openAgent

1import { createMistral } from "@ai-sdk/mistral"
2import { expect, test } from "bun:test"
3 
4test("Mistral sends promptCacheKey as prompt_cache_key", async () => {
5  let body: Record<string, unknown> | undefined
6  const mockFetch = Object.assign(
7    async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
8      body = JSON.parse(String(init?.body))
9      return Response.json({
10        id: "response-1",
11        created: 0,
12        model: "mistral-large-latest",
13        object: "chat.completion",
14        choices: [{ index: 0, message: { role: "assistant", content: "Hello" }, finish_reason: "stop" }],
15        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
16      })
17    },
18    { preconnect: fetch.preconnect },
19  )
20  const model = createMistral({ apiKey: "test", fetch: mockFetch })("mistral-large-latest")
21 
22  await model.doGenerate({
23    prompt: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
24    providerOptions: { mistral: { promptCacheKey: "session-123" } },
25  })
26 
27  expect(body?.prompt_cache_key).toBe("session-123")
28})
29 
30test("Mistral passes through unknown reasoning effort", async () => {
31  let body: Record<string, unknown> | undefined
32  const mockFetch = Object.assign(
33    async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
34      body = JSON.parse(String(init?.body))
35      return Response.json({
36        id: "response-1",
37        created: 0,
38        model: "mistral-large-latest",
39        object: "chat.completion",
40        choices: [{ index: 0, message: { role: "assistant", content: "Hello" }, finish_reason: "stop" }],
41        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
42      })
43    },
44    { preconnect: fetch.preconnect },
45  )
46  const model = createMistral({ apiKey: "test", fetch: mockFetch })("mistral-large-latest")
47 
48  await model.doGenerate({
49    prompt: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
50    providerOptions: { mistral: { reasoningEffort: "custom" } },
51  })
52 
53  expect(body?.reasoning_effort).toBe("custom")
54})
55 
56test("Mistral round-trips native reasoning in assistant history", async () => {
57  let body: { messages?: unknown[] } | undefined
58  const mockFetch = Object.assign(
59    async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
60      body = JSON.parse(String(init?.body))
61      return Response.json({
62        id: "response-1",
63        created: 0,
64        model: "mistral-small-latest",
65        object: "chat.completion",
66        choices: [
67          {
68            index: 0,
69            message: {
70              role: "assistant",
71              content: [
72                {
73                  type: "thinking",
74                  thinking: [
75                    { type: "text", text: "The user is greeting me." },
76                    {
77                      type: "tool_reference",
78                      tool: "web_search",
79                      title: "Example result",
80                      url: "https://example.com/tool",
81                      favicon: "https://example.com/favicon.ico",
82                      description: "Example description",
83                    },
84                    { type: "reference", reference_ids: [1, "source-2"] },
85                  ],
86                  closed: true,
87                  signature: "sig-123",
88                },
89                { type: "text", text: "Hi" },
90              ],
91            },
92            finish_reason: "stop",
93          },
94        ],
95        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
96      })
97    },
98    { preconnect: fetch.preconnect },
99  )
100  const model = createMistral({ apiKey: "test", fetch: mockFetch })("mistral-small-latest")
101 
102  const first = await model.doGenerate({
103    prompt: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
104  })
105  const reasoning = first.content.find((part) => part.type === "reasoning")
106  const text = first.content.find((part) => part.type === "text")
107  if (!reasoning || !text) throw new Error("expected reasoning and text")
108 
109  await model.doGenerate({
110    prompt: [
111      { role: "user", content: [{ type: "text", text: "Hello" }] },
112      {
113        role: "assistant",
114        content: [{ ...reasoning, providerOptions: reasoning.providerMetadata }, text],
115      },
116      { role: "user", content: [{ type: "text", text: "Hello again" }] },
117    ],
118  })
119 
120  expect(body?.messages?.[1]).toEqual({
121    role: "assistant",
122    content: [
123      {
124        type: "thinking",
125        thinking: [
126          { type: "text", text: "The user is greeting me." },
127          {
128            type: "tool_reference",
129            tool: "web_search",
130            title: "Example result",
131            url: "https://example.com/tool",
132            favicon: "https://example.com/favicon.ico",
133            description: "Example description",
134          },
135          { type: "reference", reference_ids: [1, "source-2"] },
136        ],
137        closed: true,
138        signature: "sig-123",
139      },
140      { type: "text", text: "Hi" },
141    ],
142  })
143 
144  await model.doGenerate({
145    prompt: [
146      { role: "user", content: [{ type: "text", text: "Hello" }] },
147      {
148        role: "assistant",
149        content: [
150          { type: "reasoning", text: "thinking" },
151          { type: "text", text: "Hi" },
152        ],
153      },
154      { role: "user", content: [{ type: "text", text: "Hello again" }] },
155    ],
156  })
157  expect(body?.messages?.[1]).toEqual({ role: "assistant", content: "thinkingHi" })
158})
159 
160test("Mistral preserves native reasoning metadata while streaming", async () => {
161  const chunks = [
162    {
163      id: "response-1",
164      created: 0,
165      model: "mistral-small-latest",
166      choices: [
167        {
168          index: 0,
169          delta: {
170            role: "assistant",
171            content: [
172              {
173                type: "thinking",
174                thinking: [
175                  { type: "text", text: "thinking" },
176                  {
177                    type: "tool_reference",
178                    tool: "web_search",
179                    title: "Example result",
180                    url: "https://example.com/tool",
181                    favicon: "https://example.com/favicon.ico",
182                    description: "Example description",
183                  },
184                ],
185              },
186            ],
187          },
188        },
189      ],
190    },
191    {
192      id: "response-1",
193      created: 0,
194      model: "mistral-small-latest",
195      choices: [
196        {
197          index: 0,
198          delta: {
199            content: [
200              {
201                type: "thinking",
202                thinking: [{ type: "reference", reference_ids: [1, "source-2"] }],
203                closed: true,
204                signature: "sig-123",
205              },
206            ],
207          },
208        },
209      ],
210    },
211    {
212      id: "response-1",
213      created: 0,
214      model: "mistral-small-latest",
215      choices: [{ index: 0, delta: { content: [{ type: "text", text: "answer" }] } }],
216    },
217    {
218      id: "response-1",
219      created: 0,
220      model: "mistral-small-latest",
221      choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
222      usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
223    },
224  ]
225  const mockFetch = Object.assign(
226    async () =>
227      new Response(chunks.map((chunk) => `data: ${JSON.stringify(chunk)}\n\n`).join(""), {
228        headers: { "Content-Type": "text/event-stream" },
229      }),
230    { preconnect: fetch.preconnect },
231  )
232  const model = createMistral({ apiKey: "test", fetch: mockFetch })("mistral-small-latest")
233  const result = await model.doStream({
234    prompt: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
235  })
236  const events = []
237  for await (const event of result.stream) events.push(event)
238 
239  expect(events.find((event) => event.type === "reasoning-end")?.providerMetadata).toEqual({
240    mistral: {
241      thinking: {
242        type: "thinking",
243        thinking: [
244          { type: "text", text: "thinking" },
245          {
246            type: "tool_reference",
247            tool: "web_search",
248            title: "Example result",
249            url: "https://example.com/tool",
250            favicon: "https://example.com/favicon.ico",
251            description: "Example description",
252          },
253          { type: "reference", reference_ids: [1, "source-2"] },
254        ],
255        closed: true,
256        signature: "sig-123",
257      },
258    },
259  })
260  expect(
261    events
262      .filter((event) => event.type === "reasoning-start" || event.type === "reasoning-delta")
263      .every((event) => event.providerMetadata === undefined),
264  ).toBe(true)
265})
266 
267test("Mistral preserves metadata-only thinking chunks", async () => {
268  const thinking = {
269    type: "thinking" as const,
270    thinking: [
271      {
272        type: "tool_reference",
273        tool: "web_search",
274        title: "Example result",
275        url: "https://example.com/tool",
276        favicon: "https://example.com/favicon.ico",
277        description: "Example description",
278      },
279      { type: "reference", reference_ids: [1, "source-2"] },
280    ],
281    closed: true,
282    signature: "sig-123",
283  }
284  const mockFetch = Object.assign(
285    async () =>
286      Response.json({
287        id: "response-1",
288        created: 0,
289        model: "mistral-small-latest",
290        object: "chat.completion",
291        choices: [{ index: 0, message: { role: "assistant", content: [thinking] }, finish_reason: "stop" }],
292        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
293      }),
294    { preconnect: fetch.preconnect },
295  )
296  const model = createMistral({ apiKey: "test", fetch: mockFetch })("mistral-small-latest")
297  const result = await model.doGenerate({
298    prompt: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
299  })
300 
301  expect(result.content).toEqual([
302    {
303      type: "reasoning",
304      text: "",
305      providerMetadata: { mistral: { thinking } },
306    },
307  ])
308})
309