dataforge/agents_and_robots
1
0
Fork 0
Code Issues Pull Requests 2 Actions Packages Projects Releases Wiki Activity

feat: añadir claude-code como proveedor LLM via claude -p

Browse Source 
Implementa un nuevo proveedor LLM que ejecuta 'claude -p' como subproceso,
permitiendo usar Claude Code como backend de cualquier agente Matrix.

Cambios:
- pkg/llm/types.go: nueva constante ProviderClaudeCode
- pkg/llm/router.go: routing de 'claude-code' antes de 'claude*' (Anthropic API)
- internal/config/schema.go: nuevo tipo ClaudeCodeCfg con campos para binary,
  timeout, disable_tools, allowed/disallowed tools, permission_mode, model,
  fallback_model, session_id y add_dirs
- shell/llm/claudecode.go: provider completo — buildClaudeArgs(), flattenMessages(),
  parseClaudeOutput() y filterEnv() para limpiar ANTHROPIC_API_KEY del entorno
  y que claude use su propia auth OAuth
- shell/llm/factory.go: case 'claude-code' en FromConfig(), WithFallback() ahora
  recibe fallbackCfg para sobreescribir model/max_tokens al hacer fallback
- agents/runtime.go: actualizado para pasar fallbackCfg a WithFallback()

