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
496 lines
22 KiB
Go
496 lines
22 KiB
Go
package util
|
|
|
|
import (
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/MoeForge/moego/ojson"
|
|
)
|
|
|
|
func TestCollectResponsesToolDescriptors_PriorityAndNamespace(t *testing.T) {
|
|
raw := `{
|
|
"tools": [
|
|
{"type": "function", "name": "top_fn", "description": "top function"}
|
|
],
|
|
"input": [
|
|
{
|
|
"type": "additional_tools",
|
|
"tools": [
|
|
{
|
|
"type": "namespace",
|
|
"name": "ns1",
|
|
"tools": [
|
|
{"type": "function", "name": "child_fn", "description": "child function"},
|
|
{"type": "custom", "name": "child_custom", "description": "child custom"}
|
|
]
|
|
},
|
|
{"type": "custom", "name": "direct_custom"}
|
|
]
|
|
}
|
|
]
|
|
}`
|
|
|
|
root := ojson.Parse(raw)
|
|
descriptors := CollectResponsesToolDescriptors(root)
|
|
if len(descriptors) != 4 {
|
|
t.Fatalf("expected 4 descriptors, got %d", len(descriptors))
|
|
}
|
|
|
|
decls, forwardMap, reverseMap := BuildGeminiFunctionDeclarations(root)
|
|
if len(decls) != 4 {
|
|
t.Fatalf("expected 4 declarations, got %d", len(decls))
|
|
}
|
|
|
|
if forwardMap["ns1__child_fn"] != "ns1__child_fn" {
|
|
t.Fatalf("forwardMap['ns1__child_fn'] = %q, want ns1__child_fn", forwardMap["ns1__child_fn"])
|
|
}
|
|
|
|
childCustomIdentity := reverseMap["ns1__child_custom"]
|
|
if childCustomIdentity.Name != "child_custom" || childCustomIdentity.Namespace != "ns1" || !childCustomIdentity.Custom {
|
|
t.Fatalf("unexpected reverseMap for ns1__child_custom: %+v", childCustomIdentity)
|
|
}
|
|
|
|
topFnIdentity := reverseMap["top_fn"]
|
|
if topFnIdentity.Name != "top_fn" || topFnIdentity.Namespace != "" || topFnIdentity.Custom {
|
|
t.Fatalf("unexpected reverseMap for top_fn: %+v", topFnIdentity)
|
|
}
|
|
}
|
|
|
|
func TestResponsesToolWinners_TopLevelBeatsAdditionalTools(t *testing.T) {
|
|
raw := `{
|
|
"tools": [
|
|
{"type": "function", "name": "shared_fn", "description": "top level"}
|
|
],
|
|
"input": [
|
|
{
|
|
"type": "additional_tools",
|
|
"tools": [
|
|
{"type": "function", "name": "shared_fn", "description": "additional"}
|
|
]
|
|
}
|
|
]
|
|
}`
|
|
|
|
root := ojson.Parse(raw)
|
|
winners := CollectResponsesToolWinners(root)
|
|
winner := winners["shared_fn"]
|
|
if winner.SourcePriority != 0 {
|
|
t.Fatalf("winner priority = %d, want 0", winner.SourcePriority)
|
|
}
|
|
if winner.Tool.Get("description").String() != "top level" {
|
|
t.Fatalf("winner description = %q, want 'top level'", winner.Tool.Get("description").String())
|
|
}
|
|
}
|
|
|
|
func TestResponsesToolWinners_DirectBeatsNamespaceChild(t *testing.T) {
|
|
raw := `{
|
|
"tools": [
|
|
{"type": "namespace", "name": "n", "tools": [{"type": "function", "name": "x", "description": "namespace child"}]},
|
|
{"type": "custom", "name": "n__x", "description": "direct"}
|
|
]
|
|
}`
|
|
|
|
root := ojson.Parse(raw)
|
|
winners := CollectResponsesToolWinners(root)
|
|
winner := winners["n__x"]
|
|
if !winner.Direct {
|
|
t.Fatalf("winner direct = %v, want true", winner.Direct)
|
|
}
|
|
if winner.ToolType != "custom" {
|
|
t.Fatalf("winner toolType = %q, want custom", winner.ToolType)
|
|
}
|
|
}
|
|
|
|
func TestConvertResponsesToolChoiceToGemini(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
choiceJSON string
|
|
forwardMap map[string]string
|
|
wantMode string
|
|
wantNames []string
|
|
}{
|
|
{
|
|
name: "auto string",
|
|
choiceJSON: `"auto"`,
|
|
wantMode: "AUTO",
|
|
},
|
|
{
|
|
name: "none string",
|
|
choiceJSON: `"none"`,
|
|
wantMode: "NONE",
|
|
},
|
|
{
|
|
name: "required string",
|
|
choiceJSON: `"required"`,
|
|
wantMode: "ANY",
|
|
},
|
|
{
|
|
name: "function object with namespace",
|
|
choiceJSON: `{"type": "function", "name": "my_fn", "namespace": "my_ns"}`,
|
|
forwardMap: map[string]string{"my_ns__my_fn": "my_ns__my_fn"},
|
|
wantMode: "ANY",
|
|
wantNames: []string{"my_ns__my_fn"},
|
|
},
|
|
{
|
|
name: "custom object",
|
|
choiceJSON: `{"type": "custom", "name": "exec", "namespace": "functions"}`,
|
|
forwardMap: map[string]string{"functions__exec": "functions__exec"},
|
|
wantMode: "ANY",
|
|
wantNames: []string{"functions__exec"},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
choice := ojson.Parse(tt.choiceJSON)
|
|
out, ok := ConvertResponsesToolChoiceToGemini(choice, tt.forwardMap)
|
|
if !ok {
|
|
t.Fatalf("ConvertResponsesToolChoiceToGemini returned false")
|
|
}
|
|
mode := ojson.GetBytes(out, "mode").String()
|
|
if mode != tt.wantMode {
|
|
t.Fatalf("mode = %q, want %q", mode, tt.wantMode)
|
|
}
|
|
if len(tt.wantNames) > 0 {
|
|
names := ojson.GetBytes(out, "allowedFunctionNames").Array()
|
|
if len(names) != len(tt.wantNames) {
|
|
t.Fatalf("allowedFunctionNames count = %d, want %d", len(names), len(tt.wantNames))
|
|
}
|
|
for i, want := range tt.wantNames {
|
|
if names[i].String() != want {
|
|
t.Fatalf("allowedFunctionNames[%d] = %q, want %q", i, names[i].String(), want)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestUnwrapResponsesCustomToolInput(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
want string
|
|
}{
|
|
{input: `{"input":"pwd"}`, want: "pwd"},
|
|
{input: `{"input":{"cmd":"ls"}}`, want: `{"cmd":"ls"}`},
|
|
{input: `"direct text"`, want: "direct text"},
|
|
{input: `{}`, want: ""},
|
|
{input: ``, want: ""},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
got := UnwrapResponsesCustomToolInput(tt.input)
|
|
if got != tt.want {
|
|
t.Errorf("UnwrapResponsesCustomToolInput(%q) = %q, want %q", tt.input, got, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBuildGeminiFunctionDeclarations_DisambiguationAndLongNames(t *testing.T) {
|
|
// Two tools that genuinely collide after sanitization (e.g. "read/file" vs "read_file"), and one > 64 chars
|
|
raw := `{
|
|
"tools": [
|
|
{"type": "function", "name": "read/file", "description": "tool with slash"},
|
|
{"type": "function", "name": "read_file", "description": "tool with underscore"},
|
|
{"type": "custom", "name": "mcp__very_very_very_very_very_very_long_namespace_name__very_very_very_long_custom_tool_name_that_exceeds_sixty_four_chars"}
|
|
]
|
|
}`
|
|
|
|
root := ojson.Parse(raw)
|
|
decls, forwardMap, reverseMap := BuildGeminiFunctionDeclarations(root)
|
|
if len(decls) != 3 {
|
|
t.Fatalf("expected 3 decls, got %d", len(decls))
|
|
}
|
|
|
|
name1 := forwardMap["read/file"]
|
|
name2 := forwardMap["read_file"]
|
|
if name1 == name2 {
|
|
t.Fatalf("colliding tools mapped to identical name: %q", name1)
|
|
}
|
|
|
|
identity1 := reverseMap[name1]
|
|
if identity1.Name != "read/file" {
|
|
t.Fatalf("reverseMap[%q].Name = %q, want read/file", name1, identity1.Name)
|
|
}
|
|
identity2 := reverseMap[name2]
|
|
if identity2.Name != "read_file" {
|
|
t.Fatalf("reverseMap[%q].Name = %q, want read_file", name2, identity2.Name)
|
|
}
|
|
|
|
longName := forwardMap["mcp__very_very_very_very_very_very_long_namespace_name__very_very_very_long_custom_tool_name_that_exceeds_sixty_four_chars"]
|
|
if len(longName) > 64 {
|
|
t.Fatalf("long tool name length = %d > 64: %q", len(longName), longName)
|
|
}
|
|
|
|
identityLong := reverseMap[longName]
|
|
if !identityLong.Custom || identityLong.Name != "mcp__very_very_very_very_very_very_long_namespace_name__very_very_very_long_custom_tool_name_that_exceeds_sixty_four_chars" {
|
|
t.Fatalf("unexpected reverse identity for long name: %+v", identityLong)
|
|
}
|
|
}
|
|
|
|
func TestBuildGeminiApplyPatchDeclaration(t *testing.T) {
|
|
root := ojson.Parse(`{"tools":[{"type":"custom","name":"apply_patch","format":{"type":"grammar","syntax":"lark","definition":"start: patch"}}]}`)
|
|
declarations, _, reverse := BuildGeminiFunctionDeclarations(root)
|
|
if len(declarations) != 1 {
|
|
t.Fatalf("declarations: %d", len(declarations))
|
|
}
|
|
declaration := ojson.ParseBytes(declarations[0])
|
|
if !strings.Contains(declaration.Get("description").String(), "*** Begin Patch") || !strings.Contains(declaration.Get("description").String(), "start: patch") {
|
|
t.Fatal("patch format is missing")
|
|
}
|
|
if declaration.Get("parametersJsonSchema.properties.input.type").String() != "string" || !declaration.Get("parametersJsonSchema.additionalProperties").Exists() || declaration.Get("parametersJsonSchema.additionalProperties").Bool() {
|
|
t.Fatal("input schema is missing")
|
|
}
|
|
if !reverse[declaration.Get("name").String()].Custom {
|
|
t.Fatal("custom client identity was lost")
|
|
}
|
|
}
|
|
|
|
func TestBuildGeminiApplyPatchIdentityUsesWinningOriginalDeclaration(t *testing.T) {
|
|
root := ojson.Parse(`{"tools":[{"type":"namespace","name":"a.b","tools":[{"type":"custom","name":"apply_patch"}]},{"type":"function","name":"a_b__apply_patch","parameters":{"type":"object","properties":{"n":{"type":"number"}}}},{"type":"function","name":"apply_patch"}],"input":[{"type":"additional_tools","tools":[{"type":"custom","name":"apply_patch"}]}]}`)
|
|
declarations, forward, reverse := BuildGeminiFunctionDeclarations(root)
|
|
if len(declarations) != 3 {
|
|
t.Fatalf("declarations=%d", len(declarations))
|
|
}
|
|
if forward["a.b__apply_patch"] == forward["a_b__apply_patch"] {
|
|
t.Fatal("sanitized collision was not separated")
|
|
}
|
|
for _, raw := range declarations {
|
|
decl := ojson.ParseBytes(raw)
|
|
identity := reverse[decl.Get("name").String()]
|
|
patch := identity.Custom && identity.Namespace == "a.b"
|
|
if identity.ApplyPatch != patch || strings.Contains(decl.Get("description").String(), "*** Begin Patch") != patch {
|
|
t.Fatalf("wrong winning identity=%+v declaration=%s", identity, raw)
|
|
}
|
|
}
|
|
if reverse[forward["apply_patch"]].Custom || reverse[forward["apply_patch"]].ApplyPatch {
|
|
t.Fatal("ordinary function became custom patch")
|
|
}
|
|
}
|
|
|
|
func TestBuildGeminiFunctionDeclarations_ClientToolSearchShimAndDeferredFiltering(t *testing.T) {
|
|
raw := `{
|
|
"tools": [
|
|
{"type": "function", "name": "exec_command", "parameters": {"type": "object", "properties": {"cmd": {"type": "string"}}}},
|
|
{"type": "tool_search", "execution": "client", "description": "Search deferred tools.", "parameters": {"type": "object", "properties": {"query": {"type": "string"}, "limit": {"type": "integer"}}, "required": ["query"], "additionalProperties": false}},
|
|
{"type": "function", "name": "deferred_fn", "defer_loading": true, "parameters": {"type": "object", "properties": {}}},
|
|
{"type": "web_search"}
|
|
]
|
|
}`
|
|
declarations, forwardMap, reverseMap := BuildGeminiFunctionDeclarations(ojson.Parse(raw))
|
|
|
|
if len(declarations) != 2 {
|
|
t.Fatalf("expected exec_command and tool_search declarations (with deferred_fn hidden), got %d: %s", len(declarations), declarations)
|
|
}
|
|
shim := ojson.ParseBytes(declarations[1])
|
|
if got := shim.Get("name").String(); got != "tool_search" {
|
|
t.Fatalf("shim name = %q, want tool_search", got)
|
|
}
|
|
if got := shim.Get("description").String(); got != "Search deferred tools." {
|
|
t.Fatalf("shim description = %q, want original description", got)
|
|
}
|
|
if got := shim.Get("parametersJsonSchema.required.0").String(); got != "query" {
|
|
t.Fatalf("shim parameters not preserved: %s", shim.Raw)
|
|
}
|
|
if got := forwardMap["tool_search"]; got != "tool_search" {
|
|
t.Fatalf("forward map for shim = %q, want tool_search", got)
|
|
}
|
|
if _, ok := reverseMap["tool_search"]; !ok {
|
|
t.Fatalf("expected tool_search in reverseMap")
|
|
}
|
|
if !reverseMap["tool_search"].ToolSearch || reverseMap["tool_search"].Custom || reverseMap["tool_search"].Namespace != "" {
|
|
t.Fatalf("unexpected shim identity: %+v", reverseMap["tool_search"])
|
|
}
|
|
if reverseMap["exec_command"].ToolSearch {
|
|
t.Fatalf("regular function must not be marked ToolSearch: %+v", reverseMap["exec_command"])
|
|
}
|
|
}
|
|
|
|
func TestBuildGeminiFunctionDeclarations_ToolSearchShimDefaultsAndPrecedence(t *testing.T) {
|
|
t.Run("default parameters when omitted and custom schema preserved when provided", func(t *testing.T) {
|
|
defaultDecls, _, _ := BuildGeminiFunctionDeclarations(ojson.Parse(`{"tools": [{"type": "tool_search", "execution": "client"}]}`))
|
|
if len(defaultDecls) != 1 {
|
|
t.Fatalf("expected one shim declaration, got %d", len(defaultDecls))
|
|
}
|
|
if got := ojson.GetBytes(defaultDecls[0], "parametersJsonSchema.properties.query.type").String(); got != "string" {
|
|
t.Fatalf("default parameters missing query: %s", defaultDecls[0])
|
|
}
|
|
if !ojson.GetBytes(defaultDecls[0], `parametersJsonSchema.required.#(=="query")`).Exists() {
|
|
t.Fatalf("default parameters missing required query: %s", defaultDecls[0])
|
|
}
|
|
|
|
customGoalRaw := `{"tools": [{"type": "tool_search", "execution": "client", "description": "Custom goal search", "parameters": {"type": "object", "properties": {"goal": {"type": "string"}}, "required": ["goal"], "additionalProperties": false}}]}`
|
|
customDecls, _, _ := BuildGeminiFunctionDeclarations(ojson.Parse(customGoalRaw))
|
|
if len(customDecls) != 1 {
|
|
t.Fatalf("expected one shim declaration, got %d", len(customDecls))
|
|
}
|
|
if got := ojson.GetBytes(customDecls[0], "parametersJsonSchema.properties.goal.type").String(); got != "string" {
|
|
t.Fatalf("custom goal property not preserved: %s", customDecls[0])
|
|
}
|
|
if ojson.GetBytes(customDecls[0], "parametersJsonSchema.properties.query").Exists() {
|
|
t.Fatalf("custom schema must not be mutated to inject query: %s", customDecls[0])
|
|
}
|
|
if ojson.GetBytes(customDecls[0], `parametersJsonSchema.required.#(=="query")`).Exists() {
|
|
t.Fatalf("custom required array must not inject query: %s", customDecls[0])
|
|
}
|
|
})
|
|
t.Run("server executed search is not emulated", func(t *testing.T) {
|
|
raw := `{"tools": [{"type": "tool_search"}, {"type": "tool_search", "execution": "server"}]}`
|
|
declarations, _, reverseMap := BuildGeminiFunctionDeclarations(ojson.Parse(raw))
|
|
if len(declarations) != 0 || len(reverseMap) != 0 {
|
|
t.Fatalf("server-executed tool_search must be dropped, got %s", declarations)
|
|
}
|
|
})
|
|
t.Run("user function and client tool_search coexist in both orders", func(t *testing.T) {
|
|
for _, userFnName := range []string{"tool_search", "__cpa_client_tool_search__"} {
|
|
for _, tc := range []struct {
|
|
name string
|
|
raw string
|
|
}{
|
|
{
|
|
name: userFnName + "/user function first",
|
|
raw: `{"tools": [{"type": "function", "name": "` + userFnName + `", "description": "user tool"}, {"type": "tool_search", "execution": "client", "description": "client search"}, {"type": "function", "name": "deferred_fn", "defer_loading": true}]}`,
|
|
},
|
|
{
|
|
name: userFnName + "/client tool_search first",
|
|
raw: `{"tools": [{"type": "tool_search", "execution": "client", "description": "client search"}, {"type": "function", "name": "` + userFnName + `", "description": "user tool"}, {"type": "function", "name": "deferred_fn", "defer_loading": true}]}`,
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
declarations, forwardMap, reverseMap := BuildGeminiFunctionDeclarations(ojson.Parse(tc.raw))
|
|
if len(declarations) != 2 {
|
|
t.Fatalf("expected both user %s and client tool_search shim (with deferred_fn hidden), got %d declarations: %s", userFnName, len(declarations), declarations)
|
|
}
|
|
userGeminiName := forwardMap[userFnName]
|
|
shimGeminiName := MapResponsesClientToolSearchName(forwardMap)
|
|
if userGeminiName != userFnName {
|
|
t.Fatalf("user function Gemini name = %q, want %s", userGeminiName, userFnName)
|
|
}
|
|
if shimGeminiName == "" || shimGeminiName == userGeminiName {
|
|
t.Fatalf("shim Gemini name = %q, must be non-empty and distinct from %q", shimGeminiName, userGeminiName)
|
|
}
|
|
if reverseMap[userGeminiName].ToolSearch || reverseMap[userGeminiName].Name != userFnName {
|
|
t.Fatalf("user function identity = %+v, want non-ToolSearch function named %s", reverseMap[userGeminiName], userFnName)
|
|
}
|
|
if !reverseMap[shimGeminiName].ToolSearch {
|
|
t.Fatalf("shim identity = %+v, want ToolSearch=true", reverseMap[shimGeminiName])
|
|
}
|
|
})
|
|
}
|
|
}
|
|
})
|
|
t.Run("sanitized name collision with tool.search keeps both", func(t *testing.T) {
|
|
raw := `{"tools": [{"type": "function", "name": "tool.search", "description": "dotted user tool"}, {"type": "tool_search", "execution": "client", "description": "client search"}]}`
|
|
declarations, forwardMap, reverseMap := BuildGeminiFunctionDeclarations(ojson.Parse(raw))
|
|
if len(declarations) != 2 {
|
|
t.Fatalf("expected 2 declarations, got %d: %s", len(declarations), declarations)
|
|
}
|
|
dottedGeminiName := forwardMap["tool.search"]
|
|
shimGeminiName := MapResponsesClientToolSearchName(forwardMap)
|
|
if shimGeminiName != "tool_search" {
|
|
t.Fatalf("shim Gemini name = %q, want tool_search", shimGeminiName)
|
|
}
|
|
if dottedGeminiName == "" || dottedGeminiName == shimGeminiName {
|
|
t.Fatalf("dotted user tool Gemini name = %q, must be distinct from %q", dottedGeminiName, shimGeminiName)
|
|
}
|
|
if reverseMap[dottedGeminiName].ToolSearch || reverseMap[dottedGeminiName].Name != "tool.search" {
|
|
t.Fatalf("dotted tool identity = %+v", reverseMap[dottedGeminiName])
|
|
}
|
|
if !reverseMap[shimGeminiName].ToolSearch {
|
|
t.Fatalf("shim identity = %+v", reverseMap[shimGeminiName])
|
|
}
|
|
})
|
|
t.Run("shared CollectResponsesToolDescriptors keeps deferred tools for non-search callers", func(t *testing.T) {
|
|
raw := `{"tools": [{"type": "tool_search", "execution": "client"}, {"type": "function", "name": "deferred_fn", "defer_loading": true}, {"type": "function", "name": "eager_fn"}]}`
|
|
descriptors := CollectResponsesToolDescriptors(ojson.Parse(raw))
|
|
if len(descriptors) != 2 || descriptors[0].Name != "deferred_fn" || descriptors[1].Name != "eager_fn" {
|
|
t.Fatalf("CollectResponsesToolDescriptors = %+v, want [deferred_fn eager_fn]", descriptors)
|
|
}
|
|
})
|
|
t.Run("additional_tools declaration", func(t *testing.T) {
|
|
raw := `{"input": [{"type": "additional_tools", "tools": [{"type": "tool_search", "execution": "client"}]}]}`
|
|
_, _, reverseMap := BuildGeminiFunctionDeclarations(ojson.Parse(raw))
|
|
if !reverseMap[ResponsesToolSearchFunctionName].ToolSearch {
|
|
t.Fatalf("tool_search inside additional_tools must be exposed: %+v", reverseMap)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestBuildGeminiFunctionDeclarations_CollectsToolSearchOutputTools(t *testing.T) {
|
|
raw := `{
|
|
"tools": [
|
|
{"type": "namespace", "name": "mcp__cua_repl", "tools": [{"type": "function", "name": "js", "description": "current"}]},
|
|
{"type": "tool_search", "execution": "client"},
|
|
{"type": "function", "name": "deferred_fn", "defer_loading": true, "description": "top-level deferred"}
|
|
],
|
|
"input": [
|
|
{"type": "tool_search_call", "execution": "client", "call_id": "search_1", "status": "completed", "arguments": {"query": "fixture"}},
|
|
{"type": "tool_search_output", "execution": "client", "call_id": "search_1", "status": "completed", "tools": [
|
|
{"type": "namespace", "name": "fixture_tools", "description": "fixture", "tools": [
|
|
{"type": "function", "name": "ping", "defer_loading": true, "parameters": {"type": "object", "properties": {}, "additionalProperties": false}}
|
|
]},
|
|
{"type": "namespace", "name": "mcp__cua_repl", "tools": [{"type": "function", "name": "js", "description": "discovered"}]}
|
|
]},
|
|
{"type": "tool_search_output", "execution": "client", "call_id": "search_2", "status": "completed", "tools": [
|
|
{"type": "namespace", "name": "fixture_tools", "tools": [{"type": "function", "name": "ping", "description": "again"}]}
|
|
]}
|
|
]
|
|
}`
|
|
declarations, forwardMap, reverseMap := BuildGeminiFunctionDeclarations(ojson.Parse(raw))
|
|
|
|
names := make([]string, 0, len(declarations))
|
|
for _, declaration := range declarations {
|
|
names = append(names, ojson.GetBytes(declaration, "name").String())
|
|
}
|
|
if len(names) != 3 || names[0] != "mcp__cua_repl__js" || names[1] != "tool_search" || names[2] != "fixture_tools__ping" {
|
|
t.Fatalf("declarations = %v, want [mcp__cua_repl__js tool_search fixture_tools__ping]", names)
|
|
}
|
|
if got := ojson.GetBytes(declarations[0], "description").String(); got != "current" {
|
|
t.Fatalf("top-level declaration must win over a discovered duplicate, got %q", got)
|
|
}
|
|
if got := forwardMap["fixture_tools__ping"]; got != "fixture_tools__ping" {
|
|
t.Fatalf("forward map for discovered tool = %q", got)
|
|
}
|
|
identity := reverseMap["fixture_tools__ping"]
|
|
if identity.Name != "ping" || identity.Namespace != "fixture_tools" {
|
|
t.Fatalf("discovered identity = %+v, want ping in fixture_tools", identity)
|
|
}
|
|
}
|
|
|
|
func TestResponsesToolReverseIdentityMap_MatchesFullDeclarations(t *testing.T) {
|
|
minimalRaw := []byte(`{
|
|
"tools": [
|
|
{"type": "function", "name": "read.file", "parameters": {"type": "object"}},
|
|
{"type": "custom", "name": "apply_patch", "description": "Apply a patch", "format": {"type": "grammar", "syntax": "lark", "definition": "start: /.+/"}},
|
|
{"type": "custom", "name": "notes"},
|
|
{"type": "tool_search", "execution": "client"},
|
|
{"type": "namespace", "name": "mcp", "tools": [{"type": "function", "name": "search", "parameters": {"type": "object"}}]}
|
|
]
|
|
}`)
|
|
heavyRaw := []byte(`{
|
|
"tools": [
|
|
{"type": "function", "name": "read.file", "parameters": {"$defs": {"item": {"type": "object", "properties": {"id": {"type": "string", "pattern": "^[^\\x00]*$", "examples": ["/tmp/a"]}}}}, "type": "object", "properties": {"path": {"type": "string", "pattern": "^[^\\x00]*$", "examples": ["/tmp/a"]}, "items": {"type": "array", "items": {"$ref": "#/$defs/item"}}, "mode": {"anyOf": [{"type": "string", "const": "fast"}, {"type": "null"}]}}, "additionalProperties": false}},
|
|
{"type": "custom", "name": "apply_patch", "description": "Apply a patch", "format": {"type": "grammar", "syntax": "lark", "definition": "start: /.+/"}},
|
|
{"type": "custom", "name": "notes"},
|
|
{"type": "tool_search", "execution": "client", "parameters": {"type": "object", "properties": {"query": {"type": ["string", "null"], "examples": ["mcp"]}, "limit": {"type": "number", "minimum": 1, "maximum": 50}}, "required": ["query"], "additionalProperties": false}},
|
|
{"type": "namespace", "name": "mcp", "tools": [{"type": "function", "name": "search", "parameters": {"$defs": {"filter": {"type": "object", "properties": {"tag": {"type": ["string", "null"]}}}}, "type": "object", "properties": {"q": {"type": ["string", "null"]}, "filter": {"$ref": "#/$defs/filter"}}, "additionalProperties": false}}]}
|
|
]
|
|
}`)
|
|
_, _, full := BuildGeminiFunctionDeclarations(ojson.ParseBytes(heavyRaw))
|
|
fast := ResponsesToolReverseIdentityMap(heavyRaw)
|
|
if len(full) == 0 || !reflect.DeepEqual(full, fast) {
|
|
t.Fatalf("reverse identity map differs from full declarations:\nfull=%#v\nfast=%#v", full, fast)
|
|
}
|
|
|
|
minimalAllocs := testing.AllocsPerRun(10, func() {
|
|
_ = ResponsesToolReverseIdentityMap(minimalRaw)
|
|
})
|
|
heavyAllocs := testing.AllocsPerRun(10, func() {
|
|
_ = ResponsesToolReverseIdentityMap(heavyRaw)
|
|
})
|
|
if heavyAllocs > minimalAllocs+10 {
|
|
t.Fatalf("ResponsesToolReverseIdentityMap performed schema cleanup allocations: minimalAllocs=%.1f heavyAllocs=%.1f", minimalAllocs, heavyAllocs)
|
|
}
|
|
}
|