mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-17 23:32:30 +08:00
- Replace tidwall/gjson and tidwall/sjson with github.com/MoeForge/moego/ojson and encoding/base64 with github.com/MoeForge/moego/base64 across the main module and examples - Introduce cross-method *ojson.Doc request rewriting pipelines across thinking, signature, client/codex, runtime/executor/helps, pluginhost, and all provider executors with FinalizePayloadDoc as the final semantic barrier - Convert all consecutive JSON mutations (>= 2 Set/SetRaw/Delete operations) to batch edits on ojson.Doc - Upgrade read-only byte paths to ojson.GetBytesNoCopy, ojson.GetManyBytesNoCopy, and util.ParseGJSONBytesNoCopy with explicit strings.Clone ownership protection across streaming and persistent state - Use base64.StdEncoding.ValidateString for zero-allocation signature checks and base64.EncodeDataURL for single-allocation data URL construction
1903 lines
60 KiB
Go
1903 lines
60 KiB
Go
// Package util provides utility functions for the CLI Proxy API server.
|
|
// It includes helper functions for JSON manipulation, proxy configuration,
|
|
// and other common operations used across the application.
|
|
package util
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/MoeForge/moego/ojson"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// Walk recursively traverses a JSON structure to find all occurrences of a specific field.
|
|
// It builds paths to each occurrence and adds them to the provided paths slice.
|
|
//
|
|
// Parameters:
|
|
// - value: The ojson.Result object to traverse
|
|
// - path: The current path in the JSON structure (empty string for root)
|
|
// - field: The field name to search for
|
|
// - paths: Pointer to a slice where found paths will be stored
|
|
//
|
|
// The function works recursively, building dot-notation paths to each occurrence
|
|
// of the specified field throughout the JSON structure.
|
|
func Walk(value ojson.Result, path, field string, paths *[]string) {
|
|
walk(value, path, field, paths, false)
|
|
}
|
|
|
|
// WalkSchema is Walk for JSON Schema documents: it records the field wherever a schema keyword
|
|
// may appear, but does not descend into literal values (default, example, examples, const, enum),
|
|
// whose contents are client data rather than subschemas. The literal keyword itself is still
|
|
// recorded when it is the searched field, and under a property-name map a key spelled like one is
|
|
// a property name whose subschema is still walked.
|
|
func WalkSchema(value ojson.Result, path, field string, paths *[]string) {
|
|
walk(value, path, field, paths, true)
|
|
}
|
|
|
|
func walk(value ojson.Result, path, field string, paths *[]string, schemaAware bool) {
|
|
switch value.Type {
|
|
case ojson.JSON:
|
|
// For JSON objects and arrays, iterate through each child
|
|
value.ForEach(func(key, val ojson.Result) bool {
|
|
var childPath string
|
|
// Escape special characters for gjson/sjson path syntax
|
|
// . -> \.
|
|
// * -> \*
|
|
// ? -> \?
|
|
keyStr := key.String()
|
|
safeKey := escapeGJSONPathKey(keyStr)
|
|
|
|
if path == "" {
|
|
childPath = safeKey
|
|
} else {
|
|
childPath = path + "." + safeKey
|
|
}
|
|
if keyStr == field {
|
|
*paths = append(*paths, childPath)
|
|
}
|
|
if schemaAware && isLiteralValueKeyword(keyStr) && !isPropertyDefinition(path) {
|
|
return true
|
|
}
|
|
walk(val, childPath, field, paths, schemaAware)
|
|
return true
|
|
})
|
|
case ojson.String, ojson.Number, ojson.True, ojson.False, ojson.Null:
|
|
// Terminal types - no further traversal needed
|
|
}
|
|
}
|
|
|
|
// RenameKey renames a key in a JSON string by moving its value to a new key path
|
|
// and then deleting the old key path.
|
|
//
|
|
// Parameters:
|
|
// - jsonStr: The JSON string to modify
|
|
// - oldKeyPath: The dot-notation path to the key that should be renamed
|
|
// - newKeyPath: The dot-notation path where the value should be moved to
|
|
//
|
|
// Returns:
|
|
// - string: The modified JSON string with the key renamed
|
|
// - error: An error if the operation fails
|
|
//
|
|
// The function performs the rename in two steps:
|
|
// 1. Sets the value at the new key path
|
|
// 2. Deletes the old key path
|
|
func RenameKey(jsonStr, oldKeyPath, newKeyPath string) (string, error) {
|
|
value := ojson.Get(jsonStr, oldKeyPath)
|
|
|
|
if !value.Exists() {
|
|
return "", fmt.Errorf("old key '%s' does not exist", oldKeyPath)
|
|
}
|
|
|
|
doc := ojson.NewDocString(jsonStr)
|
|
if errSet := doc.SetRaw(newKeyPath, value.Raw); errSet != nil {
|
|
return "", fmt.Errorf("failed to set new key '%s': %w", newKeyPath, errSet)
|
|
}
|
|
|
|
if errDelete := doc.Delete(oldKeyPath); errDelete != nil {
|
|
return "", fmt.Errorf("failed to delete old key '%s': %w", oldKeyPath, errDelete)
|
|
}
|
|
|
|
return doc.String(), nil
|
|
}
|
|
|
|
// FixJSON converts non-standard JSON that uses single quotes for strings into
|
|
// RFC 8259-compliant JSON by converting those single-quoted strings to
|
|
// double-quoted strings with proper escaping.
|
|
//
|
|
// Examples:
|
|
//
|
|
// {'a': 1, 'b': '2'} => {"a": 1, "b": "2"}
|
|
// {"t": 'He said "hi"'} => {"t": "He said \"hi\""}
|
|
//
|
|
// Rules:
|
|
// - Existing double-quoted JSON strings are preserved as-is.
|
|
// - Single-quoted strings are converted to double-quoted strings.
|
|
// - Inside converted strings, any double quote is escaped (\").
|
|
// - Common backslash escapes (\n, \r, \t, \b, \f, \\) are preserved.
|
|
// - \' inside single-quoted strings becomes a literal ' in the output (no
|
|
// escaping needed inside double quotes).
|
|
// - Unicode escapes (\uXXXX) inside single-quoted strings are forwarded.
|
|
// - The function does not attempt to fix other non-JSON features beyond quotes.
|
|
func FixJSON(input string) string {
|
|
var out bytes.Buffer
|
|
|
|
inDouble := false
|
|
inSingle := false
|
|
escaped := false // applies within the current string state
|
|
|
|
// Helper to write a rune, escaping double quotes when inside a converted
|
|
// single-quoted string (which becomes a double-quoted string in output).
|
|
writeConverted := func(r rune) {
|
|
if r == '"' {
|
|
out.WriteByte('\\')
|
|
out.WriteByte('"')
|
|
return
|
|
}
|
|
out.WriteRune(r)
|
|
}
|
|
|
|
runes := []rune(input)
|
|
for i := 0; i < len(runes); i++ {
|
|
r := runes[i]
|
|
|
|
if inDouble {
|
|
out.WriteRune(r)
|
|
if escaped {
|
|
// end of escape sequence in a standard JSON string
|
|
escaped = false
|
|
continue
|
|
}
|
|
if r == '\\' {
|
|
escaped = true
|
|
continue
|
|
}
|
|
if r == '"' {
|
|
inDouble = false
|
|
}
|
|
continue
|
|
}
|
|
|
|
if inSingle {
|
|
if escaped {
|
|
// Handle common escape sequences after a backslash within a
|
|
// single-quoted string
|
|
escaped = false
|
|
switch r {
|
|
case 'n', 'r', 't', 'b', 'f', '/', '"':
|
|
// Keep the backslash and the character (except for '"' which
|
|
// rarely appears, but if it does, keep as \" to remain valid)
|
|
out.WriteByte('\\')
|
|
out.WriteRune(r)
|
|
case '\\':
|
|
out.WriteByte('\\')
|
|
out.WriteByte('\\')
|
|
case '\'':
|
|
// \' inside single-quoted becomes a literal '
|
|
out.WriteRune('\'')
|
|
case 'u':
|
|
// Forward \uXXXX if possible
|
|
out.WriteByte('\\')
|
|
out.WriteByte('u')
|
|
// Copy up to next 4 hex digits if present
|
|
for k := 0; k < 4 && i+1 < len(runes); k++ {
|
|
peek := runes[i+1]
|
|
// simple hex check
|
|
if (peek >= '0' && peek <= '9') || (peek >= 'a' && peek <= 'f') || (peek >= 'A' && peek <= 'F') {
|
|
out.WriteRune(peek)
|
|
i++
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
// Unknown escape: preserve the backslash and the char
|
|
out.WriteByte('\\')
|
|
out.WriteRune(r)
|
|
}
|
|
continue
|
|
}
|
|
|
|
if r == '\\' { // start escape sequence
|
|
escaped = true
|
|
continue
|
|
}
|
|
if r == '\'' { // end of single-quoted string
|
|
out.WriteByte('"')
|
|
inSingle = false
|
|
continue
|
|
}
|
|
// regular char inside converted string; escape double quotes
|
|
writeConverted(r)
|
|
continue
|
|
}
|
|
|
|
// Outside any string
|
|
if r == '"' {
|
|
inDouble = true
|
|
out.WriteRune(r)
|
|
continue
|
|
}
|
|
if r == '\'' { // start of non-standard single-quoted string
|
|
inSingle = true
|
|
out.WriteByte('"')
|
|
continue
|
|
}
|
|
out.WriteRune(r)
|
|
}
|
|
|
|
// If input ended while still inside a single-quoted string, close it to
|
|
// produce the best-effort valid JSON.
|
|
if inSingle {
|
|
out.WriteByte('"')
|
|
}
|
|
|
|
return out.String()
|
|
}
|
|
|
|
func CanonicalToolName(name string) string {
|
|
canonical := strings.TrimSpace(name)
|
|
canonical = strings.TrimLeft(canonical, "_")
|
|
return strings.ToLower(canonical)
|
|
}
|
|
|
|
// ToolNameMapFromClaudeRequest returns a canonical-name -> original-name map extracted from a Claude request.
|
|
// It is used to restore exact tool name casing for clients that require strict tool name matching (e.g. Claude Code).
|
|
func ToolNameMapFromClaudeRequest(rawJSON []byte) map[string]string {
|
|
return toolNameMapFromClaudeRequest(rawJSON, false)
|
|
}
|
|
|
|
// UnambiguousToolNameMapFromClaudeRequest precomputes the legacy Claude mapper's
|
|
// collision policy so response chunks only need MapToolName, not the request body.
|
|
// Ambiguous canonical keys are stored with an empty value, so the returned map is
|
|
// only meaningful with MapToolName (which keeps the upstream name for empty
|
|
// values); do not index it directly.
|
|
func UnambiguousToolNameMapFromClaudeRequest(rawJSON []byte) map[string]string {
|
|
return toolNameMapFromClaudeRequest(rawJSON, true)
|
|
}
|
|
|
|
func claudePayloadMayContainToolAddition(rawJSON []byte) bool {
|
|
return bytes.Contains(rawJSON, []byte("tool_addition")) ||
|
|
bytes.Contains(rawJSON, []byte(`\u`)) ||
|
|
bytes.Contains(rawJSON, []byte(`\U`))
|
|
}
|
|
|
|
func forEachClaudeInlineToolAdditionDefinition(rawJSON []byte, fn func(def ojson.Result)) {
|
|
if !claudePayloadMayContainToolAddition(rawJSON) {
|
|
return
|
|
}
|
|
messages := ojson.GetBytes(rawJSON, "messages")
|
|
if !messages.IsArray() {
|
|
return
|
|
}
|
|
messages.ForEach(func(_, message ojson.Result) bool {
|
|
if message.Get("role").String() != "system" {
|
|
return true
|
|
}
|
|
content := message.Get("content")
|
|
if !content.IsArray() {
|
|
return true
|
|
}
|
|
content.ForEach(func(_, part ojson.Result) bool {
|
|
if part.Get("type").String() != "tool_addition" {
|
|
return true
|
|
}
|
|
toolSpec := part.Get("tool")
|
|
if toolSpec.Get("type").String() == "tool_definition" || toolSpec.Get("definition").IsObject() {
|
|
if def := toolSpec.Get("definition"); def.IsObject() {
|
|
fn(def)
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
return true
|
|
})
|
|
}
|
|
|
|
func toolNameMapFromClaudeRequest(rawJSON []byte, rejectAmbiguous bool) map[string]string {
|
|
if len(rawJSON) == 0 || !ojson.ValidBytes(rawJSON) {
|
|
return nil
|
|
}
|
|
|
|
tools := ojson.GetBytes(rawJSON, "tools")
|
|
hasTools := tools.Exists() && tools.IsArray()
|
|
hasToolAddition := claudePayloadMayContainToolAddition(rawJSON)
|
|
if !hasTools && !hasToolAddition {
|
|
return nil
|
|
}
|
|
|
|
var out map[string]string
|
|
recordTool := func(tool ojson.Result) {
|
|
name := strings.Clone(strings.TrimSpace(tool.Get("name").String()))
|
|
if name == "" {
|
|
name = strings.Clone(strings.TrimSpace(tool.Get("function.name").String()))
|
|
}
|
|
if name == "" {
|
|
return
|
|
}
|
|
key := strings.Clone(CanonicalToolName(name))
|
|
if key == "" {
|
|
return
|
|
}
|
|
if out == nil {
|
|
out = make(map[string]string, 4)
|
|
}
|
|
if previous, exists := out[key]; !exists {
|
|
out[key] = name
|
|
} else if rejectAmbiguous && previous != name {
|
|
// An empty value preserves the upstream name for every spelling of
|
|
// an ambiguous canonical key, including exact declared names.
|
|
out[key] = ""
|
|
}
|
|
}
|
|
|
|
if hasTools {
|
|
tools.ForEach(func(_, tool ojson.Result) bool {
|
|
recordTool(tool)
|
|
return true
|
|
})
|
|
}
|
|
if hasToolAddition {
|
|
forEachClaudeInlineToolAdditionDefinition(rawJSON, recordTool)
|
|
}
|
|
|
|
if len(out) == 0 {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
func MapToolName(toolNameMap map[string]string, name string) string {
|
|
if name == "" || toolNameMap == nil {
|
|
return name
|
|
}
|
|
if mapped, ok := toolNameMap[CanonicalToolName(name)]; ok && mapped != "" {
|
|
return mapped
|
|
}
|
|
return name
|
|
}
|
|
|
|
// MapClaudeToolName restores the client-facing tool name while preferring an exact
|
|
// declared name over canonical (case/leading-underscore-insensitive) restoration.
|
|
// It re-scans the request body on every call; hot paths should precompute with
|
|
// UnambiguousToolNameMapFromClaudeRequest and use MapToolName instead.
|
|
// This prevents distinct tools such as "Read" and "read" from being collapsed to
|
|
// the first declaration when the upstream already returned an exact name.
|
|
func MapClaudeToolName(toolNameMap map[string]string, originalRequestRawJSON []byte, name string) string {
|
|
if name == "" {
|
|
return name
|
|
}
|
|
if len(originalRequestRawJSON) > 0 && ojson.ValidBytes(originalRequestRawJSON) {
|
|
tools := ojson.GetBytes(originalRequestRawJSON, "tools")
|
|
hasTools := tools.IsArray()
|
|
hasToolAddition := claudePayloadMayContainToolAddition(originalRequestRawJSON)
|
|
if hasTools || hasToolAddition {
|
|
canonical := CanonicalToolName(name)
|
|
canonicalNames := map[string]bool{}
|
|
exactMatch := false
|
|
inspectTool := func(tool ojson.Result) {
|
|
declared := strings.TrimSpace(tool.Get("name").String())
|
|
if declared == "" {
|
|
declared = strings.TrimSpace(tool.Get("function.name").String())
|
|
}
|
|
if declared == name {
|
|
exactMatch = true
|
|
return
|
|
}
|
|
if declared != "" && CanonicalToolName(declared) == canonical {
|
|
canonicalNames[declared] = true
|
|
}
|
|
}
|
|
if hasTools {
|
|
for _, tool := range tools.Array() {
|
|
inspectTool(tool)
|
|
if exactMatch {
|
|
return name
|
|
}
|
|
}
|
|
}
|
|
if hasToolAddition {
|
|
forEachClaudeInlineToolAdditionDefinition(originalRequestRawJSON, inspectTool)
|
|
if exactMatch {
|
|
return name
|
|
}
|
|
}
|
|
if len(canonicalNames) > 1 {
|
|
return name
|
|
}
|
|
}
|
|
}
|
|
return MapToolName(toolNameMap, name)
|
|
}
|
|
|
|
// SanitizedFunctionNameMap builds an original-name → sanitized-name map from request tools.
|
|
// Exact duplicate names share a mapping. Distinct names that sanitize to the same value receive
|
|
// deterministic hash suffixes so every declaration remains addressable within the 64-byte limit.
|
|
func SanitizedFunctionNameMap(rawJSON []byte) map[string]string {
|
|
names := functionNamesFromRequest(rawJSON)
|
|
if len(names) == 0 {
|
|
return nil
|
|
}
|
|
|
|
uniqueNames := make(map[string]struct{}, len(names))
|
|
baseCounts := make(map[string]int, len(names))
|
|
for _, name := range names {
|
|
if name == "" {
|
|
continue
|
|
}
|
|
if _, exists := uniqueNames[name]; exists {
|
|
continue
|
|
}
|
|
uniqueNames[name] = struct{}{}
|
|
baseCounts[SanitizeFunctionName(name)]++
|
|
}
|
|
|
|
sortedNames := make([]string, 0, len(uniqueNames))
|
|
for name := range uniqueNames {
|
|
sortedNames = append(sortedNames, name)
|
|
}
|
|
sort.Strings(sortedNames)
|
|
|
|
out := make(map[string]string, len(sortedNames))
|
|
used := make(map[string]string, len(sortedNames))
|
|
for _, name := range sortedNames {
|
|
base := SanitizeFunctionName(name)
|
|
mapped := base
|
|
_, baseUsed := used[base]
|
|
if baseCounts[base] > 1 || baseUsed {
|
|
mapped = disambiguateSanitizedFunctionName(base, name, used)
|
|
}
|
|
out[name] = mapped
|
|
used[mapped] = name
|
|
}
|
|
if len(out) == 0 {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
// MapSanitizedFunctionName returns the request-specific sanitized name when available.
|
|
func MapSanitizedFunctionName(nameMap map[string]string, name string) string {
|
|
if mapped := nameMap[name]; mapped != "" {
|
|
return mapped
|
|
}
|
|
return SanitizeFunctionName(name)
|
|
}
|
|
|
|
// DisambiguatedToolNameMap builds a sanitized-name → original-name map using the
|
|
// same collision-aware mapping as SanitizedFunctionNameMap.
|
|
func DisambiguatedToolNameMap(rawJSON []byte) map[string]string {
|
|
forward := SanitizedFunctionNameMap(rawJSON)
|
|
if len(forward) == 0 {
|
|
return nil
|
|
}
|
|
|
|
out := make(map[string]string, len(forward))
|
|
for original, sanitized := range forward {
|
|
if sanitized != original {
|
|
out[sanitized] = original
|
|
}
|
|
}
|
|
if len(out) == 0 {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
// SanitizedToolNameMap builds the legacy sanitized-name → original-name map from
|
|
// top-level Claude-style tools. Collision-aware translators should use
|
|
// DisambiguatedToolNameMap instead.
|
|
func SanitizedToolNameMap(rawJSON []byte) map[string]string {
|
|
if len(rawJSON) == 0 || !ojson.ValidBytes(rawJSON) {
|
|
return nil
|
|
}
|
|
tools := ojson.GetBytes(rawJSON, "tools")
|
|
if !tools.IsArray() {
|
|
return nil
|
|
}
|
|
|
|
out := make(map[string]string)
|
|
tools.ForEach(func(_, tool ojson.Result) bool {
|
|
name := strings.Clone(strings.TrimSpace(tool.Get("name").String()))
|
|
if name == "" {
|
|
return true
|
|
}
|
|
sanitized := strings.Clone(SanitizeFunctionName(name))
|
|
if sanitized == name {
|
|
return true
|
|
}
|
|
if existing, exists := out[sanitized]; !exists {
|
|
out[sanitized] = name
|
|
} else {
|
|
log.Warnf("sanitized tool name collision: %q and %q both map to %q, keeping first", existing, name, sanitized)
|
|
}
|
|
return true
|
|
})
|
|
if len(out) == 0 {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
func functionNamesFromRequest(rawJSON []byte) []string {
|
|
if len(rawJSON) == 0 || !ojson.ValidBytes(rawJSON) {
|
|
return nil
|
|
}
|
|
tools := ojson.GetBytes(rawJSON, "tools")
|
|
if !tools.IsArray() {
|
|
return nil
|
|
}
|
|
|
|
names := make([]string, 0, len(tools.Array()))
|
|
var collectTool func(ojson.Result)
|
|
collectDeclarations := func(declarations ojson.Result) {
|
|
if !declarations.IsArray() {
|
|
return
|
|
}
|
|
declarations.ForEach(func(_, declaration ojson.Result) bool {
|
|
if name := declaration.Get("name").String(); name != "" {
|
|
names = append(names, strings.Clone(name))
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
collectTool = func(tool ojson.Result) {
|
|
if nestedTools := tool.Get("tools"); nestedTools.IsArray() {
|
|
nestedTools.ForEach(func(_, nestedTool ojson.Result) bool {
|
|
collectTool(nestedTool)
|
|
return true
|
|
})
|
|
return
|
|
}
|
|
hasDeclarations := false
|
|
if declarations := tool.Get("functionDeclarations"); declarations.IsArray() {
|
|
collectDeclarations(declarations)
|
|
hasDeclarations = true
|
|
}
|
|
if declarations := tool.Get("function_declarations"); declarations.IsArray() {
|
|
collectDeclarations(declarations)
|
|
hasDeclarations = true
|
|
}
|
|
if hasDeclarations {
|
|
return
|
|
}
|
|
if name := tool.Get("function.name").String(); name != "" {
|
|
names = append(names, strings.Clone(name))
|
|
return
|
|
}
|
|
if name := tool.Get("name").String(); name != "" {
|
|
names = append(names, strings.Clone(name))
|
|
}
|
|
}
|
|
tools.ForEach(func(_, tool ojson.Result) bool {
|
|
collectTool(tool)
|
|
return true
|
|
})
|
|
return names
|
|
}
|
|
|
|
func disambiguateSanitizedFunctionName(base, original string, used map[string]string) string {
|
|
for attempt := 0; ; attempt++ {
|
|
digest := sha256.Sum256([]byte(fmt.Sprintf("%s\x00%d", original, attempt)))
|
|
suffix := "_" + hex.EncodeToString(digest[:6])
|
|
prefix := base
|
|
if maxPrefix := 64 - len(suffix); len(prefix) > maxPrefix {
|
|
prefix = prefix[:maxPrefix]
|
|
}
|
|
candidate := prefix + suffix
|
|
if _, exists := used[candidate]; !exists {
|
|
return candidate
|
|
}
|
|
}
|
|
}
|
|
|
|
// DeduplicateFunctionDeclarations removes duplicate named declarations while preserving order.
|
|
func DeduplicateFunctionDeclarations(raw []byte) []byte {
|
|
result := ParseGJSONBytesNoCopy(raw)
|
|
if !result.IsArray() {
|
|
return raw
|
|
}
|
|
|
|
seen := make(map[string]struct{}, len(result.Array()))
|
|
parts := make([]string, 0, len(result.Array()))
|
|
for _, declaration := range result.Array() {
|
|
name := declaration.Get("name").String()
|
|
if name != "" {
|
|
if _, exists := seen[name]; exists {
|
|
continue
|
|
}
|
|
seen[name] = struct{}{}
|
|
}
|
|
parts = append(parts, declaration.Raw)
|
|
}
|
|
return []byte("[" + strings.Join(parts, ",") + "]")
|
|
}
|
|
|
|
// RestoreSanitizedToolName looks up a sanitized function name in the provided map
|
|
// and returns the original client-facing name. If no mapping exists, it returns
|
|
// the sanitized name unchanged.
|
|
func RestoreSanitizedToolName(toolNameMap map[string]string, sanitizedName string) string {
|
|
if sanitizedName == "" || toolNameMap == nil {
|
|
return sanitizedName
|
|
}
|
|
if original, ok := toolNameMap[sanitizedName]; ok {
|
|
return original
|
|
}
|
|
return sanitizedName
|
|
}
|
|
|
|
type claudeObjectSchemaInfo struct {
|
|
properties map[string][]ojson.Result
|
|
required map[string]bool
|
|
hasProperties bool
|
|
allowsDynamic bool
|
|
forbidsDynamic bool
|
|
hasPatternProperties bool
|
|
complex bool
|
|
unsafeComplex bool
|
|
declaresObject bool
|
|
branchInfos []claudeObjectSchemaInfo
|
|
}
|
|
|
|
func claudeSchemaAllowsDynamic(schema ojson.Result) bool {
|
|
// patternProperties permit matching keys even when additionalProperties is false
|
|
// (the latter only restricts keys matching no pattern), so pattern permission is
|
|
// never cancelled by an additionalProperties: false sibling.
|
|
if schema.Get("patternProperties").IsObject() && len(schema.Get("patternProperties").Map()) > 0 {
|
|
return true
|
|
}
|
|
additionalProperties := schema.Get("additionalProperties")
|
|
if additionalProperties.Exists() && additionalProperties.Type != ojson.False {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func claudeSchemaHasPatternProperties(schema ojson.Result) bool {
|
|
return schema.Get("patternProperties").IsObject() && len(schema.Get("patternProperties").Map()) > 0
|
|
}
|
|
|
|
func claudeSchemaForbidsDynamic(schema ojson.Result) bool {
|
|
additionalProperties := schema.Get("additionalProperties")
|
|
return additionalProperties.Exists() && additionalProperties.Type == ojson.False
|
|
}
|
|
|
|
func claudeResolveLocalRef(root ojson.Result, ref string) (ojson.Result, bool) {
|
|
if !strings.HasPrefix(ref, "#/") {
|
|
return ojson.Result{}, false
|
|
}
|
|
current := root
|
|
for _, segment := range strings.Split(strings.TrimPrefix(ref, "#/"), "/") {
|
|
segment = strings.ReplaceAll(strings.ReplaceAll(segment, "~1", "/"), "~0", "~")
|
|
next, ok := current.Map()[segment]
|
|
if !ok {
|
|
if current.IsArray() {
|
|
index, errAtoi := strconv.Atoi(segment)
|
|
if errAtoi != nil || index < 0 || index >= len(current.Array()) {
|
|
return ojson.Result{}, false
|
|
}
|
|
next = current.Array()[index]
|
|
} else {
|
|
return ojson.Result{}, false
|
|
}
|
|
}
|
|
current = next
|
|
}
|
|
return current, true
|
|
}
|
|
|
|
func analyzeClaudeObjectSchema(schema ojson.Result, root ojson.Result) claudeObjectSchemaInfo {
|
|
return analyzeClaudeObjectSchemaDepth(schema, root, 0, map[string]bool{})
|
|
}
|
|
|
|
func claudeSchemaDeclaresObject(schema ojson.Result) bool {
|
|
typeValue := schema.Get("type")
|
|
if typeValue.String() == "object" {
|
|
return true
|
|
}
|
|
if typeValue.IsArray() {
|
|
for _, item := range typeValue.Array() {
|
|
if item.String() == "object" {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func claudeUnionBranches(schema ojson.Result) ([]ojson.Result, bool) {
|
|
var branches []ojson.Result
|
|
seen := map[string]bool{}
|
|
for _, keyword := range []string{"anyOf", "oneOf"} {
|
|
union := schema.Get(keyword)
|
|
if !union.Exists() {
|
|
continue
|
|
}
|
|
if !union.IsArray() {
|
|
return nil, false
|
|
}
|
|
for _, branch := range union.Array() {
|
|
branchType := branch.Get("type")
|
|
if branchType.String() == "null" {
|
|
continue
|
|
}
|
|
if branchType.IsArray() && len(branchType.Array()) == 1 && branchType.Array()[0].String() == "null" {
|
|
continue
|
|
}
|
|
if seen[branch.Raw] {
|
|
continue
|
|
}
|
|
seen[branch.Raw] = true
|
|
branches = append(branches, branch)
|
|
}
|
|
}
|
|
return branches, true
|
|
}
|
|
|
|
var claudeAnalyzedSchemaKeywords = map[string]bool{
|
|
"type": true, "description": true, "title": true, "properties": true,
|
|
"required": true, "items": true, "additionalProperties": true,
|
|
"patternProperties": true, "anyOf": true, "oneOf": true, "allOf": true,
|
|
"$ref": true, "$defs": true, "definitions": true, "nullable": true,
|
|
"minLength": true, "maxLength": true, "minimum": true, "maximum": true,
|
|
"exclusiveMinimum": true, "exclusiveMaximum": true, "multipleOf": true,
|
|
"pattern": true, "format": true, "default": true, "examples": true,
|
|
"minItems": true, "maxItems": true, "maxProperties": true,
|
|
"$schema": true, "$id": true, "id": true,
|
|
"$comment": true, "deprecated": true, "readOnly": true, "writeOnly": true,
|
|
"example": true, "contentEncoding": true, "contentMediaType": true,
|
|
}
|
|
|
|
func claudeSchemaHasUnanalyzedKeyword(schema ojson.Result) bool {
|
|
for key := range schema.Map() {
|
|
if strings.HasPrefix(key, "x-") {
|
|
continue
|
|
}
|
|
if !claudeAnalyzedSchemaKeywords[key] {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func analyzeClaudeObjectSchemaDepth(schema ojson.Result, root ojson.Result, depth int, visitedRefs map[string]bool) claudeObjectSchemaInfo {
|
|
info := claudeObjectSchemaInfo{properties: map[string][]ojson.Result{}, required: map[string]bool{}}
|
|
if depth > 16 || !schema.Exists() || !schema.IsObject() {
|
|
info.complex = true
|
|
return info
|
|
}
|
|
if claudeSchemaDeclaresObject(schema) {
|
|
info.declaresObject = true
|
|
}
|
|
if claudeSchemaHasUnanalyzedKeyword(schema) {
|
|
// Any keyword outside the explicitly analyzed set (enum, const, contains,
|
|
// conditionals, unevaluated*, $dynamicRef, vendor applicators, ...) may
|
|
// constrain legal values in ways this analyzer does not model. Such schemas
|
|
// are unsafe-complex (unlike multi-branch unions, whose branches are
|
|
// collected): no destructive cleaning may run on them at all, even when a
|
|
// union keyword is also present.
|
|
info.complex = true
|
|
info.unsafeComplex = true
|
|
return info
|
|
}
|
|
if schema.Get("anyOf").Exists() || schema.Get("oneOf").Exists() {
|
|
branches, okBranches := claudeUnionBranches(schema)
|
|
if !okBranches || len(branches) == 0 {
|
|
info.complex = true
|
|
return info
|
|
}
|
|
if len(branches) > 1 {
|
|
// Multi-branch unions stay complex so this level never normalizes arguments,
|
|
// but collect every branch's declared properties so child recursion and
|
|
// placeholder protection still see the full original declaration. The
|
|
// per-branch infos are kept separately because union branches are
|
|
// alternatives: their dynamic-property policies must not be combined as
|
|
// simultaneous constraints.
|
|
for _, branch := range branches {
|
|
branchInfo := analyzeClaudeObjectSchemaDepth(branch, root, depth+1, visitedRefs)
|
|
info.branchInfos = append(info.branchInfos, branchInfo)
|
|
mergeClaudeObjectSchemaInfo(&info, branchInfo)
|
|
}
|
|
if claudeSchemaAllowsDynamic(schema) {
|
|
info.allowsDynamic = true
|
|
}
|
|
if claudeSchemaForbidsDynamic(schema) {
|
|
info.forbidsDynamic = true
|
|
}
|
|
if claudeSchemaHasPatternProperties(schema) {
|
|
info.hasPatternProperties = true
|
|
}
|
|
for _, requiredName := range schema.Get("required").Array() {
|
|
info.required[requiredName.String()] = true
|
|
}
|
|
props := schema.Get("properties")
|
|
if props.IsObject() {
|
|
info.hasProperties = true
|
|
info.declaresObject = true
|
|
for key, value := range props.Map() {
|
|
info.properties[key] = appendUniqueSchema(info.properties[key], value)
|
|
}
|
|
}
|
|
// Sibling $ref/allOf applicators still constrain this node alongside the
|
|
// union; collect them too or their declared child properties would be
|
|
// invisible to protection and child recursion.
|
|
if ref := schema.Get("$ref"); ref.Exists() {
|
|
refValue := ref.String()
|
|
if !visitedRefs[refValue] {
|
|
if target, ok := claudeResolveLocalRef(root, refValue); ok {
|
|
visitedRefs[refValue] = true
|
|
resolved := analyzeClaudeObjectSchemaDepth(target, root, depth+1, visitedRefs)
|
|
delete(visitedRefs, refValue)
|
|
mergeClaudeObjectSchemaInfo(&info, resolved)
|
|
}
|
|
}
|
|
}
|
|
if allOf := schema.Get("allOf"); allOf.IsArray() {
|
|
for _, branch := range allOf.Array() {
|
|
branchInfo := analyzeClaudeObjectSchemaDepth(branch, root, depth+1, visitedRefs)
|
|
mergeClaudeObjectSchemaInfo(&info, branchInfo)
|
|
}
|
|
}
|
|
info.complex = true
|
|
return info
|
|
}
|
|
branchInfo := analyzeClaudeObjectSchemaDepth(branches[0], root, depth+1, visitedRefs)
|
|
mergeClaudeObjectSchemaInfo(&info, branchInfo)
|
|
}
|
|
if ref := schema.Get("$ref"); ref.Exists() {
|
|
refValue := ref.String()
|
|
if visitedRefs[refValue] {
|
|
info.complex = true
|
|
return info
|
|
}
|
|
target, ok := claudeResolveLocalRef(root, refValue)
|
|
if !ok {
|
|
info.complex = true
|
|
return info
|
|
}
|
|
visitedRefs[refValue] = true
|
|
resolved := analyzeClaudeObjectSchemaDepth(target, root, depth+1, visitedRefs)
|
|
delete(visitedRefs, refValue)
|
|
mergeClaudeObjectSchemaInfo(&info, resolved)
|
|
}
|
|
if allOf := schema.Get("allOf"); allOf.IsArray() {
|
|
for _, branch := range allOf.Array() {
|
|
branchInfo := analyzeClaudeObjectSchemaDepth(branch, root, depth+1, visitedRefs)
|
|
mergeClaudeObjectSchemaInfo(&info, branchInfo)
|
|
}
|
|
} else if allOf.Exists() {
|
|
info.complex = true
|
|
}
|
|
if claudeSchemaAllowsDynamic(schema) {
|
|
info.allowsDynamic = true
|
|
}
|
|
if claudeSchemaForbidsDynamic(schema) {
|
|
info.forbidsDynamic = true
|
|
}
|
|
if claudeSchemaHasPatternProperties(schema) {
|
|
info.hasPatternProperties = true
|
|
}
|
|
props := schema.Get("properties")
|
|
if props.Exists() {
|
|
if !props.IsObject() {
|
|
info.complex = true
|
|
} else {
|
|
info.hasProperties = true
|
|
info.declaresObject = true
|
|
for key, value := range props.Map() {
|
|
info.properties[key] = appendUniqueSchema(info.properties[key], value)
|
|
}
|
|
}
|
|
}
|
|
for _, requiredName := range schema.Get("required").Array() {
|
|
info.required[requiredName.String()] = true
|
|
}
|
|
return info
|
|
}
|
|
|
|
func appendUniqueSchema(schemas []ojson.Result, value ojson.Result) []ojson.Result {
|
|
for _, existing := range schemas {
|
|
if existing.Raw == value.Raw {
|
|
return schemas
|
|
}
|
|
}
|
|
return append(schemas, value)
|
|
}
|
|
|
|
func mergeClaudeObjectSchemaInfo(dst *claudeObjectSchemaInfo, src claudeObjectSchemaInfo) {
|
|
if dst.properties == nil {
|
|
dst.properties = map[string][]ojson.Result{}
|
|
}
|
|
if dst.required == nil {
|
|
dst.required = map[string]bool{}
|
|
}
|
|
if src.hasProperties {
|
|
dst.hasProperties = true
|
|
for key, values := range src.properties {
|
|
for _, value := range values {
|
|
dst.properties[key] = appendUniqueSchema(dst.properties[key], value)
|
|
}
|
|
}
|
|
}
|
|
for name := range src.required {
|
|
dst.required[name] = true
|
|
}
|
|
dst.branchInfos = append(dst.branchInfos, src.branchInfos...)
|
|
dst.allowsDynamic = dst.allowsDynamic || src.allowsDynamic
|
|
dst.forbidsDynamic = dst.forbidsDynamic || src.forbidsDynamic
|
|
dst.hasPatternProperties = dst.hasPatternProperties || src.hasPatternProperties
|
|
dst.complex = dst.complex || src.complex
|
|
dst.unsafeComplex = dst.unsafeComplex || src.unsafeComplex
|
|
dst.declaresObject = dst.declaresObject || src.declaresObject
|
|
}
|
|
|
|
func findClaudeToolSchema(originalRequestRawJSON []byte, toolName string) (ojson.Result, ojson.Result, bool) {
|
|
if toolName == "" || len(originalRequestRawJSON) == 0 || !ojson.ValidBytes(originalRequestRawJSON) {
|
|
return ojson.Result{}, ojson.Result{}, false
|
|
}
|
|
root := ojson.ParseBytes(originalRequestRawJSON)
|
|
tools := root.Get("tools")
|
|
if !tools.IsArray() {
|
|
return ojson.Result{}, root, false
|
|
}
|
|
type candidate struct {
|
|
name string
|
|
schema ojson.Result
|
|
found bool
|
|
}
|
|
var exact []candidate
|
|
canonicalToolName := CanonicalToolName(toolName)
|
|
canonicalMatches := map[string][]candidate{}
|
|
for _, tool := range tools.Array() {
|
|
name := strings.TrimSpace(tool.Get("name").String())
|
|
if name == "" {
|
|
name = strings.TrimSpace(tool.Get("function.name").String())
|
|
}
|
|
if name == "" {
|
|
continue
|
|
}
|
|
schema := tool.Get("input_schema")
|
|
if !schema.Exists() {
|
|
schema = tool.Get("parameters")
|
|
}
|
|
if !schema.Exists() {
|
|
schema = tool.Get("function.parameters")
|
|
}
|
|
c := candidate{name: name, schema: schema, found: true}
|
|
if name == toolName {
|
|
exact = append(exact, c)
|
|
}
|
|
if CanonicalToolName(name) == canonicalToolName {
|
|
canonicalMatches[name] = append(canonicalMatches[name], c)
|
|
}
|
|
}
|
|
if len(exact) == 1 {
|
|
return exact[0].schema, root, true
|
|
}
|
|
if len(exact) > 1 {
|
|
firstRaw := exact[0].schema.Raw
|
|
identical := true
|
|
for _, other := range exact[1:] {
|
|
if other.schema.Raw != firstRaw {
|
|
identical = false
|
|
break
|
|
}
|
|
}
|
|
if identical {
|
|
return exact[0].schema, root, true
|
|
}
|
|
return ojson.Result{}, root, false
|
|
}
|
|
if len(canonicalMatches) == 1 {
|
|
for _, matches := range canonicalMatches {
|
|
if len(matches) == 1 {
|
|
return matches[0].schema, root, true
|
|
}
|
|
firstRaw := matches[0].schema.Raw
|
|
identical := true
|
|
for _, other := range matches[1:] {
|
|
if other.schema.Raw != firstRaw {
|
|
identical = false
|
|
break
|
|
}
|
|
}
|
|
if identical {
|
|
return matches[0].schema, root, true
|
|
}
|
|
}
|
|
}
|
|
return ojson.Result{}, root, false
|
|
}
|
|
|
|
// ClaudeToolIsParameterless reports whether the tool was declared in the original
|
|
// Claude request with a missing schema or an explicitly closed empty object schema
|
|
// (additionalProperties: false). Schemas that allow dynamic additional or pattern
|
|
// properties, including objects that omit additionalProperties, are not parameterless.
|
|
func ClaudeToolIsParameterless(toolName string, originalRequestRawJSON []byte) bool {
|
|
schema, root, found := findClaudeToolSchema(originalRequestRawJSON, toolName)
|
|
if !found {
|
|
return false
|
|
}
|
|
if !schema.Exists() {
|
|
return true
|
|
}
|
|
_ = root
|
|
info := analyzeClaudeObjectSchema(schema, schema)
|
|
if info.complex || claudeInfoAnyBranchAllowsDynamic(info) || !info.declaresObject || !info.forbidsDynamic {
|
|
return false
|
|
}
|
|
return len(info.required) == 0 && (!info.hasProperties || len(info.properties) == 0)
|
|
}
|
|
|
|
func resolveClaudeArrayItemsSchema(schema ojson.Result, root ojson.Result, depth int, visitedRefs map[string]bool) ([]ojson.Result, bool) {
|
|
if depth > 16 || !schema.Exists() || !schema.IsObject() {
|
|
return nil, false
|
|
}
|
|
var items []ojson.Result
|
|
deterministic := true
|
|
collect := func(candidate ojson.Result) {
|
|
items = appendUniqueSchema(items, candidate)
|
|
}
|
|
if ref := schema.Get("$ref"); ref.Exists() {
|
|
refValue := ref.String()
|
|
if visitedRefs[refValue] {
|
|
return nil, false
|
|
}
|
|
target, ok := claudeResolveLocalRef(root, refValue)
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
visitedRefs[refValue] = true
|
|
targetItems, targetOK := resolveClaudeArrayItemsSchema(target, root, depth+1, visitedRefs)
|
|
delete(visitedRefs, refValue)
|
|
if !targetOK {
|
|
deterministic = false
|
|
} else {
|
|
for _, item := range targetItems {
|
|
collect(item)
|
|
}
|
|
}
|
|
}
|
|
if schema.Get("anyOf").Exists() || schema.Get("oneOf").Exists() {
|
|
branches, okBranches := claudeUnionBranches(schema)
|
|
if !okBranches || len(branches) != 1 {
|
|
deterministic = false
|
|
} else {
|
|
branchItems, branchOK := resolveClaudeArrayItemsSchema(branches[0], root, depth+1, visitedRefs)
|
|
if !branchOK {
|
|
deterministic = false
|
|
} else {
|
|
for _, item := range branchItems {
|
|
collect(item)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if allOf := schema.Get("allOf"); allOf.IsArray() {
|
|
for _, branch := range allOf.Array() {
|
|
branchItems, branchOK := resolveClaudeArrayItemsSchema(branch, root, depth+1, visitedRefs)
|
|
if !branchOK {
|
|
deterministic = false
|
|
continue
|
|
}
|
|
for _, item := range branchItems {
|
|
collect(item)
|
|
}
|
|
}
|
|
} else if allOf.Exists() {
|
|
deterministic = false
|
|
}
|
|
if directItems := schema.Get("items"); directItems.Exists() {
|
|
collect(directItems)
|
|
}
|
|
return items, deterministic
|
|
}
|
|
|
|
func claudeDeclaredPropertyPlaceholders(info claudeObjectSchemaInfo) (bool, bool) {
|
|
_, reasonDeclared := info.properties["reason"]
|
|
_, underscoreDeclared := info.properties["_"]
|
|
return reasonDeclared, underscoreDeclared
|
|
}
|
|
|
|
func claudeArraySchemaUnsafe(schema ojson.Result, root ojson.Result) bool {
|
|
return analyzeClaudeObjectSchema(schema, root).unsafeComplex
|
|
}
|
|
|
|
func cleanClaudeToolArray(argsJSON string, schemas []ojson.Result, root ojson.Result, path string) string {
|
|
for _, schema := range schemas {
|
|
if claudeArraySchemaUnsafe(schema, root) {
|
|
// Value-constraining keywords on the array itself (e.g. enum of whole
|
|
// arrays) are not analyzed; keep the array untouched.
|
|
return argsJSON
|
|
}
|
|
}
|
|
var itemSchemas []ojson.Result
|
|
deterministic := true
|
|
for _, schema := range schemas {
|
|
resolvedItems, okItems := resolveClaudeArrayItemsSchema(schema, root, 0, map[string]bool{})
|
|
if !okItems {
|
|
deterministic = false
|
|
continue
|
|
}
|
|
if len(resolvedItems) == 0 {
|
|
// A candidate without an items schema (e.g. free-form "{}") accepts
|
|
// arbitrary elements; it must stay in the candidate set so element
|
|
// cleaning sees the free alternative instead of only strict siblings.
|
|
itemSchemas = appendUniqueSchema(itemSchemas, schema)
|
|
continue
|
|
}
|
|
for _, item := range resolvedItems {
|
|
itemSchemas = appendUniqueSchema(itemSchemas, item)
|
|
}
|
|
}
|
|
if !deterministic || len(itemSchemas) == 0 {
|
|
return argsJSON
|
|
}
|
|
cleaned := argsJSON
|
|
elementCount := len(ojson.Get(cleaned, path).Array())
|
|
for index := 0; index < elementCount; index++ {
|
|
elementPath := joinPath(path, strconv.Itoa(index))
|
|
element := ojson.Get(cleaned, elementPath)
|
|
if element.IsObject() {
|
|
cleaned = cleanClaudeToolObject(cleaned, itemSchemas, root, elementPath, false)
|
|
} else if element.IsArray() {
|
|
cleaned = cleanClaudeToolArray(cleaned, itemSchemas, root, elementPath)
|
|
}
|
|
}
|
|
return cleaned
|
|
}
|
|
|
|
func cleanClaudeToolObject(argsJSON string, schemas []ojson.Result, root ojson.Result, path string, topLevel bool) string {
|
|
argsResult := ojson.Get(argsJSON, path)
|
|
if path == "" {
|
|
argsResult = ojson.Parse(argsJSON)
|
|
}
|
|
if !argsResult.IsObject() || len(schemas) == 0 {
|
|
return argsJSON
|
|
}
|
|
merged := claudeObjectSchemaInfo{properties: map[string][]ojson.Result{}}
|
|
for _, schema := range schemas {
|
|
mergeClaudeObjectSchemaInfo(&merged, analyzeClaudeObjectSchema(schema, root))
|
|
}
|
|
if merged.complex || !merged.declaresObject {
|
|
return argsJSON
|
|
}
|
|
isEmptySchema := len(merged.required) == 0 && (!merged.hasProperties || len(merged.properties) == 0)
|
|
allSchemasDeclareObject := true
|
|
for _, schema := range schemas {
|
|
if !analyzeClaudeObjectSchema(schema, root).declaresObject {
|
|
allSchemasDeclareObject = false
|
|
break
|
|
}
|
|
}
|
|
if isEmptySchema && allSchemasDeclareObject && merged.forbidsDynamic && !claudeInfoAnyBranchAllowsDynamic(merged) && !claudeOriginalsAnyBranchAllowsDynamic(schemas, root) && !claudeOriginalsAnyCandidateAcceptsImplicitly(schemas, root, argsResult) {
|
|
if len(argsResult.Map()) == 0 {
|
|
return argsJSON
|
|
}
|
|
if topLevel {
|
|
return "{}"
|
|
}
|
|
updated, _ := ojson.SetRaw(argsJSON, path, "{}")
|
|
return updated
|
|
}
|
|
keys := make([]string, 0, len(merged.properties))
|
|
for key := range merged.properties {
|
|
keys = append(keys, key)
|
|
}
|
|
sort.Strings(keys)
|
|
cleaned := argsJSON
|
|
for _, key := range keys {
|
|
propertySchemas := merged.properties[key]
|
|
childPath := joinPath(path, escapeGJSONPathKey(key))
|
|
child := ojson.Get(cleaned, childPath)
|
|
if !child.Exists() {
|
|
continue
|
|
}
|
|
currentForBranch := ojson.Parse(cleaned)
|
|
if path != "" {
|
|
currentForBranch = ojson.Get(cleaned, path)
|
|
}
|
|
if claudeParentBranchAcceptsChild(merged, key, currentForBranch) || claudeOriginalsMayPermitChild(schemas, root, key, currentForBranch) {
|
|
continue
|
|
}
|
|
if child.IsObject() {
|
|
cleaned = cleanClaudeToolObject(cleaned, propertySchemas, root, childPath, false)
|
|
} else if child.IsArray() {
|
|
cleaned = cleanClaudeToolArray(cleaned, propertySchemas, root, childPath)
|
|
}
|
|
}
|
|
if claudeInfoAnyBranchAllowsDynamic(merged) {
|
|
return cleaned
|
|
}
|
|
current := ojson.Parse(cleaned)
|
|
if path != "" {
|
|
current = ojson.Get(cleaned, path)
|
|
}
|
|
if !current.IsObject() {
|
|
return cleaned
|
|
}
|
|
reasonDeclared, underscoreDeclared := claudeDeclaredPropertyPlaceholders(merged)
|
|
doc := ojson.NewDocString(cleaned)
|
|
docModified := false
|
|
for _, placeholder := range []string{"reason", "_"} {
|
|
if placeholder == "reason" && reasonDeclared {
|
|
continue
|
|
}
|
|
if placeholder == "_" && underscoreDeclared {
|
|
continue
|
|
}
|
|
if merged.required[placeholder] {
|
|
continue
|
|
}
|
|
if claudeInfoAnyBranchAllowsDynamic(merged) || claudeOriginalsAnyBranchAllowsDynamic(schemas, root) {
|
|
continue
|
|
}
|
|
if claudeParentBranchAcceptsChild(merged, placeholder, current) {
|
|
continue
|
|
}
|
|
if claudeOriginalsAnyCandidateAcceptsImplicitly(schemas, root, current) {
|
|
continue
|
|
}
|
|
if _, ok := current.Map()[placeholder]; ok {
|
|
placeholderPath := joinPath(path, placeholder)
|
|
if doc.Delete(placeholderPath) == nil {
|
|
docModified = true
|
|
}
|
|
}
|
|
}
|
|
if docModified {
|
|
cleaned = doc.String()
|
|
}
|
|
parsedCleaned := ojson.Parse(cleaned)
|
|
if path != "" {
|
|
parsedCleaned = ojson.Get(cleaned, path)
|
|
}
|
|
if parsedCleaned.IsObject() && len(parsedCleaned.Map()) == 0 && path == "" {
|
|
return "{}"
|
|
}
|
|
return cleaned
|
|
}
|
|
|
|
func findTranslatedClaudeToolSchemas(translatedRequestRawJSON []byte, toolName string, originalRequestRawJSON []byte) []ojson.Result {
|
|
if toolName == "" || len(translatedRequestRawJSON) == 0 || !ojson.ValidBytes(translatedRequestRawJSON) {
|
|
return nil
|
|
}
|
|
root := ojson.ParseBytes(translatedRequestRawJSON)
|
|
type namedSchema struct {
|
|
name string
|
|
schema ojson.Result
|
|
}
|
|
var named []namedSchema
|
|
collectNamed := func(tools ojson.Result) {
|
|
if !tools.IsArray() {
|
|
return
|
|
}
|
|
for _, toolGroup := range tools.Array() {
|
|
decls := toolGroup.Get("functionDeclarations")
|
|
if !decls.IsArray() {
|
|
continue
|
|
}
|
|
for _, decl := range decls.Array() {
|
|
name := strings.TrimSpace(decl.Get("name").String())
|
|
if name == "" {
|
|
continue
|
|
}
|
|
schema := decl.Get("parametersJsonSchema")
|
|
if !schema.Exists() {
|
|
schema = decl.Get("parameters")
|
|
}
|
|
if schema.Exists() && schema.IsObject() {
|
|
named = append(named, namedSchema{name: name, schema: schema})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
collectNamed(root.Get("tools"))
|
|
collectNamed(root.Get("request.tools"))
|
|
if len(named) == 0 {
|
|
return nil
|
|
}
|
|
canonicalToolName := CanonicalToolName(toolName)
|
|
sanitizedToolName := SanitizeFunctionName(toolName)
|
|
// Request translation renames colliding tool names via the request-wide
|
|
// disambiguated map (hash suffixes); the response name is the restored
|
|
// client name, so match the actually-sent name when it can be derived.
|
|
sentName := ""
|
|
if forward := SanitizedFunctionNameMap(originalRequestRawJSON); forward != nil {
|
|
sentName = forward[toolName]
|
|
}
|
|
var exact []ojson.Result
|
|
canonicalByName := map[string][]ojson.Result{}
|
|
for _, entry := range named {
|
|
if entry.name == toolName || (sentName != "" && entry.name == sentName) {
|
|
exact = append(exact, entry.schema)
|
|
}
|
|
if CanonicalToolName(entry.name) == canonicalToolName || entry.name == sanitizedToolName || SanitizeFunctionName(entry.name) == sanitizedToolName {
|
|
canonicalByName[entry.name] = append(canonicalByName[entry.name], entry.schema)
|
|
}
|
|
}
|
|
if len(exact) > 0 {
|
|
return exact
|
|
}
|
|
if len(canonicalByName) == 1 {
|
|
for _, schemas := range canonicalByName {
|
|
return schemas
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func claudeOriginalDeclaresPropertyDeep(schema ojson.Result, root ojson.Result, property string, depth int, visitedRefs map[string]bool) bool {
|
|
if depth > 16 || !schema.Exists() || !schema.IsObject() {
|
|
return false
|
|
}
|
|
if ref := schema.Get("$ref"); ref.Exists() {
|
|
refValue := ref.String()
|
|
if !visitedRefs[refValue] {
|
|
if target, ok := claudeResolveLocalRef(root, refValue); ok {
|
|
visitedRefs[refValue] = true
|
|
declared := claudeOriginalDeclaresPropertyDeep(target, root, property, depth+1, visitedRefs)
|
|
delete(visitedRefs, refValue)
|
|
if declared {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if _, ok := schema.Get("properties").Map()[property]; ok {
|
|
return true
|
|
}
|
|
for _, requiredName := range schema.Get("required").Array() {
|
|
if requiredName.String() == property {
|
|
return true
|
|
}
|
|
}
|
|
for _, keyword := range []string{"allOf", "anyOf", "oneOf"} {
|
|
for _, branch := range schema.Get(keyword).Array() {
|
|
if claudeOriginalDeclaresPropertyDeep(branch, root, property, depth+1, visitedRefs) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func claudeInfoAnyBranchAllowsDynamic(info claudeObjectSchemaInfo) bool {
|
|
if info.hasPatternProperties {
|
|
return true
|
|
}
|
|
if len(info.branchInfos) == 0 {
|
|
return info.allowsDynamic && !info.forbidsDynamic
|
|
}
|
|
for _, branch := range info.branchInfos {
|
|
if claudeInfoAnyBranchAllowsDynamic(branch) {
|
|
return true
|
|
}
|
|
}
|
|
return info.allowsDynamic && !info.forbidsDynamic
|
|
}
|
|
|
|
func claudeBranchMayAccept(info claudeObjectSchemaInfo, key string, current ojson.Result) bool {
|
|
// patternProperties permit matching keys regardless of additionalProperties.
|
|
if info.hasPatternProperties {
|
|
return true
|
|
}
|
|
// A branch that does not explicitly forbid additional properties accepts the
|
|
// key by JSON Schema default. To avoid treating every unconstrained sibling
|
|
// branch as permission (which would mask genuine placeholder cleaning), this
|
|
// implicit permission only counts when the current object matches the branch
|
|
// by carrying every property the branch requires.
|
|
if !info.forbidsDynamic {
|
|
matches := true
|
|
for requiredName := range info.required {
|
|
if _, ok := current.Map()[requiredName]; !ok {
|
|
matches = false
|
|
break
|
|
}
|
|
}
|
|
if matches {
|
|
return true
|
|
}
|
|
}
|
|
if info.allowsDynamic && !info.forbidsDynamic {
|
|
return true
|
|
}
|
|
for _, branch := range info.branchInfos {
|
|
_, branchDeclaresKey := branch.properties[key]
|
|
if branchDeclaresKey {
|
|
// This branch constrains the key with its own explicit schema,
|
|
// which is already part of the collected candidates.
|
|
continue
|
|
}
|
|
if claudeBranchMayAccept(branch, key, current) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func claudeParentBranchAcceptsChild(originalInfo claudeObjectSchemaInfo, key string, current ojson.Result) bool {
|
|
if len(originalInfo.branchInfos) == 0 {
|
|
return false
|
|
}
|
|
for _, branch := range originalInfo.branchInfos {
|
|
_, branchDeclaresKey := branch.properties[key]
|
|
if branchDeclaresKey {
|
|
continue
|
|
}
|
|
if claudeBranchMayAccept(branch, key, current) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func claudeCandidateMayPermitChild(info claudeObjectSchemaInfo, key string, current ojson.Result) bool {
|
|
if _, declaresKey := info.properties[key]; declaresKey {
|
|
return false
|
|
}
|
|
if info.hasPatternProperties {
|
|
return true
|
|
}
|
|
if info.forbidsDynamic {
|
|
return false
|
|
}
|
|
for requiredName := range info.required {
|
|
if _, ok := current.Map()[requiredName]; !ok {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func claudeOriginalsMayPermitChild(originals []ojson.Result, root ojson.Result, key string, current ojson.Result) bool {
|
|
if len(originals) <= 1 {
|
|
return false
|
|
}
|
|
for _, original := range originals {
|
|
info := analyzeClaudeObjectSchema(original, root)
|
|
if info.complex {
|
|
continue
|
|
}
|
|
if claudeCandidateMayPermitChild(info, key, current) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func claudeOriginalsAnyCandidateAcceptsImplicitly(originals []ojson.Result, root ojson.Result, current ojson.Result) bool {
|
|
if len(originals) <= 1 {
|
|
return false
|
|
}
|
|
for _, original := range originals {
|
|
info := analyzeClaudeObjectSchema(original, root)
|
|
if info.complex || info.forbidsDynamic {
|
|
continue
|
|
}
|
|
matches := true
|
|
for requiredName := range info.required {
|
|
if _, ok := current.Map()[requiredName]; !ok {
|
|
matches = false
|
|
break
|
|
}
|
|
}
|
|
if matches {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func claudeOriginalsAnyBranchAllowsDynamic(originals []ojson.Result, root ojson.Result) bool {
|
|
for _, original := range originals {
|
|
if info := analyzeClaudeObjectSchema(original, root); claudeInfoAnyBranchAllowsDynamic(info) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func mergedClaudeOriginalInfo(originals []ojson.Result, root ojson.Result) claudeObjectSchemaInfo {
|
|
merged := claudeObjectSchemaInfo{properties: map[string][]ojson.Result{}}
|
|
for _, original := range originals {
|
|
mergeClaudeObjectSchemaInfo(&merged, analyzeClaudeObjectSchema(original, root))
|
|
}
|
|
return merged
|
|
}
|
|
|
|
func cleanClaudeToolArgumentsByTranslatedSchema(argsJSON string, translatedSchemas []ojson.Result, originals []ojson.Result, root ojson.Result, path string, topLevel bool) string {
|
|
current := ojson.Parse(argsJSON)
|
|
if path != "" {
|
|
current = ojson.Get(argsJSON, path)
|
|
}
|
|
if !current.IsObject() || len(translatedSchemas) == 0 || len(originals) == 0 {
|
|
return argsJSON
|
|
}
|
|
for _, original := range originals {
|
|
if !original.IsObject() {
|
|
return argsJSON
|
|
}
|
|
}
|
|
originalInfo := mergedClaudeOriginalInfo(originals, root)
|
|
if originalInfo.unsafeComplex {
|
|
return argsJSON
|
|
}
|
|
if originalInfo.complex {
|
|
// Multi-branch unions in the original cannot be analyzed declaratively; fall through
|
|
// and rely on the translated schema, which records the actually-sent branches.
|
|
hasUnion := false
|
|
for _, original := range originals {
|
|
if original.Get("anyOf").IsArray() || original.Get("oneOf").IsArray() {
|
|
hasUnion = true
|
|
}
|
|
}
|
|
if !hasUnion {
|
|
return argsJSON
|
|
}
|
|
}
|
|
cleaned := argsJSON
|
|
// Recurse into declared children using matching translated child schemas.
|
|
if originalInfo.hasProperties {
|
|
keys := make([]string, 0, len(originalInfo.properties))
|
|
for key := range originalInfo.properties {
|
|
keys = append(keys, key)
|
|
}
|
|
sort.Strings(keys)
|
|
for _, key := range keys {
|
|
childPath := joinPath(path, escapeGJSONPathKey(key))
|
|
child := ojson.Get(cleaned, childPath)
|
|
if !child.Exists() {
|
|
continue
|
|
}
|
|
var translatedChildren []ojson.Result
|
|
for _, translated := range translatedSchemas {
|
|
translatedInfo := analyzeClaudeObjectSchema(translated, translated)
|
|
for _, childSchema := range translatedInfo.properties[key] {
|
|
translatedChildren = appendUniqueSchema(translatedChildren, childSchema)
|
|
}
|
|
}
|
|
if len(translatedChildren) == 0 {
|
|
continue
|
|
}
|
|
originalChildren := originalInfo.properties[key]
|
|
currentForBranch := ojson.Parse(cleaned)
|
|
if path != "" {
|
|
currentForBranch = ojson.Get(cleaned, path)
|
|
}
|
|
if claudeParentBranchAcceptsChild(originalInfo, key, currentForBranch) || claudeOriginalsMayPermitChild(originals, root, key, currentForBranch) {
|
|
// Another alternative branch/candidate may accept this key without an
|
|
// explicit property schema (dynamic, pattern, or implicit-open matched
|
|
// permission); the collected explicit candidates do not constrain it
|
|
// then, so skip destructive recursion into this subtree.
|
|
continue
|
|
}
|
|
if child.IsObject() && len(originalChildren) > 0 {
|
|
cleaned = cleanClaudeToolArgumentsByTranslatedSchema(cleaned, translatedChildren, originalChildren, root, childPath, false)
|
|
} else if child.IsArray() && len(originalChildren) > 0 {
|
|
cleaned = cleanClaudeTranslatedArray(cleaned, translatedChildren, originalChildren, root, childPath)
|
|
}
|
|
}
|
|
}
|
|
currentAfterChildren := ojson.Parse(cleaned)
|
|
if path != "" {
|
|
currentAfterChildren = ojson.Get(cleaned, path)
|
|
}
|
|
if !currentAfterChildren.IsObject() {
|
|
return cleaned
|
|
}
|
|
var placeholdersToDelete []string
|
|
for _, placeholder := range []string{"reason", "_"} {
|
|
if _, declared := originalInfo.properties[placeholder]; declared {
|
|
continue
|
|
}
|
|
if originalInfo.required[placeholder] {
|
|
continue
|
|
}
|
|
if claudeInfoAnyBranchAllowsDynamic(originalInfo) || claudeOriginalsAnyBranchAllowsDynamic(originals, root) {
|
|
// Some alternative branch (or candidate schema) accepts dynamic keys, so
|
|
// this value may be legitimate user data under that branch even though
|
|
// another branch received an injected placeholder. Never delete it.
|
|
continue
|
|
}
|
|
if claudeOriginalsAnyCandidateAcceptsImplicitly(originals, root, currentAfterChildren) {
|
|
// Alternative candidate child schemas extracted from different union
|
|
// branches: one candidate that the current object matches accepts the
|
|
// key implicitly, so the value may be legitimate under that candidate.
|
|
continue
|
|
}
|
|
if claudeParentBranchAcceptsChild(originalInfo, placeholder, currentAfterChildren) {
|
|
// An alternative branch that the current object matches (it carries all
|
|
// of the branch's required keys) accepts this key by implicit-open or
|
|
// pattern permission, so the value may be legitimate under that branch.
|
|
continue
|
|
}
|
|
declaredDeep := false
|
|
for _, original := range originals {
|
|
if claudeOriginalDeclaresPropertyDeep(original, root, placeholder, 0, map[string]bool{}) {
|
|
declaredDeep = true
|
|
break
|
|
}
|
|
}
|
|
if declaredDeep {
|
|
continue
|
|
}
|
|
if _, ok := currentAfterChildren.Map()[placeholder]; !ok {
|
|
continue
|
|
}
|
|
injected := false
|
|
for _, translated := range translatedSchemas {
|
|
translatedInfo := analyzeClaudeObjectSchema(translated, translated)
|
|
placeholderSchemas, declaredTranslated := translatedInfo.properties[placeholder]
|
|
if !declaredTranslated {
|
|
continue
|
|
}
|
|
if placeholder == "reason" {
|
|
for _, placeholderSchema := range placeholderSchemas {
|
|
required := false
|
|
for _, req := range translated.Get("required").Array() {
|
|
if req.String() == "reason" {
|
|
required = true
|
|
}
|
|
}
|
|
if required || placeholderSchema.Get("description").String() == placeholderReasonDescription {
|
|
injected = true
|
|
}
|
|
}
|
|
// Also check required on union branches flattened into the analyzed info.
|
|
if !injected {
|
|
for _, req := range translated.Get("required").Array() {
|
|
if req.String() == "reason" {
|
|
injected = true
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for _, req := range translated.Get("required").Array() {
|
|
if req.String() == "_" {
|
|
injected = true
|
|
}
|
|
}
|
|
// The "_" placeholder is also marked required by addEmptySchemaPlaceholder;
|
|
// when branch flattening drops required, its boolean type is the fallback signal
|
|
// only for nested objects. At the top level, the Antigravity executor wraps tool
|
|
// schemas before its second sanitization pass, which can also inject "_" after
|
|
// translation; that post-translation injection is handled below by re-running
|
|
// the same schema cleaning on the translated schema.
|
|
if !injected && !topLevel {
|
|
for _, placeholderSchema := range placeholderSchemas {
|
|
if placeholderSchema.Get("type").String() == "boolean" {
|
|
injected = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Union branches: analyzeClaudeObjectSchema only resolves single-branch unions,
|
|
// so also scan raw union branches. A required placeholder alone does not prove
|
|
// injection (the original may legitimately require it in a branch, which the
|
|
// deep-declaration check above already excluded); here the original declares the
|
|
// field nowhere, so a required occurrence in a sent branch is the injected one.
|
|
if !injected {
|
|
for _, translated := range translatedSchemas {
|
|
for _, keyword := range []string{"anyOf", "oneOf"} {
|
|
for _, branch := range translated.Get(keyword).Array() {
|
|
branchInfo := analyzeClaudeObjectSchema(branch, branch)
|
|
if _, declaredBranch := branchInfo.properties[placeholder]; !declaredBranch {
|
|
continue
|
|
}
|
|
for _, req := range branch.Get("required").Array() {
|
|
if req.String() == placeholder {
|
|
injected = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// The Antigravity executor re-sanitizes tool schemas after translation (wrapping
|
|
// them so top-level objects become nested), which can inject placeholders that the
|
|
// translated request seen here does not yet contain. Re-running the same cleaning
|
|
// on the translated schema reproduces that final sent schema; if the placeholder
|
|
// appears there as required, it was injected post-translation. This simulation is
|
|
// only applied to closed objects (additionalProperties: false): open objects may
|
|
// legitimately carry the key as user data on routes without executor injection,
|
|
// and deleting based on a simulated injection would lose real arguments there.
|
|
if !injected && topLevel && originalInfo.forbidsDynamic {
|
|
for _, translated := range translatedSchemas {
|
|
// Mirror the executor's cleanNestedSchema wrapping: the schema is nested
|
|
// under a wrapper key before cleaning, so its top-level object counts as
|
|
// nested and can receive the "_" placeholder.
|
|
wrapped, errWrap := ojson.SetRaw("{}", "schema", translated.Raw)
|
|
if errWrap != nil {
|
|
continue
|
|
}
|
|
recleaned := ojson.Get(CleanJSONSchemaForAntigravity(wrapped), "schema")
|
|
if !recleaned.Exists() {
|
|
continue
|
|
}
|
|
recleanedInfo := analyzeClaudeObjectSchema(recleaned, recleaned)
|
|
if _, declaredRecleaned := recleanedInfo.properties[placeholder]; !declaredRecleaned {
|
|
continue
|
|
}
|
|
for _, req := range recleaned.Get("required").Array() {
|
|
if req.String() == placeholder {
|
|
injected = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if injected {
|
|
placeholdersToDelete = append(placeholdersToDelete, joinPath(path, placeholder))
|
|
}
|
|
}
|
|
doc := ojson.NewDocString(cleaned)
|
|
docModified := false
|
|
for _, placeholderPath := range placeholdersToDelete {
|
|
if doc.Delete(placeholderPath) == nil {
|
|
docModified = true
|
|
}
|
|
}
|
|
// Closed parameterless objects: if the original declared no properties and
|
|
// explicitly forbids additional properties (additionalProperties: false) without
|
|
// any candidate or union branch permitting dynamic data, normalize to "{}".
|
|
// Implicitly open objects (additionalProperties omitted) keep non-placeholder
|
|
// arguments after proven injected placeholders have been removed above.
|
|
allCandidatesDeclareObject := true
|
|
for _, original := range originals {
|
|
if !analyzeClaudeObjectSchema(original, root).declaresObject {
|
|
allCandidatesDeclareObject = false
|
|
break
|
|
}
|
|
}
|
|
currentForNormalize := doc.Get(path)
|
|
if path == "" {
|
|
if docModified {
|
|
cleaned = doc.String()
|
|
docModified = false
|
|
}
|
|
currentForNormalize = ojson.Parse(cleaned)
|
|
}
|
|
if !originalInfo.complex && allCandidatesDeclareObject && originalInfo.forbidsDynamic && !claudeInfoAnyBranchAllowsDynamic(originalInfo) && !claudeOriginalsAnyBranchAllowsDynamic(originals, root) && !claudeOriginalsAnyCandidateAcceptsImplicitly(originals, root, currentForNormalize) && originalInfo.declaresObject && len(originalInfo.required) == 0 && (!originalInfo.hasProperties || len(originalInfo.properties) == 0) {
|
|
if topLevel {
|
|
return "{}"
|
|
}
|
|
if doc.SetRaw(path, "{}") == nil {
|
|
return doc.String()
|
|
}
|
|
return cleaned
|
|
}
|
|
if docModified {
|
|
cleaned = doc.String()
|
|
}
|
|
parsedCleaned := ojson.Parse(cleaned)
|
|
if path != "" {
|
|
parsedCleaned = ojson.Get(cleaned, path)
|
|
}
|
|
if parsedCleaned.IsObject() && len(parsedCleaned.Map()) == 0 && path == "" {
|
|
return "{}"
|
|
}
|
|
_ = root
|
|
return cleaned
|
|
}
|
|
|
|
func cleanClaudeTranslatedArray(argsJSON string, translatedArraySchemas []ojson.Result, originalArraySchemas []ojson.Result, root ojson.Result, path string) string {
|
|
for _, schema := range originalArraySchemas {
|
|
if claudeArraySchemaUnsafe(schema, root) {
|
|
return argsJSON
|
|
}
|
|
}
|
|
var translatedItems []ojson.Result
|
|
var originalItems []ojson.Result
|
|
deterministic := true
|
|
for _, schema := range translatedArraySchemas {
|
|
items, okItems := resolveClaudeArrayItemsSchema(schema, schema, 0, map[string]bool{})
|
|
if !okItems {
|
|
deterministic = false
|
|
}
|
|
for _, item := range items {
|
|
translatedItems = appendUniqueSchema(translatedItems, item)
|
|
}
|
|
}
|
|
for _, schema := range originalArraySchemas {
|
|
items, okItems := resolveClaudeArrayItemsSchema(schema, root, 0, map[string]bool{})
|
|
if !okItems {
|
|
deterministic = false
|
|
}
|
|
if okItems && len(items) == 0 {
|
|
originalItems = appendUniqueSchema(originalItems, schema)
|
|
continue
|
|
}
|
|
for _, item := range items {
|
|
originalItems = appendUniqueSchema(originalItems, item)
|
|
}
|
|
}
|
|
if !deterministic || len(translatedItems) == 0 || len(originalItems) == 0 {
|
|
return argsJSON
|
|
}
|
|
cleaned := argsJSON
|
|
elementCount := len(ojson.Get(cleaned, path).Array())
|
|
for index := 0; index < elementCount; index++ {
|
|
elementPath := joinPath(path, strconv.Itoa(index))
|
|
element := ojson.Get(cleaned, elementPath)
|
|
if element.IsObject() {
|
|
cleaned = cleanClaudeToolArgumentsByTranslatedSchema(cleaned, translatedItems, originalItems, root, elementPath, false)
|
|
} else if element.IsArray() {
|
|
cleaned = cleanClaudeTranslatedArray(cleaned, translatedItems, originalItems, root, elementPath)
|
|
}
|
|
}
|
|
return cleaned
|
|
}
|
|
|
|
// CleanClaudeToolArgumentsWithTranslated strips placeholder arguments ("reason" or "_")
|
|
// only when the translated (actually-sent) tool schema shows that the placeholder was
|
|
// injected for that object (present in the translated schema with the placeholder
|
|
// description or marked required, while absent from the original declaration). When no
|
|
// translated schema is available it falls back to the original-schema inference used by
|
|
// CleanClaudeToolArguments. Parameterless tools are still normalized to "{}" because a
|
|
// strict Claude client rejects any argument for them.
|
|
func CleanClaudeToolArgumentsWithTranslated(rawArgs string, toolName string, originalRequestRawJSON []byte, translatedRequestRawJSON []byte) string {
|
|
if translatedSchemas := findTranslatedClaudeToolSchemas(translatedRequestRawJSON, toolName, originalRequestRawJSON); len(translatedSchemas) > 0 {
|
|
rawArgs = strings.TrimSpace(rawArgs)
|
|
if rawArgs == "" || rawArgs == "{}" {
|
|
return "{}"
|
|
}
|
|
if !ojson.Valid(rawArgs) || !ojson.Parse(rawArgs).IsObject() {
|
|
return rawArgs
|
|
}
|
|
schema, _, found := findClaudeToolSchema(originalRequestRawJSON, toolName)
|
|
if !found {
|
|
return rawArgs
|
|
}
|
|
if !schema.Exists() {
|
|
return "{}"
|
|
}
|
|
return cleanClaudeToolArgumentsByTranslatedSchema(rawArgs, translatedSchemas, []ojson.Result{schema}, schema, "", true)
|
|
}
|
|
return CleanClaudeToolArguments(rawArgs, toolName, originalRequestRawJSON)
|
|
}
|
|
|
|
// CleanClaudeToolArguments strips placeholder arguments ("reason" or "_") injected during
|
|
// schema normalization for empty object schemas when returning responses to Claude clients.
|
|
// If the tool was declared with empty or missing properties and additionalProperties: false,
|
|
// the arguments are normalized to "{}". Placeholder fields are also stripped recursively from declared nested object
|
|
// properties when they were not declared there. Free-form nested schemas that do not declare
|
|
// an object type or properties are preserved because no placeholder is injected for them.
|
|
// Tools that legitimately declared those fields or use union schemas that cannot be resolved
|
|
// deterministically are left untouched. Deterministic allOf, single-branch unions, and local
|
|
// $ref schemas are resolved within the tool schema scope, matching request translation.
|
|
func CleanClaudeToolArguments(rawArgs string, toolName string, originalRequestRawJSON []byte) string {
|
|
rawArgs = strings.TrimSpace(rawArgs)
|
|
if rawArgs == "" || rawArgs == "{}" {
|
|
return "{}"
|
|
}
|
|
if !ojson.Valid(rawArgs) {
|
|
return rawArgs
|
|
}
|
|
schema, root, found := findClaudeToolSchema(originalRequestRawJSON, toolName)
|
|
if !found {
|
|
return rawArgs
|
|
}
|
|
if !schema.Exists() {
|
|
return "{}"
|
|
}
|
|
argsResult := ojson.Parse(rawArgs)
|
|
if !argsResult.IsObject() {
|
|
return rawArgs
|
|
}
|
|
_ = root
|
|
info := analyzeClaudeObjectSchema(schema, schema)
|
|
if info.complex || !info.declaresObject {
|
|
return rawArgs
|
|
}
|
|
if len(info.required) == 0 && (!info.hasProperties || len(info.properties) == 0) && info.forbidsDynamic && !claudeInfoAnyBranchAllowsDynamic(info) {
|
|
return "{}"
|
|
}
|
|
return cleanClaudeToolObject(rawArgs, []ojson.Result{schema}, schema, "", true)
|
|
}
|