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
674 lines
24 KiB
Go
674 lines
24 KiB
Go
package util
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
|
|
"github.com/MoeForge/moego/ojson"
|
|
applypatch "github.com/router-for-me/CLIProxyAPI/v8/internal/client/codex/apply-patch"
|
|
)
|
|
|
|
// ResponsesToolIdentity represents the resolved identity of a tool in OpenAI Responses format.
|
|
type ResponsesToolIdentity struct {
|
|
Name string
|
|
Namespace string
|
|
Custom bool
|
|
ApplyPatch bool // Resolved from the winning original declaration, never from the upstream name.
|
|
ToolSearch bool // Marks the function shim standing in for a client-executed tool_search declaration.
|
|
}
|
|
|
|
const (
|
|
// ResponsesToolSearchType is the Responses tool type for deferred tool discovery.
|
|
ResponsesToolSearchType = "tool_search"
|
|
// ResponsesToolSearchExecutionClient marks a tool_search that the client executes itself.
|
|
ResponsesToolSearchExecutionClient = "client"
|
|
// ResponsesToolSearchFunctionName is the function name exposed to providers
|
|
// that have no native tool_search support.
|
|
ResponsesToolSearchFunctionName = "tool_search"
|
|
// ResponsesClientToolSearchKey is the internal forwardMap key for the
|
|
// client-executed tool_search shim. The leading NUL byte cannot appear in a
|
|
// JSON identifier, preventing collisions with user-declared tool names.
|
|
ResponsesClientToolSearchKey = "\x00client_tool_search"
|
|
// ResponsesToolSearchCallType is the Responses item type for a tool_search invocation.
|
|
ResponsesToolSearchCallType = "tool_search_call"
|
|
// ResponsesToolSearchOutputType is the Responses input item carrying discovered tools.
|
|
ResponsesToolSearchOutputType = "tool_search_output"
|
|
// ResponsesDiscoveredToolPriority ranks tools loaded by tool_search_output after declared tools.
|
|
ResponsesDiscoveredToolPriority = 2
|
|
|
|
responsesToolSearchDefaultParameters = `{"type":"object","properties":{"query":{"type":"string","description":"Search query for deferred tools."},"limit":{"type":"number","description":"Maximum number of tools to return."}},"required":["query"],"additionalProperties":false}`
|
|
)
|
|
|
|
// ResponsesToolDescriptor is an internal representation of a tool declaration in a Responses request.
|
|
type ResponsesToolDescriptor struct {
|
|
Name string // Qualified name (e.g. "functions__exec" or "exec")
|
|
LocalName string // Local name without namespace (e.g. "exec")
|
|
Namespace string // Namespace if any (e.g. "functions")
|
|
ToolType string // "function", "custom", etc.
|
|
Tool ojson.Result
|
|
SourcePriority int // 0 for top-level tools, 1 for additional_tools, 2 for tool_search_output
|
|
Direct bool // true if declared directly, false if declared as namespace child
|
|
Order int // original discovery order
|
|
ClientSearch bool // true for a client-executed tool_search declaration
|
|
}
|
|
|
|
// QualifyResponsesNamespaceToolName qualifies a child tool name with its namespace.
|
|
func QualifyResponsesNamespaceToolName(namespaceName, childName string) string {
|
|
childName = strings.TrimSpace(childName)
|
|
namespaceName = strings.TrimSpace(namespaceName)
|
|
if childName == "" || namespaceName == "" || strings.HasPrefix(childName, "mcp__") {
|
|
return childName
|
|
}
|
|
if childName == namespaceName || strings.HasPrefix(childName, namespaceName+"__") {
|
|
return childName
|
|
}
|
|
if strings.HasSuffix(namespaceName, "__") {
|
|
return namespaceName + childName
|
|
}
|
|
return namespaceName + "__" + childName
|
|
}
|
|
|
|
func responsesToolSources(root ojson.Result, includeClientToolSearch bool) []struct {
|
|
tools ojson.Result
|
|
priority int
|
|
} {
|
|
return responsesToolSourcesFromGetter(root.Get, includeClientToolSearch)
|
|
}
|
|
|
|
func responsesToolSourcesFromGetter(get func(string) ojson.Result, includeClientToolSearch bool) []struct {
|
|
tools ojson.Result
|
|
priority int
|
|
} {
|
|
if get == nil {
|
|
return nil
|
|
}
|
|
var sources []struct {
|
|
tools ojson.Result
|
|
priority int
|
|
}
|
|
appendSource := func(tools ojson.Result, priority int) {
|
|
if tools.Exists() && tools.IsArray() {
|
|
sources = append(sources, struct {
|
|
tools ojson.Result
|
|
priority int
|
|
}{tools: tools, priority: priority})
|
|
}
|
|
}
|
|
appendSource(get("tools"), 0)
|
|
if input := get("input"); input.Exists() && input.IsArray() {
|
|
input.ForEach(func(_, item ojson.Result) bool {
|
|
if item.Get("type").String() == "additional_tools" {
|
|
appendSource(item.Get("tools"), 1)
|
|
}
|
|
return true
|
|
})
|
|
if includeClientToolSearch {
|
|
input.ForEach(func(_, item ojson.Result) bool {
|
|
if item.Get("type").String() == ResponsesToolSearchOutputType && IsResponsesClientToolSearchItem(item) {
|
|
appendSource(item.Get("tools"), ResponsesDiscoveredToolPriority)
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
}
|
|
return sources
|
|
}
|
|
|
|
// IsResponsesClientToolSearchDeclaration reports whether a tool declaration is
|
|
// a client-executed Responses tool_search.
|
|
func IsResponsesClientToolSearchDeclaration(tool ojson.Result) bool {
|
|
return strings.TrimSpace(tool.Get("type").String()) == ResponsesToolSearchType &&
|
|
strings.TrimSpace(tool.Get("execution").String()) == ResponsesToolSearchExecutionClient
|
|
}
|
|
|
|
// IsResponsesClientToolSearchItem reports whether a tool_search_call or
|
|
// tool_search_output input item belongs to client-executed tool search.
|
|
// Hosted server search explicitly sets execution to "server".
|
|
func IsResponsesClientToolSearchItem(item ojson.Result) bool {
|
|
execution := strings.TrimSpace(item.Get("execution").String())
|
|
return execution == "" || execution == ResponsesToolSearchExecutionClient
|
|
}
|
|
|
|
func responsesToolName(tool ojson.Result) string {
|
|
if name := strings.TrimSpace(tool.Get("name").String()); name != "" {
|
|
return name
|
|
}
|
|
return strings.TrimSpace(tool.Get("function.name").String())
|
|
}
|
|
|
|
// ResponsesToolDescription extracts the description from a tool or function object.
|
|
func ResponsesToolDescription(tool ojson.Result) string {
|
|
if description := tool.Get("description").String(); description != "" {
|
|
return description
|
|
}
|
|
return tool.Get("function.description").String()
|
|
}
|
|
|
|
func responsesToolDescription(tool ojson.Result) string {
|
|
return ResponsesToolDescription(tool)
|
|
}
|
|
|
|
// ResponsesToolParameters extracts the schema/parameters from a tool or function object.
|
|
func ResponsesToolParameters(tool ojson.Result) ojson.Result {
|
|
for _, path := range []string{
|
|
"parameters",
|
|
"parametersJsonSchema",
|
|
"input_schema",
|
|
"function.parameters",
|
|
"function.parametersJsonSchema",
|
|
} {
|
|
if parameters := tool.Get(path); parameters.Exists() {
|
|
return parameters
|
|
}
|
|
}
|
|
return ojson.Result{}
|
|
}
|
|
|
|
func responsesToolParameters(tool ojson.Result) ojson.Result {
|
|
return ResponsesToolParameters(tool)
|
|
}
|
|
|
|
// CollectResponsesToolDescriptors extracts all tool descriptors from a Responses request root.
|
|
func CollectResponsesToolDescriptors(root ojson.Result) []ResponsesToolDescriptor {
|
|
return collectResponsesToolDescriptors(root, false)
|
|
}
|
|
|
|
// CollectResponsesToolDescriptorsDoc extracts all tool descriptors from a Responses request doc.
|
|
func CollectResponsesToolDescriptorsDoc(doc *ojson.Doc) []ResponsesToolDescriptor {
|
|
if doc == nil || doc.Len() == 0 {
|
|
return nil
|
|
}
|
|
return collectResponsesToolDescriptorsFromGetter(doc.Get, false)
|
|
}
|
|
|
|
func collectResponsesToolDescriptors(root ojson.Result, includeClientToolSearch bool) []ResponsesToolDescriptor {
|
|
return collectResponsesToolDescriptorsFromGetter(root.Get, includeClientToolSearch)
|
|
}
|
|
|
|
func collectResponsesToolDescriptorsFromGetter(get func(string) ojson.Result, includeClientToolSearch bool) []ResponsesToolDescriptor {
|
|
var descriptors []ResponsesToolDescriptor
|
|
appendDescriptor := func(tool ojson.Result, name, localName, namespace string, toolType string, sourcePriority int, direct bool, clientSearch bool) {
|
|
if name == "" {
|
|
return
|
|
}
|
|
descriptors = append(descriptors, ResponsesToolDescriptor{
|
|
Name: name,
|
|
LocalName: localName,
|
|
Namespace: namespace,
|
|
ToolType: toolType,
|
|
Tool: tool,
|
|
SourcePriority: sourcePriority,
|
|
Direct: direct,
|
|
Order: len(descriptors),
|
|
ClientSearch: clientSearch,
|
|
})
|
|
}
|
|
appendNamespaceChildren := func(namespaceTool ojson.Result, sourcePriority int) {
|
|
namespaceName := strings.TrimSpace(namespaceTool.Get("name").String())
|
|
children := namespaceTool.Get("tools")
|
|
if !children.Exists() || !children.IsArray() {
|
|
children = namespaceTool.Get("children")
|
|
}
|
|
if !children.Exists() || !children.IsArray() {
|
|
return
|
|
}
|
|
children.ForEach(func(_, child ojson.Result) bool {
|
|
childName := responsesToolName(child)
|
|
if childName == "" {
|
|
return true
|
|
}
|
|
qualifiedName := QualifyResponsesNamespaceToolName(namespaceName, childName)
|
|
switch strings.TrimSpace(child.Get("type").String()) {
|
|
case "", "function":
|
|
appendDescriptor(child, qualifiedName, childName, namespaceName, "function", sourcePriority, false, false)
|
|
case "custom":
|
|
appendDescriptor(child, qualifiedName, childName, namespaceName, "custom", sourcePriority, false, false)
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
for _, source := range responsesToolSourcesFromGetter(get, includeClientToolSearch) {
|
|
source.tools.ForEach(func(_, tool ojson.Result) bool {
|
|
toolType := strings.TrimSpace(tool.Get("type").String())
|
|
switch toolType {
|
|
case "", "function":
|
|
name := responsesToolName(tool)
|
|
appendDescriptor(tool, name, name, "", "function", source.priority, true, false)
|
|
case "custom":
|
|
name := responsesToolName(tool)
|
|
appendDescriptor(tool, name, name, "", "custom", source.priority, true, false)
|
|
case "namespace":
|
|
appendNamespaceChildren(tool, source.priority)
|
|
case ResponsesToolSearchType:
|
|
if includeClientToolSearch && source.priority < ResponsesDiscoveredToolPriority && IsResponsesClientToolSearchDeclaration(tool) {
|
|
appendDescriptor(tool, ResponsesToolSearchFunctionName, ResponsesToolSearchFunctionName, "", ResponsesToolSearchType, source.priority, true, true)
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
|
|
if !includeClientToolSearch || !responsesHasClientToolSearch(descriptors) {
|
|
return descriptors
|
|
}
|
|
kept := make([]ResponsesToolDescriptor, 0, len(descriptors))
|
|
for _, descriptor := range descriptors {
|
|
if !descriptor.ClientSearch && descriptor.SourcePriority != ResponsesDiscoveredToolPriority && descriptor.Tool.Get("defer_loading").Bool() {
|
|
continue
|
|
}
|
|
descriptor.Order = len(kept)
|
|
kept = append(kept, descriptor)
|
|
}
|
|
return kept
|
|
}
|
|
|
|
func responsesHasClientToolSearch(descriptors []ResponsesToolDescriptor) bool {
|
|
for i := range descriptors {
|
|
if descriptors[i].ClientSearch {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func responsesToolDescriptorPrecedes(left, right ResponsesToolDescriptor) bool {
|
|
if left.SourcePriority != right.SourcePriority {
|
|
return left.SourcePriority < right.SourcePriority
|
|
}
|
|
if left.Direct != right.Direct {
|
|
return left.Direct
|
|
}
|
|
return left.Order < right.Order
|
|
}
|
|
|
|
// CollectResponsesToolWinners collects deduplicated winning descriptors for each qualified tool name.
|
|
func CollectResponsesToolWinners(root ojson.Result) map[string]ResponsesToolDescriptor {
|
|
return collectResponsesToolWinnersFromDescriptors(CollectResponsesToolDescriptors(root))
|
|
}
|
|
|
|
// CollectResponsesToolWinnersDoc collects deduplicated winning descriptors from doc.
|
|
func CollectResponsesToolWinnersDoc(doc *ojson.Doc) map[string]ResponsesToolDescriptor {
|
|
return collectResponsesToolWinnersFromDescriptors(CollectResponsesToolDescriptorsDoc(doc))
|
|
}
|
|
|
|
func collectResponsesToolWinnersFromDescriptors(descriptors []ResponsesToolDescriptor) map[string]ResponsesToolDescriptor {
|
|
winners := map[string]ResponsesToolDescriptor{}
|
|
for _, descriptor := range descriptors {
|
|
current, exists := winners[descriptor.Name]
|
|
if !exists || responsesToolDescriptorPrecedes(descriptor, current) {
|
|
winners[descriptor.Name] = descriptor
|
|
}
|
|
}
|
|
return winners
|
|
}
|
|
|
|
func sanitizeResponsesToolNames(names []string) map[string]string {
|
|
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 = disambiguateResponsesSanitizedName(base, name, used)
|
|
}
|
|
out[name] = mapped
|
|
used[mapped] = name
|
|
}
|
|
return out
|
|
}
|
|
|
|
func disambiguateResponsesSanitizedName(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
|
|
}
|
|
}
|
|
}
|
|
|
|
type responsesToolWinnerKey struct {
|
|
name string
|
|
clientSearch bool
|
|
}
|
|
|
|
// BuildGeminiFunctionDeclarations builds Gemini function declarations, forward name mapping, and reverse identity mapping.
|
|
func BuildGeminiFunctionDeclarations(root ojson.Result) ([][]byte, map[string]string, map[string]ResponsesToolIdentity) {
|
|
return buildGeminiFunctionDeclarations(root, true)
|
|
}
|
|
|
|
// buildGeminiFunctionDeclarations skips per-tool declaration construction and schema
|
|
// cleanup when the caller only needs the name and identity maps.
|
|
func buildGeminiFunctionDeclarations(root ojson.Result, withDeclarations bool) ([][]byte, map[string]string, map[string]ResponsesToolIdentity) {
|
|
descriptors := collectResponsesToolDescriptors(root, true)
|
|
winners := make(map[responsesToolWinnerKey]ResponsesToolDescriptor, len(descriptors))
|
|
for _, descriptor := range descriptors {
|
|
key := responsesToolWinnerKey{name: descriptor.Name, clientSearch: descriptor.ClientSearch}
|
|
current, exists := winners[key]
|
|
if !exists || responsesToolDescriptorPrecedes(descriptor, current) {
|
|
winners[key] = descriptor
|
|
}
|
|
}
|
|
|
|
seenKeys := make(map[responsesToolWinnerKey]struct{}, len(winners))
|
|
var winningList []ResponsesToolDescriptor
|
|
for _, descriptor := range descriptors {
|
|
key := responsesToolWinnerKey{name: descriptor.Name, clientSearch: descriptor.ClientSearch}
|
|
winner, ok := winners[key]
|
|
if !ok || winner.Order != descriptor.Order {
|
|
continue
|
|
}
|
|
if _, seen := seenKeys[key]; seen {
|
|
continue
|
|
}
|
|
seenKeys[key] = struct{}{}
|
|
winningList = append(winningList, descriptor)
|
|
}
|
|
|
|
hasClientSearchHistory := false
|
|
if include := root.Get("input"); include.Exists() && include.IsArray() {
|
|
include.ForEach(func(_, item ojson.Result) bool {
|
|
typ := item.Get("type").String()
|
|
if (typ == ResponsesToolSearchCallType || typ == ResponsesToolSearchOutputType) && IsResponsesClientToolSearchItem(item) {
|
|
hasClientSearchHistory = true
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
|
|
if len(winningList) == 0 {
|
|
if !hasClientSearchHistory {
|
|
return nil, nil, nil
|
|
}
|
|
forwardMap := map[string]string{
|
|
ResponsesClientToolSearchKey: ResponsesToolSearchFunctionName,
|
|
ResponsesToolSearchFunctionName: ResponsesToolSearchFunctionName,
|
|
}
|
|
reverseMap := map[string]ResponsesToolIdentity{
|
|
ResponsesToolSearchFunctionName: {
|
|
Name: ResponsesToolSearchFunctionName,
|
|
ToolSearch: true,
|
|
},
|
|
}
|
|
return nil, forwardMap, reverseMap
|
|
}
|
|
|
|
hasClientSearch := false
|
|
userOwnsExactToolSearch := false
|
|
qualifiedNames := make([]string, 0, len(winningList))
|
|
for _, desc := range winningList {
|
|
if desc.ClientSearch {
|
|
hasClientSearch = true
|
|
continue
|
|
}
|
|
if desc.Name == ResponsesToolSearchFunctionName {
|
|
userOwnsExactToolSearch = true
|
|
}
|
|
qualifiedNames = append(qualifiedNames, desc.Name)
|
|
}
|
|
sanitizedMap := sanitizeResponsesToolNames(qualifiedNames)
|
|
if sanitizedMap == nil {
|
|
sanitizedMap = make(map[string]string, len(winningList))
|
|
}
|
|
|
|
clientSearchGeminiName := ""
|
|
if hasClientSearch || hasClientSearchHistory {
|
|
used := make(map[string]string, len(sanitizedMap)+1)
|
|
for origName, mappedName := range sanitizedMap {
|
|
used[mappedName] = origName
|
|
}
|
|
if !userOwnsExactToolSearch {
|
|
// Reserve "tool_search" for the client tool_search shim and
|
|
// disambiguate any non-exact tool (e.g. "tool.search") that sanitized to it.
|
|
if collidingOrig, taken := used[ResponsesToolSearchFunctionName]; taken && collidingOrig != ResponsesToolSearchFunctionName {
|
|
used[ResponsesToolSearchFunctionName] = ResponsesClientToolSearchKey
|
|
newMapped := disambiguateResponsesSanitizedName(ResponsesToolSearchFunctionName, collidingOrig, used)
|
|
sanitizedMap[collidingOrig] = newMapped
|
|
used[newMapped] = collidingOrig
|
|
} else {
|
|
used[ResponsesToolSearchFunctionName] = ResponsesClientToolSearchKey
|
|
}
|
|
clientSearchGeminiName = ResponsesToolSearchFunctionName
|
|
} else {
|
|
clientSearchGeminiName = disambiguateResponsesSanitizedName(ResponsesToolSearchFunctionName, ResponsesClientToolSearchKey, used)
|
|
used[clientSearchGeminiName] = ResponsesClientToolSearchKey
|
|
}
|
|
}
|
|
|
|
forwardMap := make(map[string]string, len(winningList)*2+1)
|
|
reverseMap := make(map[string]ResponsesToolIdentity, len(winningList)*2+1)
|
|
if clientSearchGeminiName != "" {
|
|
forwardMap[ResponsesClientToolSearchKey] = clientSearchGeminiName
|
|
forwardMap[clientSearchGeminiName] = clientSearchGeminiName
|
|
if !userOwnsExactToolSearch {
|
|
forwardMap[ResponsesToolSearchFunctionName] = clientSearchGeminiName
|
|
}
|
|
reverseMap[clientSearchGeminiName] = ResponsesToolIdentity{
|
|
Name: ResponsesToolSearchFunctionName,
|
|
ToolSearch: true,
|
|
}
|
|
}
|
|
var declarations [][]byte
|
|
|
|
for _, desc := range winningList {
|
|
geminiName := desc.Name
|
|
if desc.ClientSearch {
|
|
geminiName = clientSearchGeminiName
|
|
} else if mapped, ok := sanitizedMap[desc.Name]; ok && mapped != "" {
|
|
geminiName = mapped
|
|
} else {
|
|
geminiName = SanitizeFunctionName(desc.Name)
|
|
}
|
|
|
|
if !desc.ClientSearch {
|
|
forwardMap[desc.Name] = geminiName
|
|
}
|
|
forwardMap[geminiName] = geminiName
|
|
|
|
identity := ResponsesToolIdentity{
|
|
Name: desc.LocalName,
|
|
Namespace: desc.Namespace,
|
|
Custom: desc.ToolType == "custom",
|
|
ApplyPatch: applypatch.IsCustomTool(desc.Tool),
|
|
ToolSearch: desc.ClientSearch,
|
|
}
|
|
reverseMap[geminiName] = identity
|
|
if !desc.ClientSearch && desc.Name != geminiName {
|
|
reverseMap[desc.Name] = identity
|
|
}
|
|
if !withDeclarations {
|
|
continue
|
|
}
|
|
|
|
funcDeclDoc := ojson.NewDoc([]byte(`{"name":"","description":"","parametersJsonSchema":{}}`))
|
|
_ = funcDeclDoc.Set("name", geminiName)
|
|
if descStr := responsesToolDescription(desc.Tool); descStr != "" {
|
|
_ = funcDeclDoc.Set("description", descStr)
|
|
}
|
|
|
|
if applypatch.IsCustomTool(desc.Tool) {
|
|
_ = funcDeclDoc.Set("description", applypatch.Description(desc.Tool))
|
|
_ = funcDeclDoc.SetRawBytes("parametersJsonSchema", applypatch.Parameters())
|
|
} else if desc.ToolType == "custom" {
|
|
_ = funcDeclDoc.SetRaw("parametersJsonSchema", `{"type":"object","properties":{"input":{"type":"string"}},"required":["input"]}`)
|
|
} else if desc.ClientSearch {
|
|
_ = funcDeclDoc.SetRawBytes("parametersJsonSchema", buildGeminiToolSearchParametersSchema(desc.Tool))
|
|
} else {
|
|
params := responsesToolParameters(desc.Tool)
|
|
if params.Exists() {
|
|
_ = funcDeclDoc.SetRaw("parametersJsonSchema", CleanJSONSchemaForGeminiJSONSchema(params.Raw))
|
|
}
|
|
}
|
|
declarations = append(declarations, funcDeclDoc.Bytes())
|
|
}
|
|
|
|
// Populate local-name aliases after all direct/qualified names are registered
|
|
// so a namespace child's local name never shadows a direct tool or the search shim.
|
|
for _, desc := range winningList {
|
|
if !desc.ClientSearch && desc.LocalName != "" && desc.LocalName != desc.Name {
|
|
if _, exists := forwardMap[desc.LocalName]; !exists {
|
|
forwardMap[desc.LocalName] = forwardMap[desc.Name]
|
|
}
|
|
}
|
|
}
|
|
|
|
return declarations, forwardMap, reverseMap
|
|
}
|
|
|
|
func buildGeminiToolSearchParametersSchema(tool ojson.Result) []byte {
|
|
if params := responsesToolParameters(tool); params.Exists() && params.IsObject() {
|
|
cleaned := CleanJSONSchemaForGeminiJSONSchema(params.Raw)
|
|
if ojson.Valid(cleaned) && ojson.Parse(cleaned).IsObject() {
|
|
return []byte(cleaned)
|
|
}
|
|
}
|
|
return []byte(responsesToolSearchDefaultParameters)
|
|
}
|
|
|
|
// ResponsesToolReverseIdentityMap builds a Gemini function name -> ResponsesToolIdentity map from a Responses request raw JSON.
|
|
func ResponsesToolReverseIdentityMap(rawJSON []byte) map[string]ResponsesToolIdentity {
|
|
if len(rawJSON) == 0 || !ojson.ValidBytes(rawJSON) {
|
|
return nil
|
|
}
|
|
root := ojson.ParseBytes(rawJSON)
|
|
if req := root.Get("request"); req.Exists() && (req.Get("model").Exists() || req.Get("input").Exists() || req.Get("tools").Exists()) {
|
|
root = req
|
|
}
|
|
_, _, reverseMap := buildGeminiFunctionDeclarations(root, false)
|
|
return reverseMap
|
|
}
|
|
|
|
// MapResponsesToolName returns the mapped Gemini function name if present in forwardMap, else sanitized name.
|
|
func MapResponsesToolName(forwardMap map[string]string, name string) string {
|
|
if mapped, ok := forwardMap[name]; ok && mapped != "" {
|
|
return mapped
|
|
}
|
|
return SanitizeFunctionName(name)
|
|
}
|
|
|
|
// MapResponsesClientToolSearchName returns the mapped Gemini function name for
|
|
// the client-executed tool_search shim.
|
|
func MapResponsesClientToolSearchName(forwardMap map[string]string) string {
|
|
if mapped, ok := forwardMap[ResponsesClientToolSearchKey]; ok && mapped != "" {
|
|
return mapped
|
|
}
|
|
return ResponsesToolSearchFunctionName
|
|
}
|
|
|
|
// ConvertResponsesToolChoiceToGemini translates Responses tool_choice into Gemini functionCallingConfig JSON.
|
|
func ConvertResponsesToolChoiceToGemini(toolChoice ojson.Result, forwardMap map[string]string) ([]byte, bool) {
|
|
if !toolChoice.Exists() {
|
|
return nil, false
|
|
}
|
|
mode := ""
|
|
var allowedNames []string
|
|
if toolChoice.Type == ojson.String {
|
|
switch strings.ToLower(strings.TrimSpace(toolChoice.String())) {
|
|
case "none":
|
|
mode = "NONE"
|
|
case "auto":
|
|
mode = "AUTO"
|
|
case "required", "any":
|
|
mode = "ANY"
|
|
}
|
|
} else if toolChoice.IsObject() {
|
|
toolType := strings.ToLower(strings.TrimSpace(toolChoice.Get("type").String()))
|
|
switch toolType {
|
|
case "none":
|
|
mode = "NONE"
|
|
case "auto":
|
|
mode = "AUTO"
|
|
case "required", "any":
|
|
mode = "ANY"
|
|
case ResponsesToolSearchType:
|
|
mode = "ANY"
|
|
allowedNames = append(allowedNames, MapResponsesClientToolSearchName(forwardMap))
|
|
case "function", "custom", "tool", "":
|
|
mode = "ANY"
|
|
name := strings.TrimSpace(toolChoice.Get("name").String())
|
|
if name == "" {
|
|
name = strings.TrimSpace(toolChoice.Get("function.name").String())
|
|
}
|
|
if name == "" {
|
|
name = strings.TrimSpace(toolChoice.Get("custom.name").String())
|
|
}
|
|
namespace := strings.TrimSpace(toolChoice.Get("namespace").String())
|
|
if namespace == "" {
|
|
namespace = strings.TrimSpace(toolChoice.Get("function.namespace").String())
|
|
}
|
|
if namespace == "" {
|
|
namespace = strings.TrimSpace(toolChoice.Get("custom.namespace").String())
|
|
}
|
|
if namespace != "" {
|
|
name = QualifyResponsesNamespaceToolName(namespace, name)
|
|
}
|
|
if name != "" {
|
|
geminiName := MapResponsesToolName(forwardMap, name)
|
|
allowedNames = append(allowedNames, geminiName)
|
|
}
|
|
}
|
|
}
|
|
if mode == "" {
|
|
return nil, false
|
|
}
|
|
cfgDoc := ojson.NewDoc([]byte(`{"mode":""}`))
|
|
_ = cfgDoc.Set("mode", mode)
|
|
if len(allowedNames) > 0 {
|
|
_ = cfgDoc.Set("allowedFunctionNames", allowedNames)
|
|
}
|
|
return cfgDoc.Bytes(), true
|
|
}
|
|
|
|
// UnwrapResponsesCustomToolInput extracts the raw input string from custom tool arguments JSON or plain string.
|
|
func UnwrapResponsesCustomToolInput(arguments string) string {
|
|
arguments = strings.TrimSpace(arguments)
|
|
if arguments == "" || arguments == "{}" {
|
|
return ""
|
|
}
|
|
if ojson.Valid(arguments) {
|
|
parsed := ojson.Parse(arguments)
|
|
if v := parsed.Get("input"); v.Exists() {
|
|
if v.Type == ojson.String {
|
|
return v.String()
|
|
}
|
|
return v.Raw
|
|
}
|
|
if parsed.Type == ojson.String {
|
|
return parsed.String()
|
|
}
|
|
}
|
|
return arguments
|
|
}
|