Add support for multiple providers

internal/tool/tool.go

@@ -22,6 +22,8 @@ import (
 	"time"
 
 	"github.com/sashabaranov/go-openai"
+
+	"code.chimeric.al/chimerical/odidere/internal/config"
 )
 
 // fn provides template functions available to argument templates.
@@ -36,25 +38,44 @@ var fn = template.FuncMap{
 // Tools are executed as subprocesses with templated arguments.
 type Tool struct {
 	// Name uniquely identifies the tool within a registry.
-	Name string `yaml:"name"`
+	Name string
 	// Description explains the tool's purpose for the LLM.
-	Description string `yaml:"description"`
+	Description string
 	// Command is the executable path or name.
-	Command string `yaml:"command"`
+	Command string
 	// Arguments are Go templates expanded with LLM-provided parameters.
-	// Empty results after expansion are filtered out.
-	Arguments []string `yaml:"arguments"`
+	Arguments []string
 	// Parameters is a JSON Schema describing expected input from the LLM.
-	Parameters map[string]any `yaml:"parameters"`
-	// Timeout limits execution time (e.g., "30s", "5m").
-	// Empty means no timeout.
-	Timeout string `yaml:"timeout"`
-	// timeout is the parsed duration, set during registry construction.
-	timeout time.Duration `yaml:"-"`
+	Parameters map[string]any
+	// timeout is the parsed execution duration limit.
+	timeout time.Duration
+}
+
+// NewTool creates a Tool from a ToolConfig.
+func NewTool(cfg config.ToolConfig) (*Tool, error) {
+	var timeout time.Duration
+	if cfg.Timeout != "" {
+		var err error
+		timeout, err = time.ParseDuration(cfg.Timeout)
+		if err != nil {
+			return nil, fmt.Errorf(
+				"invalid timeout %q: %w", cfg.Timeout, err,
+			)
+		}
+	}
+
+	return &Tool{
+		Name:        cfg.Name,
+		Description: cfg.Description,
+		Command:     cfg.Command,
+		Arguments:   cfg.Arguments,
+		Parameters:  cfg.Parameters,
+		timeout:     timeout,
+	}, nil
 }
 
 // OpenAI converts the tool to an OpenAI function definition for API calls.
-func (t Tool) OpenAI() openai.Tool {
+func (t *Tool) OpenAI() openai.Tool {
 	return openai.Tool{
 		Type: openai.ToolTypeFunction,
 		Function: &openai.FunctionDefinition{
@@ -69,13 +90,11 @@ func (t Tool) OpenAI() openai.Tool {
 // The args parameter should be a JSON object string; empty string or "{}"
 // results in an empty data map. Templates producing empty strings are
 // filtered from the result, allowing conditional arguments.
-func (t Tool) ParseArguments(args string) ([]string, error) {
+func (t *Tool) ParseArguments(args string) ([]string, error) {
 	var data = map[string]any{}
 	if args != "" && args != "{}" {
 		if err := json.Unmarshal([]byte(args), &data); err != nil {
-			return nil, fmt.Errorf(
-				"invalid arguments JSON: %w", err,
-			)
+			return nil, fmt.Errorf("invalid arguments JSON: %w", err)
 		}
 	}
 
@@ -83,16 +102,12 @@ func (t Tool) ParseArguments(args string) ([]string, error) {
 	for _, v := range t.Arguments {
 		tmpl, err := template.New("").Funcs(fn).Parse(v)
 		if err != nil {
-			return nil, fmt.Errorf(
-				"invalid template %q: %w", v, err,
-			)
+			return nil, fmt.Errorf("invalid template %q: %w", v, err)
 		}
 
 		var buf bytes.Buffer
 		if err := tmpl.Execute(&buf, data); err != nil {
-			return nil, fmt.Errorf(
-				"execute template %q: %w", v, err,
-			)
+			return nil, fmt.Errorf("execute template %q: %w", v, err)
 		}
 
 		// Filter out empty strings (unused conditional arguments).
@@ -104,35 +119,8 @@ func (t Tool) ParseArguments(args string) ([]string, error) {
 	return result, nil
 }
 
-// Validate checks that the tool definition is complete and valid.
-// It verifies required fields are present, the timeout (if specified)
-// is parseable, and all argument templates are syntactically valid.
-func (t Tool) Validate() error {
-	if t.Name == "" {
-		return fmt.Errorf("missing name")
-	}
-	if t.Description == "" {
-		return fmt.Errorf("missing description")
-	}
-	if t.Command == "" {
-		return fmt.Errorf("missing command")
-	}
-	if t.Timeout != "" {
-		if _, err := time.ParseDuration(t.Timeout); err != nil {
-			return fmt.Errorf("invalid timeout: %v", err)
-		}
-	}
-	for _, arg := range t.Arguments {
-		if _, err := template.New("").Funcs(fn).Parse(arg); err != nil {
-			return fmt.Errorf("invalid argument template")
-		}
-	}
-
-	return nil
-}
-
 // Registry holds tools indexed by name and handles their execution.
-// It validates all tools at construction time to fail fast on
+// It validates all tool definitions at construction time to fail fast on
 // configuration errors.
 type Registry struct {
 	tools map[string]*Tool
@@ -140,30 +128,20 @@ type Registry struct {
 
 // NewRegistry creates a registry from the provided tool definitions.
 // Returns an error if any tool fails validation or if duplicate names exist.
-func NewRegistry(tools []Tool) (*Registry, error) {
+func NewRegistry(tools []config.ToolConfig) (*Registry, error) {
 	var r = &Registry{
 		tools: make(map[string]*Tool),
 	}
-	for _, t := range tools {
-		if err := t.Validate(); err != nil {
-			return nil, fmt.Errorf("invalid tool: %v", err)
-		}
-		if t.Timeout != "" {
-			d, err := time.ParseDuration(t.Timeout)
-			if err != nil {
-				return nil, fmt.Errorf(
-					"parse timeout: %v", err,
-				)
-			}
-			t.timeout = d
+	for _, tc := range tools {
+		t, err := NewTool(tc)
+		if err != nil {
+			return nil, fmt.Errorf("invalid tool %q: %w", tc.Name, err)
 		}
 
 		if _, exists := r.tools[t.Name]; exists {
-			return nil, fmt.Errorf(
-				"duplicate tool name: %s", t.Name,
-			)
+			return nil, fmt.Errorf("duplicate tool name: %s", t.Name)
 		}
-		r.tools[t.Name] = &t
+		r.tools[t.Name] = t
 	}
 
 	return r, nil
@@ -185,8 +163,8 @@ func (r *Registry) List() []string {
 }
 
 // Execute runs a tool by name with the provided JSON arguments.
-// It expands argument templates, executes the command as a subprocess,
-// and returns stdout on success. The context can be used for cancellation;
+// It expands argument templates, executes the command as a subprocess, and
+// returns stdout on success. The context can be used for cancellation;
 // tool-specific timeouts are applied on top of any context deadline.
 func (r *Registry) Execute(
 	ctx context.Context, name string, args string,

internal/tool/tool_test.go

@@ -1,229 +1,135 @@
 package tool
 
 import (
-	"context"
-	"slices"
 	"testing"
 	"time"
+
+	"code.chimeric.al/chimerical/odidere/internal/config"
 )
 
-func TestToolValidate(t *testing.T) {
+func TestTool_OpenAI(t *testing.T) {
+	tool := &Tool{
+		Name:        "test_tool",
+		Description: "test description",
+		Parameters:  map[string]any{"type": "object"},
+	}
+	openaiTool := tool.OpenAI()
+	if openaiTool.Function.Name != "test_tool" {
+		t.Errorf("expected name test_tool, got %s", openaiTool.Function.Name)
+	}
+}
+
+func TestTool_ParseArguments(t *testing.T) {
+	tool := &Tool{
+		Arguments: []string{"--name {{.name}}", "{{if .flag}}--enabled{{end}}"},
+	}
+	tests := []struct {
+		name     string
+		args     string
+		expected []string
+	}{
+		{
+			name:     "basic",
+			args:     `{"name": "test"}`,
+			expected: []string{"--name test"},
+		},
+		{
+			name:     "with flag",
+			args:     `{"name": "test", "flag": true}`,
+			expected: []string{"--name test", "--enabled"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tool.ParseArguments(tt.args)
+			if err != nil {
+				t.Fatalf("ParseArguments failed: %v", err)
+			}
+			if len(got) != len(tt.expected) {
+				t.Errorf("expected len %d, got %d", len(tt.expected), len(got))
+			}
+			for i := range got {
+				if got[i] != tt.expected[i] {
+					t.Errorf("expected %q, got %q", tt.expected[i], got[i])
+				}
+			}
+		})
+	}
+}
+
+func TestNewTool(t *testing.T) {
 	tests := []struct {
 		name    string
-		tool    Tool
+		cfg     config.ToolConfig
 		wantErr bool
 	}{
 		{
-			name: "valid tool",
-			tool: Tool{
-				Name:        "echo",
-				Description: "echoes input",
-				Command:     "echo",
-				Arguments:   []string{"{{.message}}"},
-			},
-			wantErr: false,
-		},
-		{
-			name: "valid tool with timeout",
-			tool: Tool{
-				Name:        "slow",
-				Description: "slow command",
-				Command:     "sleep",
-				Arguments:   []string{"1"},
-				Timeout:     "5s",
-			},
-			wantErr: false,
-		},
-		{
-			name: "missing name",
-			tool: Tool{
-				Description: "test",
-				Command:     "echo",
-			},
-			wantErr: true,
-		},
-		{
-			name: "missing description",
-			tool: Tool{
-				Name:    "test",
-				Command: "echo",
-			},
-			wantErr: true,
-		},
-		{
-			name: "missing command",
-			tool: Tool{
+			name: "valid",
+			cfg: config.ToolConfig{
 				Name:        "test",
-				Description: "test",
+				Description: "desc",
+				Command:     "ls",
+				Timeout:     "10s",
 			},
-			wantErr: true,
+			wantErr: false,
 		},
 		{
 			name: "invalid timeout",
-			tool: Tool{
+			cfg: config.ToolConfig{
 				Name:        "test",
-				Description: "test",
-				Command:     "echo",
+				Description: "desc",
+				Command:     "ls",
 				Timeout:     "invalid",
 			},
 			wantErr: true,
 		},
-		{
-			name: "invalid template",
-			tool: Tool{
-				Name:        "test",
-				Description: "test",
-				Command:     "echo",
-				Arguments:   []string{"{{.unclosed"},
-			},
-			wantErr: true,
-		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := tt.tool.Validate()
+			tool, err := NewTool(tt.cfg)
 			if (err != nil) != tt.wantErr {
-				t.Errorf(
-					"Validate() error = %v, wantErr %v",
-					err, tt.wantErr,
-				)
+				t.Errorf("NewTool() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err == nil {
+				if tool.Name != tt.cfg.Name {
+					t.Errorf("expected name %s, got %s", tt.cfg.Name, tool.Name)
+				}
+				if tt.cfg.Timeout == "10s" && tool.timeout != 10*time.Second {
+					t.Errorf("expected timeout 10s, got %v", tool.timeout)
+				}
 			}
 		})
 	}
 }
 
-func TestToolParseArguments(t *testing.T) {
+func TestRegistry_NewRegistry(t *testing.T) {
 	tests := []struct {
 		name    string
-		tool    Tool
-		args    string
-		want    []string
+		tools   []config.ToolConfig
 		wantErr bool
 	}{
 		{
-			name: "simple substitution",
-			tool: Tool{
-				Arguments: []string{"{{.message}}"},
-			},
-			args: `{"message": "hello"}`,
-			want: []string{"hello"},
-		},
-		{
-			name: "multiple arguments",
-			tool: Tool{
-				Arguments: []string{"-n", "{{.count}}", "{{.file}}"},
-			},
-			args: `{"count": "10", "file": "test.txt"}`,
-			want: []string{"-n", "10", "test.txt"},
-		},
-		{
-			name: "conditional with if",
-			tool: Tool{
-				Arguments: []string{
-					"{{.required}}", "{{if .optional}}{{.optional}}{{end}}",
-				},
-			},
-			args: `{"required": "value"}`,
-			want: []string{"value"},
-		},
-		{
-			name: "json function",
-			tool: Tool{
-				Arguments: []string{`{{json .data}}`},
-			},
-			args: `{"data": {"key": "value"}}`,
-			want: []string{`{"key":"value"}`},
-		},
-		{
-			name: "empty JSON object",
-			tool: Tool{
-				Arguments: []string{"fixed"},
-			},
-			args: "{}",
-			want: []string{"fixed"},
-		},
-		{
-			name: "empty string args",
-			tool: Tool{
-				Arguments: []string{"fixed"},
-			},
-			args: "",
-			want: []string{"fixed"},
-		},
-		{
-			name: "invalid JSON",
-			tool: Tool{
-				Arguments: []string{"{{.x}}"},
-			},
-			args:    "not json",
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := tt.tool.ParseArguments(tt.args)
-			if (err != nil) != tt.wantErr {
-				t.Errorf(
-					"ParseArguments() error = %v, wantErr %v",
-					err, tt.wantErr,
-				)
-				return
-			}
-			if !tt.wantErr && !slices.Equal(got, tt.want) {
-				t.Errorf(
-					"ParseArguments() = %v, want %v",
-					got, tt.want,
-				)
-			}
-		})
-	}
-}
-
-func TestNewRegistry(t *testing.T) {
-	tests := []struct {
-		name    string
-		tools   []Tool
-		wantErr bool
-	}{
-		{
-			name: "valid registry",
-			tools: []Tool{
-				{Name: "a", Description: "a", Command: "echo"},
-				{Name: "b", Description: "b", Command: "cat"},
+			name: "valid",
+			tools: []config.ToolConfig{
+				{Name: "t1", Description: "d1", Command: "c1"},
+				{Name: "t2", Description: "d2", Command: "c2"},
 			},
 			wantErr: false,
 		},
 		{
-			name:    "empty registry",
-			tools:   []Tool{},
-			wantErr: false,
-		},
-		{
-			name: "duplicate names",
-			tools: []Tool{
-				{
-					Name:        "dup",
-					Description: "first",
-					Command:     "echo",
-				},
-				{
-					Name:        "dup",
-					Description: "second",
-					Command:     "cat",
-				},
+			name: "duplicate",
+			tools: []config.ToolConfig{
+				{Name: "t1", Description: "d1", Command: "c1"},
+				{Name: "t1", Description: "d2", Command: "c2"},
 			},
 			wantErr: true,
 		},
 		{
 			name: "invalid tool",
-			tools: []Tool{
-				{
-					Name:        "",
-					Description: "missing name",
-					Command:     "echo",
-				},
+			tools: []config.ToolConfig{
+				{Name: "t1", Description: "d1", Command: "c1", Timeout: "invalid"},
 			},
 			wantErr: true,
 		},
@@ -233,177 +139,8 @@ func TestNewRegistry(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			_, err := NewRegistry(tt.tools)
 			if (err != nil) != tt.wantErr {
-				t.Errorf(
-					"NewRegistry() error = %v, wantErr %v",
-					err, tt.wantErr,
-				)
+				t.Errorf("NewRegistry() error = %v, wantErr %v", err, tt.wantErr)
 			}
 		})
 	}
 }
-
-func TestRegistryGet(t *testing.T) {
-	r, err := NewRegistry([]Tool{
-		{Name: "echo", Description: "echo", Command: "echo"},
-	})
-	if err != nil {
-		t.Fatalf("NewRegistry() error = %v", err)
-	}
-
-	tool, ok := r.Get("echo")
-	if !ok {
-		t.Error("Get(echo) returned false, want true")
-	}
-	if tool.Name != "echo" {
-		t.Errorf("Get(echo).Name = %q, want %q", tool.Name, "echo")
-	}
-
-	_, ok = r.Get("nonexistent")
-	if ok {
-		t.Error("Get(nonexistent) returned true, want false")
-	}
-}
-
-func TestRegistryList(t *testing.T) {
-	r, err := NewRegistry([]Tool{
-		{Name: "a", Description: "a", Command: "echo"},
-		{Name: "b", Description: "b", Command: "cat"},
-		{Name: "c", Description: "c", Command: "ls"},
-	})
-	if err != nil {
-		t.Fatalf("NewRegistry() error = %v", err)
-	}
-
-	names := r.List()
-	if len(names) != 3 {
-		t.Errorf("List() returned %d names, want 3", len(names))
-	}
-
-	slices.Sort(names)
-	want := []string{"a", "b", "c"}
-	if !slices.Equal(names, want) {
-		t.Errorf("List() = %v, want %v", names, want)
-	}
-}
-
-func TestRegistryExecute(t *testing.T) {
-	r, err := NewRegistry([]Tool{
-		{
-			Name:        "echo",
-			Description: "echo message",
-			Command:     "echo",
-			Arguments:   []string{"{{.message}}"},
-		},
-		{
-			Name:        "cat",
-			Description: "cat stdin",
-			Command:     "cat",
-			Arguments:   []string{},
-		},
-	})
-	if err != nil {
-		t.Fatalf("NewRegistry() error = %v", err)
-	}
-
-	ctx := context.Background()
-
-	// Successful execution.
-	out, err := r.Execute(ctx, "echo", `{"message": "hello world"}`)
-	if err != nil {
-		t.Errorf("Execute(echo) error = %v", err)
-	}
-	if out != "hello world\n" {
-		t.Errorf("Execute(echo) = %q, want %q", out, "hello world\n")
-	}
-
-	// Unknown tool.
-	_, err = r.Execute(ctx, "unknown", "{}")
-	if err == nil {
-		t.Error("Execute(unknown) expected error, got nil")
-	}
-
-	// Invalid JSON arguments.
-	_, err = r.Execute(ctx, "echo", "not json")
-	if err == nil {
-		t.Error("Execute with invalid JSON expected error, got nil")
-	}
-}
-
-func TestRegistryExecuteTimeout(t *testing.T) {
-	r, err := NewRegistry([]Tool{
-		{
-			Name:        "slow",
-			Description: "slow command",
-			Command:     "sleep",
-			Arguments:   []string{"10"},
-			Timeout:     "50ms",
-		},
-	})
-	if err != nil {
-		t.Fatalf("NewRegistry() error = %v", err)
-	}
-
-	ctx := context.Background()
-	start := time.Now()
-	_, err = r.Execute(ctx, "slow", "{}")
-	elapsed := time.Since(start)
-
-	if err == nil {
-		t.Error("Execute(slow) expected timeout error, got nil")
-	}
-	if elapsed > time.Second {
-		t.Errorf(
-			"Execute(slow) took %v, expected ~50ms timeout",
-			elapsed,
-		)
-	}
-}
-
-func TestRegistryExecuteFailure(t *testing.T) {
-	r, err := NewRegistry([]Tool{
-		{
-			Name:        "fail",
-			Description: "always fails",
-			Command:     "false",
-		},
-	})
-	if err != nil {
-		t.Fatalf("NewRegistry() error = %v", err)
-	}
-
-	_, err = r.Execute(context.Background(), "fail", "{}")
-	if err == nil {
-		t.Error("Execute(fail) expected error, got nil")
-	}
-}
-
-func TestToolOpenAI(t *testing.T) {
-	tool := Tool{
-		Name:        "test",
-		Description: "test tool",
-		Command:     "echo",
-		Parameters: map[string]any{
-			"type": "object",
-			"properties": map[string]any{
-				"message": map[string]any{
-					"type":        "string",
-					"description": "the message",
-				},
-			},
-		},
-	}
-
-	openaiTool := tool.OpenAI()
-	if openaiTool.Function.Name != "test" {
-		t.Errorf(
-			"OpenAI().Function.Name = %q, want %q",
-			openaiTool.Function.Name, "test",
-		)
-	}
-	if openaiTool.Function.Description != "test tool" {
-		t.Errorf(
-			"OpenAI().Function.Description = %q, want %q",
-			openaiTool.Function.Description, "test tool",
-		)
-	}
-}