feat(ai): add ai/tools helper and 'micro chat' interactive agent

Extract the registry-discovery + RPC-execution loop from the web
agent playground into a reusable ai/tools package:

- tools.New(reg) creates a Set bound to a registry
- Set.Discover() walks the registry and returns []ai.Tool with
  LLM-safe (underscored) names, remembering the mapping back to
  the original dotted form
- Set.Handler(client) returns an ai.ToolHandler that resolves
  the safe name and issues the RPC

Add cmd/micro/chat — an interactive 'micro chat' REPL that uses
ai/tools to let users talk to their services through any
registered AI provider. Supports --prompt for single-shot use,
auto-detects the provider from --base_url, and falls back to the
provider's conventional env var (ANTHROPIC_API_KEY, etc).

Update README with the new command and the programmatic example.

Author: claude

README.md

@@ -149,6 +149,34 @@ micro run
 
 Use `micro mcp serve` for local AI tools like Claude Code, or connect any MCP-compatible agent to the HTTP endpoint.
 
+### micro chat
+
+For an interactive terminal session that lets you talk to your services through an LLM:
+
+```bash
+ANTHROPIC_API_KEY=sk-ant-... micro chat --provider anthropic
+> list all users
+> create an order for product 42
+```
+
+`micro chat` discovers every service in the registry, exposes each endpoint as a tool, and lets the model orchestrate calls. The same building blocks (`ai/tools`) work from your own services:
+
+```go
+import "go-micro.dev/v5/ai/tools"
+
+set := tools.New(service.Registry())
+discovered, _ := set.Discover()
+
+m := ai.New("anthropic",
+    ai.WithAPIKey(key),
+    ai.WithToolHandler(set.Handler(service.Client())),
+)
+resp, _ := m.Generate(ctx, &ai.Request{
+    Prompt: userInput,
+    Tools:  discovered,
+})
+```
+
 See the [MCP guide](https://go-micro.dev/docs/mcp.html) for authentication, scopes, and advanced usage.
 
 ## Multi-Service Binaries

ai/tools/tools.go

@@ -0,0 +1,197 @@
+// Package tools turns go-micro services into ai.Tool definitions and
+// provides an ai.ToolHandler that executes tool calls by issuing RPCs
+// to the corresponding service.
+//
+// This is the building block that lets any go-micro service reason
+// about and call other services through an LLM:
+//
+//	m := ai.New("anthropic",
+//	    ai.WithAPIKey(key),
+//	    ai.WithToolHandler(tools.Handler(service.Client())),
+//	)
+//	resp, _ := m.Generate(ctx, &ai.Request{
+//	    Prompt: userInput,
+//	    Tools:  tools.FromRegistry(service.Registry()),
+//	})
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"sync"
+
+	"go-micro.dev/v5/ai"
+	"go-micro.dev/v5/client"
+	codecBytes "go-micro.dev/v5/codec/bytes"
+	"go-micro.dev/v5/registry"
+)
+
+// nameMap holds the mapping between LLM-safe tool names (no dots) and the
+// original `service.Endpoint` names used by the registry/client. Many
+// providers reject dots in tool names, so we substitute underscores when
+// presenting the tool and restore the original when executing.
+type nameMap struct {
+	mu sync.RWMutex
+	m  map[string]string
+}
+
+func (n *nameMap) put(safe, original string) {
+	n.mu.Lock()
+	n.m[safe] = original
+	n.mu.Unlock()
+}
+
+func (n *nameMap) get(safe string) (string, bool) {
+	n.mu.RLock()
+	v, ok := n.m[safe]
+	n.mu.RUnlock()
+	return v, ok
+}
+
+// Set is the shared discovery state between FromRegistry and Handler.
+// Use New, then Discover + Handler together when you want the handler
+// to recognise LLM-safe tool names that were emitted by Discover.
+//
+// FromRegistry+Handler are convenience wrappers that create their own
+// internal Set; Set is exposed for callers that want to control the
+// lifecycle (e.g. cache the tool list and reuse it across turns).
+type Set struct {
+	registry registry.Registry
+	names    *nameMap
+}
+
+// New creates an empty Set bound to the given registry. Call Discover
+// to populate it. The registry is only used by Discover; Handler does
+// not need it.
+func New(reg registry.Registry) *Set {
+	return &Set{
+		registry: reg,
+		names:    &nameMap{m: map[string]string{}},
+	}
+}
+
+// Discover walks the registry and returns one ai.Tool per service
+// endpoint. The returned tools have LLM-safe names (dots replaced with
+// underscores); the Set remembers the mapping so Handler can route
+// calls back to the right service.
+func (s *Set) Discover() ([]ai.Tool, error) {
+	services, err := s.registry.ListServices()
+	if err != nil {
+		return nil, err
+	}
+
+	var tools []ai.Tool
+	for _, svc := range services {
+		full, err := s.registry.GetService(svc.Name)
+		if err != nil || len(full) == 0 {
+			continue
+		}
+		for _, ep := range full[0].Endpoints {
+			original := fmt.Sprintf("%s.%s", svc.Name, ep.Name)
+			safe := strings.ReplaceAll(original, ".", "_")
+			s.names.put(safe, original)
+
+			desc := fmt.Sprintf("Call %s on %s service", ep.Name, svc.Name)
+			if ep.Metadata != nil {
+				if d, ok := ep.Metadata["description"]; ok && d != "" {
+					desc = d
+				}
+			}
+
+			props := map[string]any{}
+			if ep.Request != nil {
+				for _, field := range ep.Request.Values {
+					props[field.Name] = map[string]any{
+						"type":        jsonType(field.Type),
+						"description": fmt.Sprintf("%s (%s)", field.Name, field.Type),
+					}
+				}
+			}
+
+			tools = append(tools, ai.Tool{
+				Name:         safe,
+				OriginalName: original,
+				Description:  desc,
+				Properties:   props,
+			})
+		}
+	}
+
+	return tools, nil
+}
+
+// Handler returns an ai.ToolHandler that executes tool calls against
+// the given client. Tool names may be the LLM-safe form (with
+// underscores) emitted by Discover or the original dotted form; both
+// resolve to the same RPC.
+func (s *Set) Handler(c client.Client) ai.ToolHandler {
+	if c == nil {
+		c = client.DefaultClient
+	}
+	return func(name string, input map[string]any) (any, string) {
+		if orig, ok := s.names.get(name); ok {
+			name = orig
+		}
+		parts := strings.SplitN(name, ".", 2)
+		if len(parts) != 2 {
+			return errResult("invalid tool name: " + name)
+		}
+
+		inputBytes, err := json.Marshal(input)
+		if err != nil {
+			return errResult("failed to marshal input: " + err.Error())
+		}
+
+		req := c.NewRequest(parts[0], parts[1], &codecBytes.Frame{Data: inputBytes})
+		var rsp codecBytes.Frame
+		if err := c.Call(context.Background(), req, &rsp); err != nil {
+			return errResult(err.Error())
+		}
+
+		var result any
+		if err := json.Unmarshal(rsp.Data, &result); err != nil {
+			result = string(rsp.Data)
+		}
+		return result, string(rsp.Data)
+	}
+}
+
+// FromRegistry is a convenience that builds a one-shot Set, discovers
+// tools, and returns just the tool list. Use NewSet directly if you
+// need to also wire up Handler against the same name mapping.
+func FromRegistry(reg registry.Registry) ([]ai.Tool, error) {
+	return New(reg).Discover()
+}
+
+// Handler is a convenience that returns an ai.ToolHandler bound to the
+// given client. It only resolves dotted "service.Endpoint" names — it
+// has no awareness of any LLM-safe name mapping. For full round-tripping
+// of underscored names emitted by FromRegistry, construct a Set with
+// New and call Set.Handler.
+func Handler(c client.Client) ai.ToolHandler {
+	return (&Set{names: &nameMap{m: map[string]string{}}}).Handler(c)
+}
+
+func errResult(msg string) (any, string) {
+	encoded, _ := json.Marshal(map[string]string{"error": msg})
+	return map[string]string{"error": msg}, string(encoded)
+}
+
+// jsonType maps Go types to JSON schema types. Anything that isn't a
+// recognised primitive becomes "object".
+func jsonType(goType string) string {
+	switch goType {
+	case "string":
+		return "string"
+	case "int", "int32", "int64", "uint", "uint32", "uint64":
+		return "integer"
+	case "float32", "float64":
+		return "number"
+	case "bool":
+		return "boolean"
+	default:
+		return "object"
+	}
+}