No se tocó: los proveedores existentes (anthropic.go, openai.go), el core puro
de decision ni el listener de Matrix.
This commit is contained in:
Enmanuel
2026-03-06 22:14:28 +00:00
parent bff41b9ccd
commit 4634ad104b
6 changed files with 283 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files
agents/runtime.go
+1 -1
View File
@@ -129,7 +129,7 @@ func New(cfg *config.AgentConfig, rules []decision.Rule, logger *slog.Logger) (*
if err != nil {
logger.Warn("fallback LLM config error", "err", err)
} else {
llmFunc = shelllm.WithFallback(primaryLLM, fallbackLLM, llmLog)
llmFunc = shelllm.WithFallback(primaryLLM, fallbackLLM, cfg.LLM.Fallback, llmLog)
}
}
internal/config/schema.go
+18
View File
@@ -80,6 +80,24 @@ type LLMProviderCfg struct {
BaseURL string `yaml:"base_url"`
MaxTokens int `yaml:"max_tokens"`
Temperature float64 `yaml:"temperature"`
// ClaudeCode holds configuration for the claude-code provider (claude -p).
ClaudeCode ClaudeCodeCfg `yaml:"claude_code"`
}
// ClaudeCodeCfg configures the claude -p subprocess provider.
type ClaudeCodeCfg struct {
Binary string `yaml:"binary"` // path to claude binary (default: "claude")
Timeout time.Duration `yaml:"timeout"` // subprocess timeout (default: 5m)
DisableTools bool `yaml:"disable_tools"` // pass --tools "" to disable all internal tools
AllowedTools []string `yaml:"allowed_tools"` // tools claude -p can use internally (e.g. Bash, Read, Edit)
DisallowedTools []string `yaml:"disallowed_tools"` // tools to block
WorkingDir string `yaml:"working_dir"` // working directory for claude -p
PermissionMode string `yaml:"permission_mode"` // default, acceptEdits, bypassPermissions, plan
Model string `yaml:"model"` // inner model: sonnet, opus, haiku, or full name
FallbackModel string `yaml:"fallback_model"` // fallback model if primary is overloaded
SessionID string `yaml:"session_id"` // fixed session ID for continuity
AddDirs []string `yaml:"add_dirs"` // additional directories accessible
}
type LLMReasoningCfg struct {
pkg/llm/router.go
+2
View File
@@ -5,6 +5,8 @@ import "strings"
// Route maps a model string to its provider. Pure function.
func Route(model string) ProviderID {
switch {
case model == "claude-code" || strings.HasPrefix(model, "claude-code/"):
return ProviderClaudeCode
case strings.HasPrefix(model, "claude"):
return ProviderAnthropic
case strings.HasPrefix(model, "gpt"), strings.HasPrefix(model, "o1"), strings.HasPrefix(model, "o3"):
pkg/llm/types.go
+4 -3
View File
@@ -16,9 +16,10 @@ const (
type ProviderID string
const (
ProviderAnthropic ProviderID = "anthropic"
ProviderOpenAI ProviderID = "openai"
ProviderOllama ProviderID = "ollama"
ProviderAnthropic ProviderID = "anthropic"
ProviderOpenAI ProviderID = "openai"
ProviderOllama ProviderID = "ollama"
ProviderClaudeCode ProviderID = "claude-code"
)
type Message struct {
shell/llm/claudecode.go
+247
View File
@@ -0,0 +1,247 @@
package llm
import (
"bytes"
"context"
"encoding/json"
"fmt"
"log/slog"
"os"
"os/exec"
"strings"
"time"
"github.com/enmanuel/agents/internal/config"
coretypes "github.com/enmanuel/agents/pkg/llm"
)
const (
defaultClaudeBinary = "claude"
defaultClaudeTimeout = 5 * time.Minute
)
// claudeJSONOutput represents the JSON output from `claude -p --output-format json`.
type claudeJSONOutput struct {
Type string `json:"type"`
Subtype string `json:"subtype"`
CostUSD float64 `json:"cost_usd"`
IsError bool `json:"is_error"`
Duration float64 `json:"duration_api_ms"`
NumTurns int `json:"num_turns"`
Result string `json:"result"`
SessionID string `json:"session_id"`
TotalCost float64 `json:"total_cost_usd"`
Usage claudeUsage `json:"usage"`
ContentBlock []claudeContent `json:"content"`
}
type claudeUsage struct {
InputTokens int `json:"input_tokens"`
OutputTokens int `json:"output_tokens"`
}
type claudeContent struct {
Type string `json:"type"`
Text string `json:"text"`
}
// NewClaudeCodeComplete creates a CompleteFunc that executes `claude -p` as a subprocess.
func NewClaudeCodeComplete(cfg config.ClaudeCodeCfg, log *slog.Logger) coretypes.CompleteFunc {
binary := cfg.Binary
if binary == "" {
binary = defaultClaudeBinary
}
timeout := cfg.Timeout
if timeout <= 0 {
timeout = defaultClaudeTimeout
}
return func(ctx context.Context, req coretypes.CompletionRequest) (coretypes.CompletionResponse, error) {
ctx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
args := buildClaudeArgs(cfg, req)
prompt := flattenMessages(req.Messages)
log.Debug("claude_code_exec",
"binary", binary,
"args", strings.Join(args, " "),
"prompt_len", len(prompt),
)
cmd := exec.CommandContext(ctx, binary, args...)
if cfg.WorkingDir != "" {
cmd.Dir = cfg.WorkingDir
}
// Build clean env: inherit parent but remove ANTHROPIC_API_KEY
// so claude uses its own OAuth auth instead of a potentially invalid key.
cmd.Env = filterEnv(os.Environ(), "ANTHROPIC_API_KEY")
cmd.Stdin = strings.NewReader(prompt)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
start := time.Now()
err := cmd.Run()
elapsed := time.Since(start)
log.Debug("claude_code_done",
"elapsed_ms", elapsed.Milliseconds(),
"stdout_len", stdout.Len(),
"stderr_len", stderr.Len(),
"exit_err", err,
)
return parseClaudeOutput(stdout.Bytes(), stderr.Bytes(), err, elapsed, log)
}
}
// buildClaudeArgs constructs the CLI arguments for claude -p.
func buildClaudeArgs(cfg config.ClaudeCodeCfg, req coretypes.CompletionRequest) []string {
args := []string{"--print", "--output-format", "json"}
if req.SystemPrompt != "" {
args = append(args, "--system-prompt", req.SystemPrompt)
}
if cfg.DisableTools {
args = append(args, "--tools", "")
} else {
if len(cfg.AllowedTools) > 0 {
args = append(args, "--allowedTools")
args = append(args, cfg.AllowedTools...)
}
if len(cfg.DisallowedTools) > 0 {
args = append(args, "--disallowedTools")
args = append(args, cfg.DisallowedTools...)
}
}
if cfg.PermissionMode != "" {
args = append(args, "--permission-mode", cfg.PermissionMode)
}
if cfg.Model != "" {
args = append(args, "--model", cfg.Model)
}
if cfg.FallbackModel != "" {
args = append(args, "--fallback-model", cfg.FallbackModel)
}
if cfg.SessionID != "" {
args = append(args, "--session-id", cfg.SessionID)
}
for _, dir := range cfg.AddDirs {
args = append(args, "--add-dir", dir)
}
return args
}
// flattenMessages converts a conversation history into a single text prompt for stdin.
func flattenMessages(msgs []coretypes.Message) string {
var b strings.Builder
for _, m := range msgs {
switch m.Role {
case coretypes.RoleUser:
fmt.Fprintf(&b, "User: %s\n\n", m.Content)
case coretypes.RoleAssistant:
fmt.Fprintf(&b, "Assistant: %s\n\n", m.Content)
case coretypes.RoleTool:
fmt.Fprintf(&b, "Tool result: %s\n\n", m.Content)
}
}
return b.String()
}
// parseClaudeOutput parses the JSON output from `claude -p --output-format json`.
func parseClaudeOutput(
stdout, stderr []byte,
execErr error,
elapsed time.Duration,
log *slog.Logger,
) (coretypes.CompletionResponse, error) {
// If the process failed and there's no stdout, report the error
if execErr != nil && len(stdout) == 0 {
errMsg := string(stderr)
if errMsg == "" {
errMsg = execErr.Error()
}
return coretypes.CompletionResponse{}, fmt.Errorf("claude-code process failed: %s", errMsg)
}
// Parse JSON output
var output claudeJSONOutput
if err := json.Unmarshal(stdout, &output); err != nil {
// Fall back to treating stdout as plain text
log.Warn("claude_code_json_parse_failed", "err", err, "stdout_len", len(stdout))
return coretypes.CompletionResponse{
Content: strings.TrimSpace(string(stdout)),
FinishReason: "stop",
}, nil
}
if output.IsError {
return coretypes.CompletionResponse{}, fmt.Errorf("claude-code error: %s", output.Result)
}
// Extract text from result field or content blocks
content := output.Result
if content == "" && len(output.ContentBlock) > 0 {
var parts []string
for _, block := range output.ContentBlock {
if block.Type == "text" && block.Text != "" {
parts = append(parts, block.Text)
}
}
content = strings.Join(parts, "\n")
}
finishReason := "stop"
if execErr != nil {
finishReason = "error"
}
log.Info("claude_code_response",
"content_len", len(content),
"input_tokens", output.Usage.InputTokens,
"output_tokens", output.Usage.OutputTokens,
"num_turns", output.NumTurns,
"cost_usd", output.TotalCost,
"elapsed_ms", elapsed.Milliseconds(),
)
return coretypes.CompletionResponse{
Content: content,
Usage: coretypes.TokenUsage{
InputTokens: output.Usage.InputTokens,
OutputTokens: output.Usage.OutputTokens,
TotalTokens: output.Usage.InputTokens + output.Usage.OutputTokens,
},
FinishReason: finishReason,
}, nil
}
// filterEnv returns a copy of environ with the named keys removed.
func filterEnv(environ []string, keys ...string) []string {
out := make([]string, 0, len(environ))
for _, e := range environ {
skip := false
for _, k := range keys {
if strings.HasPrefix(e, k+"=") {
skip = true
break
}
}
if !skip {
out = append(out, e)
}
}
return out
}
shell/llm/factory.go
+11 -2
View File
@@ -23,18 +23,27 @@ func FromConfig(cfg config.LLMProviderCfg, log *slog.Logger) (coretypes.Complete
base = "http://localhost:11434/v1"
}
return NewOpenAIComplete("OLLAMA_API_KEY", base, log), nil
case "claude-code":
return NewClaudeCodeComplete(cfg.ClaudeCode, log), nil
default:
return nil, fmt.Errorf("unknown LLM provider: %s", cfg.Provider)
}
}
// WithFallback wraps primary with a fallback CompleteFunc.
// If primary returns an error, fallback is tried.
func WithFallback(primary, fallback coretypes.CompleteFunc, log *slog.Logger) coretypes.CompleteFunc {
// If primary returns an error, fallback is tried with the fallback config's model.
func WithFallback(primary, fallback coretypes.CompleteFunc, fallbackCfg config.LLMProviderCfg, log *slog.Logger) coretypes.CompleteFunc {
return func(ctx context.Context, req coretypes.CompletionRequest) (coretypes.CompletionResponse, error) {
resp, err := primary(ctx, req)
if err != nil {
log.Warn("llm_fallback_triggered", "primary_err", err)
// Override request fields with fallback config values
if fallbackCfg.Model != "" {
req.Model = fallbackCfg.Model
}
if fallbackCfg.MaxTokens > 0 {
req.MaxTokens = fallbackCfg.MaxTokens
}
return fallback(ctx, req)
}
return resp, nil