feat: import agents_and_robots platform as unibots (Matrix-out, unibus transport)

Reemplaza el scaffold del echobot por la plataforma completa de bots traida
desde ~/DataProyects/Github/agents_and_robots tras la operacion Matrix-out:
los bots ya no hablan por Matrix sino por el bus unibus (modelo todo-rooms +
E2E via shell/transportunibus sobre github.com/enmanuel/unibus/pkg/client).

- go.mod: replace de unibus -> ../unibus y de fn-registry -> ../../../.. (paths
  relativos reajustados a la nueva ubicacion dentro de fn_registry).
- app.md: bump a 0.2.0, descripcion + arquitectura + comandos + gotchas reales.
- modulo Go conservado como github.com/enmanuel/agents (sin reescribir imports).

agents_and_robots queda archivado como museo de la era Matrix.

shell/llm/openai.go

@@ -0,0 +1,169 @@
+package llm
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"os"
+	"time"
+
+	openai "github.com/sashabaranov/go-openai"
+
+	coretypes "github.com/enmanuel/agents/pkg/llm"
+	"github.com/enmanuel/agents/shell/logger"
+)
+
+// NewOpenAIComplete returns a CompleteFunc backed by the OpenAI-compatible API.
+// Works with OpenAI, Ollama, vLLM, LMStudio — just change baseURL.
+func NewOpenAIComplete(apiKeyEnv, baseURL string, log *slog.Logger) coretypes.CompleteFunc {
+	return func(ctx context.Context, req coretypes.CompletionRequest) (coretypes.CompletionResponse, error) {
+		apiKey := os.Getenv(apiKeyEnv)
+		if apiKey == "" {
+			apiKey = "ollama" // Ollama doesn't require a real key
+		}
+
+		cfg := openai.DefaultConfig(apiKey)
+		if baseURL != "" {
+			cfg.BaseURL = baseURL
+		}
+		client := openai.NewClientWithConfig(cfg)
+
+		msgs := make([]openai.ChatCompletionMessage, 0, len(req.Messages)+1)
+		if req.SystemPrompt != "" {
+			msgs = append(msgs, openai.ChatCompletionMessage{
+				Role:    openai.ChatMessageRoleSystem,
+				Content: req.SystemPrompt,
+			})
+		}
+		for _, m := range req.Messages {
+			msgs = append(msgs, toOpenAIMessage(m))
+		}
+
+		openReq := openai.ChatCompletionRequest{
+			Model:       req.Model,
+			Messages:    msgs,
+			MaxTokens:   req.MaxTokens,
+			Temperature: float32(req.Temperature),
+		}
+
+		// Add tools if present
+		if len(req.Tools) > 0 {
+			openReq.Tools = toOpenAITools(req.Tools)
+		}
+
+		log.Info("llm_request",
+			"provider", "openai",
+			"model", req.Model,
+			"messages", len(req.Messages),
+			"tools", len(req.Tools),
+		)
+
+		start := time.Now()
+		resp, err := client.CreateChatCompletion(ctx, openReq)
+		if err != nil {
+			ms := time.Since(start).Milliseconds()
+			log.Error("llm_error", "provider", "openai", logger.FieldDurationMS, ms, "err", err)
+			return coretypes.CompletionResponse{}, fmt.Errorf("openai completion: %w", err)
+		}
+		ms := time.Since(start).Milliseconds()
+
+		if len(resp.Choices) == 0 {
+			log.Error("llm_error", "provider", "openai", logger.FieldDurationMS, ms, "err", "empty choices")
+			return coretypes.CompletionResponse{}, fmt.Errorf("openai: empty choices")
+		}
+
+		choice := resp.Choices[0]
+		var toolCalls []coretypes.ToolCall
+		for _, tc := range choice.Message.ToolCalls {
+			toolCalls = append(toolCalls, coretypes.ToolCall{
+				ID:        tc.ID,
+				Name:      tc.Function.Name,
+				Arguments: tc.Function.Arguments,
+			})
+		}
+
+		log.Info("llm_response",
+			"provider", "openai",
+			"model", req.Model,
+			logger.FieldDurationMS, ms,
+			logger.FieldTokensUsed, resp.Usage.TotalTokens,
+			"input_tokens", resp.Usage.PromptTokens,
+			"output_tokens", resp.Usage.CompletionTokens,
+			"tool_calls", len(toolCalls),
+			"finish_reason", string(choice.FinishReason),
+		)
+
+		return coretypes.CompletionResponse{
+			Content:      choice.Message.Content,
+			ToolCalls:    toolCalls,
+			FinishReason: string(choice.FinishReason),
+			Usage: coretypes.TokenUsage{
+				InputTokens:  resp.Usage.PromptTokens,
+				OutputTokens: resp.Usage.CompletionTokens,
+				TotalTokens:  resp.Usage.TotalTokens,
+			},
+		}, nil
+	}
+}
+
+// toOpenAIMessage converts a core Message to an OpenAI ChatCompletionMessage.
+func toOpenAIMessage(m coretypes.Message) openai.ChatCompletionMessage {
+	role := openai.ChatMessageRoleUser
+	switch m.Role {
+	case coretypes.RoleAssistant:
+		role = openai.ChatMessageRoleAssistant
+	case coretypes.RoleSystem:
+		role = openai.ChatMessageRoleSystem
+	case coretypes.RoleTool:
+		role = openai.ChatMessageRoleTool
+	}
+
+	msg := openai.ChatCompletionMessage{
+		Role:       role,
+		Content:    m.Content,
+		ToolCallID: m.ToolCallID,
+	}
+
+	// Assistant messages with tool calls
+	if m.Role == coretypes.RoleAssistant && len(m.ToolCalls) > 0 {
+		msg.ToolCalls = make([]openai.ToolCall, len(m.ToolCalls))
+		for i, tc := range m.ToolCalls {
+			msg.ToolCalls[i] = openai.ToolCall{
+				ID:   tc.ID,
+				Type: openai.ToolTypeFunction,
+				Function: openai.FunctionCall{
+					Name:      tc.Name,
+					Arguments: tc.Arguments,
+				},
+			}
+		}
+	}
+
+	return msg
+}
+
+// toOpenAITools converts core ToolSpecs to OpenAI Tool format.
+func toOpenAITools(specs []coretypes.ToolSpec) []openai.Tool {
+	tools := make([]openai.Tool, len(specs))
+	for i, s := range specs {
+		tools[i] = openai.Tool{
+			Type: openai.ToolTypeFunction,
+			Function: &openai.FunctionDefinition{
+				Name:        s.Name,
+				Description: s.Description,
+				Parameters:  json.RawMessage(marshalSchema(s.InputSchema)),
+			},
+		}
+	}
+	return tools
+}
+
+// marshalSchema marshals a JSON schema map to bytes. Falls back to empty object.
+func marshalSchema(schema map[string]any) []byte {
+	b, err := json.Marshal(schema)
+	if err != nil {
+		return []byte("{}")
+	}
+	return b
+}