ai/tools/tools_test.go

@@ -0,0 +1,123 @@
+package tools
+
+import (
+	"testing"
+
+	"go-micro.dev/v5/registry"
+)
+
+func TestJSONType(t *testing.T) {
+	cases := map[string]string{
+		"string":  "string",
+		"int":     "integer",
+		"int64":   "integer",
+		"float64": "number",
+		"bool":    "boolean",
+		"User":    "object",
+		"":        "object",
+	}
+	for in, want := range cases {
+		if got := jsonType(in); got != want {
+			t.Errorf("jsonType(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+func TestFromRegistry_Empty(t *testing.T) {
+	reg := registry.NewMemoryRegistry()
+	tools, err := FromRegistry(reg)
+	if err != nil {
+		t.Fatalf("FromRegistry: %v", err)
+	}
+	if len(tools) != 0 {
+		t.Errorf("expected 0 tools, got %d", len(tools))
+	}
+}
+
+func TestFromRegistry_DiscoversEndpoints(t *testing.T) {
+	reg := registry.NewMemoryRegistry()
+	svc := &registry.Service{
+		Name:    "users",
+		Version: "1.0.0",
+		Nodes: []*registry.Node{
+			{Id: "users-1", Address: "127.0.0.1:9000"},
+		},
+		Endpoints: []*registry.Endpoint{
+			{
+				Name: "Users.Get",
+				Metadata: map[string]string{
+					"description": "Fetch a user by ID",
+				},
+				Request: &registry.Value{
+					Name: "GetRequest",
+					Type: "GetRequest",
+					Values: []*registry.Value{
+						{Name: "id", Type: "string"},
+						{Name: "expand", Type: "bool"},
+					},
+				},
+			},
+		},
+	}
+	if err := reg.Register(svc); err != nil {
+		t.Fatalf("Register: %v", err)
+	}
+
+	tools, err := FromRegistry(reg)
+	if err != nil {
+		t.Fatalf("FromRegistry: %v", err)
+	}
+	if len(tools) != 1 {
+		t.Fatalf("expected 1 tool, got %d", len(tools))
+	}
+
+	tool := tools[0]
+	if tool.Name != "users_Users_Get" {
+		t.Errorf("safe name = %q, want users_Users_Get", tool.Name)
+	}
+	if tool.OriginalName != "users.Users.Get" {
+		t.Errorf("original = %q", tool.OriginalName)
+	}
+	if tool.Description != "Fetch a user by ID" {
+		t.Errorf("description = %q", tool.Description)
+	}
+
+	id, ok := tool.Properties["id"].(map[string]any)
+	if !ok {
+		t.Fatal("missing id property")
+	}
+	if id["type"] != "string" {
+		t.Errorf("id type = %v", id["type"])
+	}
+	expand, ok := tool.Properties["expand"].(map[string]any)
+	if !ok {
+		t.Fatal("missing expand property")
+	}
+	if expand["type"] != "boolean" {
+		t.Errorf("expand type = %v", expand["type"])
+	}
+}
+
+func TestSet_HandlerResolvesSafeName(t *testing.T) {
+	s := New(registry.NewMemoryRegistry())
+	s.names.put("users_Users_Get", "users.Users.Get")
+
+	resolved, ok := s.names.get("users_Users_Get")
+	if !ok || resolved != "users.Users.Get" {
+		t.Errorf("name map lookup = (%q, %v)", resolved, ok)
+	}
+}
+
+func TestSet_HandlerInvalidName(t *testing.T) {
+	s := New(registry.NewMemoryRegistry())
+	h := s.Handler(nil)
+
+	// "foo" has no dot, no mapping entry — should error cleanly.
+	result, content := h("foo", map[string]any{})
+	if result == nil {
+		t.Fatal("expected error result")
+	}
+	if content == "" {
+		t.Error("expected non-empty content")
+	}
+}