Files
samandCopilot 64dfad6d53 feat(runs): add typed results and model aliases (#2043)
Also fix repository-free message.send validation (#2046) and add a single-binary development smoke path (#1977).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-18 23:47:35 +11:00

109 lines
3.1 KiB
Go

package runs
import (
"context"
"encoding/json/jsontext"
json "encoding/json/v2"
"errors"
"fmt"
"strings"
"github.com/google/jsonschema-go/jsonschema"
"github.com/samcharles93/ai-sdk/core"
"github.com/samcharles93/archie-core/modules/connectors"
)
// resultTool is the name of the tool that accepts a structured result.
const resultTool = "return_result"
const resultRule = "Return your result by calling " + resultTool + " exactly once, when you have it."
// resultSchema compiles the step's result schema. Tool parameters must be
// a JSON object.
func (s agentSettings) resultSchema() ([]byte, *jsonschema.Resolved, error) {
// Tool schemas are part of the journaled model request digest.
raw, err := json.Marshal(s.Result, json.Deterministic(true))
if err != nil {
return nil, nil, fmt.Errorf("schema: %w", err)
}
var schema jsonschema.Schema
if err := json.Unmarshal(raw, &schema); err != nil {
return nil, nil, fmt.Errorf("schema: %w", err)
}
if schema.Type != "object" {
return nil, nil, errors.New("a JSON Schema with type object")
}
resolved, err := schema.Resolve(nil)
if err != nil {
return nil, nil, fmt.Errorf("schema: %w", err)
}
return raw, resolved, nil
}
// resultFields are the fields the result schema declares, or nil when it
// declares none, which accepts any field.
func (s agentSettings) resultFields() map[string]bool {
props, _ := s.Result["properties"].(map[string]any)
if len(props) == 0 {
return nil
}
fields := make(map[string]bool, len(props))
for name := range props {
fields[name] = true
}
return fields
}
// system is the part of the agent's system prompt the step adds: its mission,
// its extra rules and, with a result schema, how to return it.
func (s agentSettings) system() string {
parts := []string{s.Mission}
if strings.TrimSpace(s.ExtraRules) != "" {
parts = append(parts, s.ExtraRules)
}
if s.Result != nil {
parts = append(parts, resultRule)
}
return strings.Join(parts, "\n\n")
}
// newResultTool returns validation errors to the agent so it can correct
// its result.
func newResultTool(raw []byte, schema *jsonschema.Resolved) *core.Tool {
return &core.Tool{
Name: resultTool,
Description: "Return the result of this step.",
Parameters: raw,
Execute: func(_ context.Context, input string) (string, error) {
if _, err := decodeResult(jsontext.Value(input), schema); err != nil {
return "", err
}
return "recorded", nil
},
}
}
// decodeResult reads what the agent returned and checks it against the schema.
func decodeResult(raw jsontext.Value, schema *jsonschema.Resolved) (map[string]any, error) {
var out map[string]any
if err := json.Unmarshal(raw, &out); err != nil {
return nil, fmt.Errorf("the result is not a JSON object: %w", err)
}
if err := schema.Validate(out); err != nil {
return nil, fmt.Errorf("the result doesn't match its schema: %w", err)
}
return out, nil
}
// readOnly filters tool declarations to read-only tools.
func readOnly(decls []connectors.Declaration) []connectors.Declaration {
out := make([]connectors.Declaration, 0, len(decls))
for _, d := range decls {
if d.ReadOnly {
out = append(out, d)
}
}
return out
}