Files
coder/coderd/x/chatd/toolschema/toolschema.go
T
Hugo Dutka 457d777af1 fix(coderd/x/chatd/toolschema): traverse schema branches (#31128)
Tool input validation skipped properties declared inside composed
schemas, allowing case-variant keys to bypass ambiguity checks. Traverse
`anyOf`, `oneOf`, and `allOf` branches when checking nested objects,
arrays, and free-form map values, while preserving exact property
matches.

Generated with Codex, carefully reviewed by Hugo.
2026-10-26 17:55:48 +01:00

148 lines
4.5 KiB
Go

// Package toolschema rejects tool inputs whose object keys the Go decoder
// and a case-sensitive reader resolve differently.
package toolschema
import (
"bytes"
"encoding/json"
"maps"
"slices"
"strings"
"golang.org/x/xerrors"
)
// freeFormPropertyName is the property name fantasy generates for
// map[string]T inputs. Its keys are data, so they are checked against the
// value schema behind this name rather than against a fixed property set.
const freeFormPropertyName = "*"
// ValidateUnambiguous reports an error when input holds an object key that
// encoding/json folds into a declared property but a case-sensitive reader
// treats as distinct, or when one object repeats a key. Either lets code
// inspecting the raw input read one value while the tool executes another.
//
// properties is a fantasy ToolInfo.Parameters map, keyed by property name.
// Declared properties are collected across anyOf, oneOf, and allOf branches;
// this checks key ambiguity without validating which branches match.
// Keys matching no property are ignored because a generated struct decoder
// drops them. A tool with a hand-written decoder that reads undeclared keys
// has to reject ambiguous spellings of those keys itself.
func ValidateUnambiguous(properties map[string]any, input []byte) error {
decoder := json.NewDecoder(bytes.NewReader(input))
token, err := decoder.Token()
// Input that does not parse here does not decode for the tool either,
// so its own decode reports the failure.
if err != nil || token != json.Delim('{') {
return nil
}
return validateObject([]map[string]any{properties}, decoder, "")
}
func validateObject(propertySets []map[string]any, decoder *json.Decoder, parent string) error {
seen := make(map[string]struct{})
for {
token, err := decoder.Token()
if err != nil {
return nil
}
if token == json.Delim('}') {
return nil
}
key, ok := token.(string)
if !ok {
return nil
}
path := key
if parent != "" {
path = parent + "." + key
}
if _, duplicate := seen[key]; duplicate {
return xerrors.Errorf("input repeats the key %q", path)
}
seen[key] = struct{}{}
if err := checkKeyCase(propertySets, key, path); err != nil {
return err
}
value, err := decoder.Token()
if err != nil {
return nil
}
if err := validateValue(childSchemas(propertySets, key), decoder, value, path); err != nil {
return err
}
}
}
func validateValue(schemas []map[string]any, decoder *json.Decoder, token json.Token, path string) error {
switch token {
case json.Delim('{'):
var propertySets []map[string]any
for _, schema := range schemas {
propertySets = append(propertySets, schemaChildren(schema, "properties")...)
}
return validateObject(propertySets, decoder, path)
case json.Delim('['):
var items []map[string]any
for _, schema := range schemas {
items = append(items, schemaChildren(schema, "items")...)
}
for {
next, err := decoder.Token()
if err != nil {
return nil
}
if next == json.Delim(']') {
return nil
}
if err := validateValue(items, decoder, next, path+"[]"); err != nil {
return err
}
}
}
return nil
}
// schemaChildren collects a keyword's schemas from every composition branch.
// Keeping them separate preserves nested schemas for shared property names.
func schemaChildren(schema map[string]any, keyword string) []map[string]any {
var children []map[string]any
if child, ok := schema[keyword].(map[string]any); ok {
children = append(children, child)
}
for _, composition := range []string{"anyOf", "oneOf", "allOf"} {
branches, _ := schema[composition].([]any)
for _, branch := range branches {
if branch, ok := branch.(map[string]any); ok {
children = append(children, schemaChildren(branch, keyword)...)
}
}
}
return children
}
func checkKeyCase(propertySets []map[string]any, key, path string) error {
for _, properties := range propertySets {
for _, name := range slices.Sorted(maps.Keys(properties)) {
if name != key && strings.EqualFold(name, key) {
return xerrors.Errorf("input key %q differs from schema property %q only by case", path, name)
}
}
}
return nil
}
func childSchemas(propertySets []map[string]any, key string) []map[string]any {
var schemas []map[string]any
for _, properties := range propertySets {
name := key
if _, freeForm := properties[freeFormPropertyName]; freeForm {
name = freeFormPropertyName
}
if schema, ok := properties[name].(map[string]any); ok {
schemas = append(schemas, schema)
}
}
return schemas
}