1package provider
2
3import (
4 "encoding/json"
5 "testing"
6)
7
8func TestKimiK3DeferredToolsLoadAtToolResult(t *testing.T) {
9 client := NewMoonshot("token", "").(*openaiClient)
10 tools := []Tool{
11 {Name: "search_tools", Schema: json.RawMessage(`{"type":"object"}`)},
12 {Name: "lookup_weather", Schema: json.RawMessage(`{"type":"object"}`), Deferred: true},
13 }
14 wire, err := client.buildRequest(Request{
15 Model: "kimi-k3",
16 Tools: tools,
17 Messages: []Message{
18 {Role: RoleUser, Content: []Content{TextBlock{Text: "weather"}}},
19 {Role: RoleAssistant, Content: []Content{ToolCallBlock{ID: "call-1", Name: "search_tools", Arguments: json.RawMessage(`{}`)}}},
20 {Role: RoleTool, Content: []Content{ToolResultBlock{CallID: "call-1", Content: []Content{TextBlock{Text: "found"}}}}, AddedToolNames: []string{"lookup_weather"}},
21 },
22 })
23 if err != nil {
24 t.Fatal(err)
25 }
26 if len(wire.Tools) != 1 || wire.Tools[0].Function.Name != "search_tools" {
27 t.Fatalf("top-level tools = %+v, want only search_tools", wire.Tools)
28 }
29 var loaded []oaiTool
30 for _, message := range wire.Messages {
31 if message.Role == "system" && len(message.Tools) > 0 {
32 loaded = message.Tools
33 }
34 }
35 if len(loaded) != 1 || loaded[0].Function.Name != "lookup_weather" {
36 t.Fatalf("loaded tools = %+v, want lookup_weather", loaded)
37 }
38}
39
40// The deferred-tools handshake is a Moonshot API extension. Another provider
41// serving the same model id must get the standard wire instead: no tools-bearing
42// system message (it carries no content, which strict schemas reject), and the
43// activated tool in the top-level definitions where every provider reads it.
44func TestKimiK3DeferredToolsSkippedForNonMoonshotProvider(t *testing.T) {
45 client := NewGondola("token", "").(*openaiClient)
46 tools := []Tool{
47 {Name: "search_tools", Schema: json.RawMessage(`{"type":"object"}`)},
48 {Name: "lookup_weather", Schema: json.RawMessage(`{"type":"object"}`), Deferred: true},
49 }
50 wire, err := client.buildRequest(Request{
51 Model: "kimi-k3",
52 Tools: tools,
53 Messages: []Message{
54 {Role: RoleUser, Content: []Content{TextBlock{Text: "weather"}}},
55 {Role: RoleAssistant, Content: []Content{ToolCallBlock{ID: "call-1", Name: "search_tools", Arguments: json.RawMessage(`{}`)}}},
56 {Role: RoleTool, Content: []Content{ToolResultBlock{CallID: "call-1", Content: []Content{TextBlock{Text: "found"}}}}, AddedToolNames: []string{"lookup_weather"}},
57 },
58 })
59 if err != nil {
60 t.Fatal(err)
61 }
62 for _, message := range wire.Messages {
63 if len(message.Tools) > 0 {
64 t.Fatalf("message %q carries tools; deferred injection must not reach a non-Moonshot provider", message.Role)
65 }
66 if message.Content == nil && len(message.ToolCalls) == 0 {
67 t.Fatalf("message %q has neither content nor tool calls", message.Role)
68 }
69 }
70 var names []string
71 for _, tool := range wire.Tools {
72 names = append(names, tool.Function.Name)
73 }
74 if len(names) != 2 || names[0] != "search_tools" || names[1] != "lookup_weather" {
75 t.Fatalf("top-level tools = %v, want [search_tools lookup_weather]", names)
76 }
77}
78
79func TestDeferredToolsFallbackToActiveTopLevelDefinitions(t *testing.T) {
80 tools := []Tool{
81 {Name: "base", Schema: json.RawMessage(`{"type":"object"}`)},
82 {Name: "late", Schema: json.RawMessage(`{"type":"object"}`), Deferred: true},
83 }
84 builders := map[string]func(Request) ([]string, error){
85 "openai": func(req Request) ([]string, error) {
86 wire, err := NewOpenAI("token", "").(*openaiClient).buildRequest(req)
87 if err != nil {
88 return nil, err
89 }
90 names := make([]string, 0, len(wire.Tools))
91 for _, tool := range wire.Tools {
92 names = append(names, tool.Function.Name)
93 }
94 return names, nil
95 },
96 "anthropic": func(req Request) ([]string, error) {
97 req.Model = "claude-sonnet-4-6"
98 wire, err := NewAnthropic("token", "").(*anthropicClient).buildRequest(req)
99 if err != nil {
100 return nil, err
101 }
102 names := make([]string, 0, len(wire.Tools))
103 for _, tool := range wire.Tools {
104 names = append(names, tool.Name)
105 }
106 return names, nil
107 },
108 "bedrock": func(req Request) ([]string, error) {
109 req.Model = "anthropic.claude-sonnet-4-5-20250929-v1:0"
110 wire, err := (&bedrockClient{region: "us-east-1"}).buildRequest(req)
111 if err != nil {
112 return nil, err
113 }
114 if wire.ToolConfig == nil {
115 return nil, nil
116 }
117 names := make([]string, 0, len(wire.ToolConfig.Tools))
118 for _, tool := range wire.ToolConfig.Tools {
119 names = append(names, tool.ToolSpec.Name)
120 }
121 return names, nil
122 },
123 "gemini": func(req Request) ([]string, error) {
124 req.Model = "gemini-2.5-pro"
125 wire, _, err := NewGemini("token", "").(*geminiClient).buildRequest(req)
126 if err != nil {
127 return nil, err
128 }
129 var names []string
130 for _, group := range wire.Tools {
131 for _, tool := range group.FunctionDeclarations {
132 names = append(names, tool.Name)
133 }
134 }
135 return names, nil
136 },
137 "openai-codex": func(req Request) ([]string, error) {
138 req.Model = "gpt-5.5"
139 wire, err := NewOpenAICodex("token", "account", "").(*codexClient).buildRequest(req)
140 if err != nil {
141 return nil, err
142 }
143 names := make([]string, 0, len(wire.Tools))
144 for _, tool := range wire.Tools {
145 names = append(names, tool.Name)
146 }
147 return names, nil
148 },
149 }
150
151 for name, build := range builders {
152 t.Run(name, func(t *testing.T) {
153 initial, err := build(Request{Model: "gpt-5", Tools: tools})
154 if err != nil {
155 t.Fatal(err)
156 }
157 if len(initial) != 1 || initial[0] != "base" {
158 t.Fatalf("initial tools = %v, want [base]", initial)
159 }
160
161 activated, err := build(Request{
162 Model: "gpt-5",
163 Tools: tools,
164 Messages: []Message{{Role: RoleTool, AddedToolNames: []string{"late"}}},
165 })
166 if err != nil {
167 t.Fatal(err)
168 }
169 if len(activated) != 2 || activated[0] != "base" || activated[1] != "late" {
170 t.Fatalf("activated tools = %v, want [base late]", activated)
171 }
172 })
173 }
174}
175
176func TestKimiK3AndGrok45CatalogMetadata(t *testing.T) {
177 for _, tc := range []struct {
178 provider string
179 model string
180 }{
181 {"kimi", "k3"},
182 {"moonshotai", "kimi-k3"},
183 {"moonshotai-cn", "kimi-k3"},
184 {"openrouter", "moonshotai/kimi-k3"},
185 {"vercel-ai-gateway", "moonshotai/kimi-k3"},
186 } {
187 m, err := FindModel(tc.provider, tc.model)
188 if err != nil {
189 t.Fatalf("%s/%s: %v", tc.provider, tc.model, err)
190 }
191 if m.MaxOutput != 131072 || !m.Reasoning {
192 t.Fatalf("%s/%s metadata = %+v", tc.provider, tc.model, m)
193 }
194 }
195 m, err := FindModel("xai", "grok-4.5")
196 if err != nil {
197 t.Fatal(err)
198 }
199 if !m.Reasoning || m.MaxOutput != 30000 || m.API != APIResponses {
200 t.Fatalf("xai/grok-4.5 metadata = %+v", m)
201 }
202}