Nested builtin tool input errors repeat an absolute schema path at every recursion level. Unwrap the validator's error chain to retain only the innermost path wrapper and its cause, with a comment explaining the dependency's wrapping behavior. Also remove the redundant sentence about exact property names and duplicate keys from the retry guidance. Existing schema-validation tests now assert complete tool error messages for root failures, nested properties, arrays, and maps. Validation behavior and diagnostics embedded in the cause are preserved. Refs #31541.
147 lines
5.3 KiB
Go
147 lines
5.3 KiB
Go
package chatd
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
|
|
"charm.land/fantasy"
|
|
"github.com/google/jsonschema-go/jsonschema"
|
|
"golang.org/x/xerrors"
|
|
|
|
"github.com/coder/coder/v2/coderd/x/chatd/chathooks"
|
|
"github.com/coder/coder/v2/coderd/x/chatd/toolschema"
|
|
)
|
|
|
|
// partitionInvalidToolCalls rejects malformed JSON and invalid builtin inputs
|
|
// before pre_tool_use or execution. Synthetic tool errors let the model correct
|
|
// its arguments without failing the turn. allowedIndexes maps allowed calls
|
|
// back to the input order without relying on duplicate-prone IDs.
|
|
func partitionInvalidToolCalls(
|
|
prepared turnEnvironment,
|
|
toolCalls []fantasy.ToolCallContent,
|
|
) (allowed []fantasy.ToolCallContent, allowedIndexes []int, rejected []fantasy.ToolResultContent) {
|
|
for i, toolCall := range toolCalls {
|
|
if !json.Valid([]byte(toolCall.Input)) {
|
|
rejected = append(rejected, malformedToolResult(toolCall))
|
|
continue
|
|
}
|
|
if err := validateBuiltinToolInput(prepared, toolCall.ToolName, []byte(toolCall.Input)); err != nil {
|
|
rejected = append(rejected, invalidToolInputResult(toolCall, err))
|
|
continue
|
|
}
|
|
allowed = append(allowed, toolCall)
|
|
allowedIndexes = append(allowedIndexes, i)
|
|
}
|
|
return allowed, allowedIndexes, rejected
|
|
}
|
|
|
|
// validateOverriddenToolInputs rechecks the inputs a pre_tool_use consumer
|
|
// replaced. The model cannot fix an invalid override, so the turn fails
|
|
// closed instead of executing it.
|
|
func validateOverriddenToolInputs(prepared turnEnvironment, preflight chathooks.PreToolUseExecutionResult) error {
|
|
for _, toolCall := range preflight.Allowed {
|
|
if _, overridden := preflight.Overrides[toolCall.ToolCallID]; !overridden {
|
|
continue
|
|
}
|
|
if err := validateBuiltinToolInput(prepared, toolCall.ToolName, []byte(toolCall.Input)); err != nil {
|
|
return xerrors.Errorf("hook input override for tool %s: %w", toolCall.ToolName, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// validateBuiltinToolInput only guards builtin tools, whose input coderd
|
|
// decodes itself. Dynamic calls are executed by the client and MCP calls by
|
|
// their own server, and a dynamic tool cannot shadow a builtin name.
|
|
func validateBuiltinToolInput(prepared turnEnvironment, toolName string, input []byte) error {
|
|
if !prepared.BuiltinToolNames[toolName] {
|
|
return nil
|
|
}
|
|
for _, tool := range prepared.Tools {
|
|
info := tool.Info()
|
|
if info.Name != toolName {
|
|
continue
|
|
}
|
|
if err := toolschema.ValidateUnambiguous(info.Parameters, input); err != nil {
|
|
return err
|
|
}
|
|
schemaJSON, err := json.Marshal(info.Parameters)
|
|
if err != nil {
|
|
return xerrors.Errorf("marshal tool schema: %w", err)
|
|
}
|
|
schema := jsonschema.Schema{Type: "object", Required: info.Required}
|
|
if err := json.Unmarshal(schemaJSON, &schema.Properties); err != nil {
|
|
return xerrors.Errorf("decode tool schema: %w", err)
|
|
}
|
|
normalizeToolMapSchemas(&schema)
|
|
compiled, err := schema.Resolve(nil)
|
|
if err != nil {
|
|
return xerrors.Errorf("compile tool schema: %w", err)
|
|
}
|
|
var value any
|
|
if err := json.Unmarshal(input, &value); err != nil {
|
|
return xerrors.Errorf("decode tool input: %w", err)
|
|
}
|
|
// jsonschema-go wraps each recursive error with an absolute schema path.
|
|
// Keep the innermost wrapper so the location and cause are reported once,
|
|
// without repeating every ancestor path.
|
|
err = compiled.Validate(value)
|
|
for {
|
|
cause := errors.Unwrap(err)
|
|
if cause == nil || errors.Unwrap(cause) == nil {
|
|
return err
|
|
}
|
|
err = cause
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// normalizeToolMapSchemas translates Fantasy's map[string]T wildcard property
|
|
// into JSON Schema's additionalProperties, leaving the tool metadata intact.
|
|
func normalizeToolMapSchemas(schema *jsonschema.Schema) {
|
|
if schema == nil {
|
|
return
|
|
}
|
|
for _, property := range schema.Properties {
|
|
normalizeToolMapSchemas(property)
|
|
}
|
|
normalizeToolMapSchemas(schema.Items)
|
|
normalizeToolMapSchemas(schema.AdditionalProperties)
|
|
for _, branches := range [][]*jsonschema.Schema{schema.AnyOf, schema.OneOf, schema.AllOf} {
|
|
for _, branch := range branches {
|
|
normalizeToolMapSchemas(branch)
|
|
}
|
|
}
|
|
if value, wildcard := schema.Properties["*"]; wildcard && len(schema.Properties) == 1 && schema.AdditionalProperties == nil {
|
|
schema.AdditionalProperties = value
|
|
schema.Properties = nil
|
|
}
|
|
}
|
|
|
|
// malformedToolResult reports input the tool decoder would reject anyway. It
|
|
// is produced here because a hook payload carries the input as JSON, so
|
|
// invalid bytes would otherwise surface as a dispatch failure and end the
|
|
// turn instead of letting the model correct the call.
|
|
func malformedToolResult(toolCall fantasy.ToolCallContent) fantasy.ToolResultContent {
|
|
return fantasy.ToolResultContent{
|
|
ToolCallID: toolCall.ToolCallID,
|
|
ToolName: toolCall.ToolName,
|
|
Result: fantasy.ToolResultOutputContentError{
|
|
Error: xerrors.New("This tool call was not executed because its input is not valid JSON. Retry with a well-formed JSON object matching the tool schema."),
|
|
},
|
|
}
|
|
}
|
|
|
|
func invalidToolInputResult(toolCall fantasy.ToolCallContent, err error) fantasy.ToolResultContent {
|
|
message := "This tool call was not executed because its input is invalid: " + err.Error() +
|
|
". Retry with a JSON object matching the tool schema, including all required properties and their declared types."
|
|
return fantasy.ToolResultContent{
|
|
ToolCallID: toolCall.ToolCallID,
|
|
ToolName: toolCall.ToolName,
|
|
Result: fantasy.ToolResultOutputContentError{
|
|
Error: xerrors.New(message),
|
|
},
|
|
}
|
|
}
|