openAgent

1import { PermissionV1 } from "@opencode-ai/core/v1/permission"
2import { ConfigV1 } from "@opencode-ai/core/v1/config/config"
3import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test"
4import { SessionV1 } from "@opencode-ai/core/v1/session"
5import path from "path"
6import { tool, type ModelMessage } from "ai"
7import { Cause, Effect, Exit, Fiber, Layer, Stream } from "effect"
8import { InstanceRef } from "../../src/effect/instance-ref"
9import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
10import z from "zod"
11import { LLM } from "../../src/session/llm"
12import { LLMClient, RequestExecutor } from "@opencode-ai/llm/route"
13import { Provider } from "@/provider/provider"
14import { ProviderTransform } from "@/provider/transform"
15import { ModelsDev } from "@opencode-ai/core/models-dev"
16 
17import { testEffect } from "../lib/effect"
18import type { Agent } from "../../src/agent/agent"
19import { MessageV2 } from "../../src/session/message-v2"
20import { SessionID, MessageID } from "../../src/session/schema"
21import { RuntimeFlags } from "@/effect/runtime-flags"
22import { Permission } from "@/permission"
23import { LLMAISDK } from "@/session/llm/ai-sdk"
24import { Session as SessionNs } from "@/session/session"
25import { ProviderV2 } from "@opencode-ai/core/provider"
26import { ModelV2 } from "@opencode-ai/core/model"
27import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
28import { LayerNode } from "@opencode-ai/core/effect/layer-node"
29import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
30 
31type ConfigModel = NonNullable<NonNullable<ConfigV1.Info["provider"]>[string]["models"]>[string]
32 
33const openAIConfig = (model: ModelsDev.Provider["models"][string], baseURL: string): Partial<ConfigV1.Info> => {
34  const { experimental: _experimental, ...configModel } = model
35  return {
36    enabled_providers: ["openai"],
37    provider: {
38      openai: {
39        name: "OpenAI",
40        env: ["OPENAI_API_KEY"],
41        npm: "@ai-sdk/openai",
42        api: "https://api.openai.com/v1",
43        models: {
44          [model.id]: JSON.parse(JSON.stringify(configModel)) as ConfigModel,
45        },
46        options: {
47          apiKey: "test-openai-key",
48          baseURL,
49        },
50      },
51    },
52  }
53}
54 
55const it = testEffect(AppNodeBuilder.build(LayerNode.group([LLM.node, Provider.node])))
56 
57// LLM.stream returns a Stream, not an Effect, so we can't use the serviceUse proxy.
58const drain = (input: LLM.StreamInput) => LLM.Service.use((svc) => svc.stream(input).pipe(Stream.runDrain))
59 
60// drainWith builds an isolated runtime so custom replacements fully own LLM and
61// its transitive deps.
62const drainWith = (layer: Layer.Layer<LLM.Service>, input: LLM.StreamInput) =>
63  Effect.gen(function* () {
64    const ctx = yield* InstanceRef
65    if (!ctx) return yield* Effect.die("InstanceRef not provided")
66    return yield* Effect.promise(() =>
67      Effect.runPromise(
68        LLM.Service.use((svc) => svc.stream(input).pipe(Stream.runDrain)).pipe(
69          Effect.provide(layer),
70          Effect.provideService(InstanceRef, ctx),
71        ),
72      ),
73    )
74  })
75 
76function llmLayerWithExecutor(
77  options: {
78    executor?: Layer.Layer<RequestExecutor.Service>
79    flags?: Partial<RuntimeFlags.Info>
80  } = {},
81) {
82  return AppNodeBuilder.build(LLM.node, [
83    [RuntimeFlags.node, RuntimeFlags.layer(options.flags)],
84    ...(options.executor ? ([[LayerNodePlatform.requestExecutor, options.executor]] as const) : []),
85  ])
86}
87 
88describe("session.llm.hasToolCalls", () => {
89  test("returns false for empty messages array", () => {
90    expect(LLM.hasToolCalls([])).toBe(false)
91  })
92 
93  test("returns false for messages with only text content", () => {
94    const messages: ModelMessage[] = [
95      {
96        role: "user",
97        content: [{ type: "text", text: "Hello" }],
98      },
99      {
100        role: "assistant",
101        content: [{ type: "text", text: "Hi there" }],
102      },
103    ]
104    expect(LLM.hasToolCalls(messages)).toBe(false)
105  })
106 
107  test("returns true when messages contain tool-call", () => {
108    const messages = [
109      {
110        role: "user",
111        content: [{ type: "text", text: "Run a command" }],
112      },
113      {
114        role: "assistant",
115        content: [
116          {
117            type: "tool-call",
118            toolCallId: "call-123",
119            toolName: "bash",
120          },
121        ],
122      },
123    ] as ModelMessage[]
124    expect(LLM.hasToolCalls(messages)).toBe(true)
125  })
126 
127  test("returns true when messages contain tool-result", () => {
128    const messages = [
129      {
130        role: "tool",
131        content: [
132          {
133            type: "tool-result",
134            toolCallId: "call-123",
135            toolName: "bash",
136          },
137        ],
138      },
139    ] as ModelMessage[]
140    expect(LLM.hasToolCalls(messages)).toBe(true)
141  })
142 
143  test("returns false for messages with string content", () => {
144    const messages: ModelMessage[] = [
145      {
146        role: "user",
147        content: "Hello world",
148      },
149      {
150        role: "assistant",
151        content: "Hi there",
152      },
153    ]
154    expect(LLM.hasToolCalls(messages)).toBe(false)
155  })
156 
157  test("returns true when tool-call is mixed with text content", () => {
158    const messages = [
159      {
160        role: "assistant",
161        content: [
162          { type: "text", text: "Let me run that command" },
163          {
164            type: "tool-call",
165            toolCallId: "call-456",
166            toolName: "read",
167          },
168        ],
169      },
170    ] as ModelMessage[]
171    expect(LLM.hasToolCalls(messages)).toBe(true)
172  })
173})
174 
175describe("session.llm.ai-sdk adapter", () => {
176  type AISDKAdapterEvent = Parameters<typeof LLMAISDK.toLLMEvents>[1]
177 
178  const adapt = (events: ReadonlyArray<AISDKAdapterEvent>) => {
179    const state = LLMAISDK.adapterState()
180    return Effect.runPromise(
181      Effect.forEach(events, (event) => LLMAISDK.toLLMEvents(state, event)).pipe(Effect.map((items) => items.flat())),
182    )
183  }
184  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- tests defensive adapter branches outside AI SDK's current typed surface
185  const uncheckedAdapterEvent = (input: unknown) => input as AISDKAdapterEvent
186 
187  test("maps AI SDK stream chunks without losing session-visible fields", async () => {
188    const metadata = { openai: { itemID: "item-1" } }
189    const events = await adapt([
190      { type: "start" },
191      { type: "start-step", request: {}, warnings: [] },
192      { type: "text-start", id: "text-1", providerMetadata: metadata },
193      { type: "text-delta", id: "text-1", text: "Hel", providerMetadata: { openai: { delta: 1 } } },
194      { type: "text-delta", id: "text-1", text: "lo", providerMetadata: { openai: { delta: 2 } } },
195      { type: "text-end", id: "text-1", providerMetadata: { openai: { done: true } } },
196      { type: "reasoning-start", id: "reasoning-1", providerMetadata: metadata },
197      { type: "reasoning-delta", id: "reasoning-1", text: "Think", providerMetadata: { openai: { delta: 3 } } },
198      { type: "reasoning-end", id: "reasoning-1", providerMetadata: { openai: { done: true } } },
199      { type: "tool-input-start", id: "call-1", toolName: "lookup", providerMetadata: metadata },
200      { type: "tool-input-delta", id: "call-1", delta: '{"query":' },
201      { type: "tool-input-delta", id: "call-1", delta: '"weather"}' },
202      { type: "tool-input-end", id: "call-1", providerMetadata: { openai: { inputDone: true } } },
203      {
204        type: "tool-call",
205        toolCallId: "call-1",
206        toolName: "lookup",
207        input: { query: "weather" },
208        providerExecuted: true,
209        providerMetadata: { openai: { called: true } },
210      },
211      {
212        type: "tool-result",
213        toolCallId: "call-1",
214        toolName: "lookup",
215        input: { query: "weather" },
216        output: { title: "Lookup", output: "sunny", metadata: { ok: true } },
217        providerExecuted: true,
218        providerMetadata: { openai: { result: true } },
219      },
220      {
221        type: "finish-step",
222        response: { id: "response-1", timestamp: new Date(0), modelId: "gpt-test" },
223        finishReason: "other",
224        rawFinishReason: "other",
225        usage: {
226          inputTokens: 10,
227          outputTokens: 5,
228          totalTokens: 15,
229          inputTokenDetails: { noCacheTokens: 5, cacheReadTokens: 3, cacheWriteTokens: 2 },
230          outputTokenDetails: { textTokens: 4, reasoningTokens: 1 },
231        },
232        providerMetadata: { openai: { step: true } },
233      },
234      {
235        type: "finish",
236        finishReason: "other",
237        rawFinishReason: "other",
238        totalUsage: {
239          inputTokens: 11,
240          outputTokens: 6,
241          totalTokens: 17,
242          cachedInputTokens: 4,
243          reasoningTokens: 2,
244          inputTokenDetails: { noCacheTokens: 7, cacheReadTokens: 4, cacheWriteTokens: undefined },
245          outputTokenDetails: { textTokens: 4, reasoningTokens: 2 },
246        },
247      },
248    ])
249 
250    expect(events).toMatchObject([
251      { type: "step-start", index: 0 },
252      { type: "text-start", id: "text-1", providerMetadata: metadata },
253      { type: "text-delta", id: "text-1", text: "Hel", providerMetadata: { openai: { delta: 1 } } },
254      { type: "text-delta", id: "text-1", text: "lo", providerMetadata: { openai: { delta: 2 } } },
255      { type: "text-end", id: "text-1", providerMetadata: { openai: { done: true } } },
256      { type: "reasoning-start", id: "reasoning-1", providerMetadata: metadata },
257      { type: "reasoning-delta", id: "reasoning-1", text: "Think", providerMetadata: { openai: { delta: 3 } } },
258      { type: "reasoning-end", id: "reasoning-1", providerMetadata: { openai: { done: true } } },
259      { type: "tool-input-start", id: "call-1", name: "lookup", providerMetadata: metadata },
260      { type: "tool-input-delta", id: "call-1", name: "lookup", text: '{"query":' },
261      { type: "tool-input-delta", id: "call-1", name: "lookup", text: '"weather"}' },
262      { type: "tool-input-end", id: "call-1", name: "lookup", providerMetadata: { openai: { inputDone: true } } },
263      {
264        type: "tool-call",
265        id: "call-1",
266        name: "lookup",
267        input: { query: "weather" },
268        providerExecuted: true,
269        providerMetadata: { openai: { called: true } },
270      },
271      {
272        type: "tool-result",
273        id: "call-1",
274        name: "lookup",
275        result: { type: "json", value: { title: "Lookup", output: "sunny", metadata: { ok: true } } },
276        providerExecuted: true,
277        providerMetadata: { openai: { result: true } },
278      },
279      {
280        type: "step-finish",
281        index: 0,
282        reason: "unknown",
283        usage: {
284          inputTokens: 10,
285          outputTokens: 5,
286          totalTokens: 15,
287          reasoningTokens: 1,
288          cacheReadInputTokens: 3,
289          cacheWriteInputTokens: 2,
290        },
291        providerMetadata: { openai: { step: true } },
292      },
293      {
294        type: "finish",
295        reason: "unknown",
296        usage: {
297          inputTokens: 11,
298          outputTokens: 6,
299          totalTokens: 17,
300          reasoningTokens: 2,
301          cacheReadInputTokens: 4,
302        },
303      },
304    ])
305  })
306 
307  test("creates stable block ids when AI SDK omits them", async () => {
308    const events = await adapt([
309      uncheckedAdapterEvent({ type: "text-delta", text: "implicit text" }),
310      uncheckedAdapterEvent({ type: "text-end" }),
311      uncheckedAdapterEvent({ type: "reasoning-delta", text: "implicit reasoning" }),
312      uncheckedAdapterEvent({ type: "reasoning-end" }),
313    ])
314 
315    expect(events).toMatchObject([
316      { type: "text-delta", id: "text-0", text: "implicit text" },
317      { type: "text-end", id: "text-0" },
318      { type: "reasoning-delta", id: "reasoning-0", text: "implicit reasoning" },
319      { type: "reasoning-end", id: "reasoning-0" },
320    ])
321  })
322 
323  test("explicitly ignores non-session-visible AI SDK chunks", async () => {
324    expect(
325      await adapt([
326        uncheckedAdapterEvent({ type: "abort" }),
327        uncheckedAdapterEvent({ type: "source" }),
328        uncheckedAdapterEvent({ type: "file" }),
329        uncheckedAdapterEvent({ type: "raw" }),
330        uncheckedAdapterEvent({ type: "tool-output-denied" }),
331        uncheckedAdapterEvent({ type: "tool-approval-request" }),
332      ]),
333    ).toEqual([])
334  })
335 
336  test("preserves tool-error cause", async () => {
337    const error = new PermissionV1.RejectedError()
338    const events = await Effect.runPromise(
339      LLMAISDK.toLLMEvents(LLMAISDK.adapterState(), {
340        type: "tool-error",
341        toolCallId: "call_123",
342        toolName: "bash",
343        input: {},
344        error,
345      }),
346    )
347 
348    expect(events).toHaveLength(1)
349    expect(events[0]).toMatchObject({
350      type: "tool-error",
351      id: "call_123",
352      name: "bash",
353      message: error.message,
354      error,
355    })
356  })
357 
358  test("emits undefined usage when every AI SDK usage field is missing", async () => {
359    // If every numeric field is undefined the translator should signal "no usage info"
360    // by emitting undefined, not by polluting the event with usage: {}. Downstream cost
361    // telemetry distinguishes "missing" from "zero," so emitting an empty object causes
362    // false positives ("usage was tracked, just empty") instead of correct nulls.
363    const events = await adapt([
364      {
365        type: "finish-step",
366        response: { id: "response-1", timestamp: new Date(0), modelId: "gpt-test" },
367        finishReason: "stop",
368        rawFinishReason: "stop",
369        providerMetadata: undefined,
370        usage: {
371          inputTokens: undefined,
372          outputTokens: undefined,
373          totalTokens: undefined,
374          reasoningTokens: undefined,
375          cachedInputTokens: undefined,
376          inputTokenDetails: { noCacheTokens: undefined, cacheReadTokens: undefined, cacheWriteTokens: undefined },
377          outputTokenDetails: { textTokens: undefined, reasoningTokens: undefined },
378        },
379      },
380    ])
381 
382    expect(events).toHaveLength(1)
383    const stepFinish = events[0]
384    if (stepFinish.type !== "step-finish") throw new Error("expected step-finish")
385    expect(stepFinish.usage).toBeUndefined()
386  })
387 
388  test("reuses adapter state cleanly across streams once finish has fired", async () => {
389    // adapterState() is meant to be per-stream, but the only thing finish currently clears
390    // is toolNames — step, text counters, and the current text/reasoning IDs all leak
391    // forward. A caller that reuses a state across two streams sees text-1/reasoning-1/
392    // step index 1 on the second stream's first events. The test pins the intended
393    // contract: after finish, the same state can be reused and starts fresh.
394    const state = LLMAISDK.adapterState()
395    const run = (events: ReadonlyArray<AISDKAdapterEvent>) =>
396      Effect.runPromise(
397        Effect.forEach(events, (event) => LLMAISDK.toLLMEvents(state, event)).pipe(Effect.map((items) => items.flat())),
398      )
399 
400    await run([
401      { type: "start-step", request: {}, warnings: [] },
402      uncheckedAdapterEvent({ type: "text-delta", text: "first" }),
403      uncheckedAdapterEvent({ type: "text-end" }),
404      uncheckedAdapterEvent({ type: "reasoning-delta", text: "first reasoning" }),
405      uncheckedAdapterEvent({ type: "reasoning-end" }),
406      {
407        type: "finish-step",
408        response: { id: "r1", timestamp: new Date(0), modelId: "gpt-test" },
409        finishReason: "stop",
410        rawFinishReason: "stop",
411        providerMetadata: undefined,
412        usage: {
413          inputTokens: 1,
414          outputTokens: 1,
415          totalTokens: 2,
416          inputTokenDetails: { noCacheTokens: undefined, cacheReadTokens: undefined, cacheWriteTokens: undefined },
417          outputTokenDetails: { textTokens: undefined, reasoningTokens: undefined },
418        },
419      },
420      {
421        type: "finish",
422        finishReason: "stop",
423        rawFinishReason: "stop",
424        totalUsage: {
425          inputTokens: 1,
426          outputTokens: 1,
427          totalTokens: 2,
428          inputTokenDetails: { noCacheTokens: undefined, cacheReadTokens: undefined, cacheWriteTokens: undefined },
429          outputTokenDetails: { textTokens: undefined, reasoningTokens: undefined },
430        },
431      },
432    ])
433 
434    const secondStream = await run([
435      { type: "start-step", request: {}, warnings: [] },
436      uncheckedAdapterEvent({ type: "text-delta", text: "second" }),
437      uncheckedAdapterEvent({ type: "text-end" }),
438      uncheckedAdapterEvent({ type: "reasoning-delta", text: "second reasoning" }),
439      uncheckedAdapterEvent({ type: "reasoning-end" }),
440    ])
441 
442    expect(secondStream).toMatchObject([
443      { type: "step-start", index: 0 },
444      { type: "text-delta", id: "text-0", text: "second" },
445      { type: "text-end", id: "text-0" },
446      { type: "reasoning-delta", id: "reasoning-0", text: "second reasoning" },
447      { type: "reasoning-end", id: "reasoning-0" },
448    ])
449  })
450 
451  // Anthropic emits cache write counts in providerMetadata.anthropic.cacheCreationInputTokens
452  // rather than usage.inputTokenDetails.cacheWriteTokens. Session.getUsage falls back to the
453  // metadata path — but only if the adapter preserves providerMetadata on step-finish.
454  test("preserves providerMetadata on step-finish so Anthropic cache writes survive getUsage", async () => {
455    const events = await adapt([
456      {
457        type: "finish-step",
458        response: { id: "msg_test", timestamp: new Date(0), modelId: "claude-3-5-sonnet" },
459        finishReason: "stop",
460        rawFinishReason: "stop",
461        // Anthropic's AI SDK shape: cacheWriteTokens is NOT in usage, it arrives via providerMetadata.
462        usage: {
463          inputTokens: 1000,
464          outputTokens: 500,
465          totalTokens: 1500,
466          inputTokenDetails: { noCacheTokens: 800, cacheReadTokens: 200, cacheWriteTokens: undefined },
467          outputTokenDetails: { textTokens: 500, reasoningTokens: undefined },
468        },
469        providerMetadata: { anthropic: { cacheCreationInputTokens: 300 } },
470      },
471    ])
472 
473    expect(events).toHaveLength(1)
474    const stepFinish = events[0]
475    if (stepFinish.type !== "step-finish") throw new Error("expected step-finish")
476    expect(stepFinish.providerMetadata).toEqual({ anthropic: { cacheCreationInputTokens: 300 } })
477    expect(stepFinish.usage?.cacheWriteInputTokens).toBeUndefined()
478    expect(stepFinish.usage?.cacheReadInputTokens).toBe(200)
479 
480    // End-to-end: with the metadata preserved, getUsage extracts cache.write from the fallback path.
481    const result = SessionNs.getUsage({
482      model: {
483        id: "claude-3-5-sonnet",
484        providerID: "anthropic",
485        name: "Claude",
486        limit: { context: 200_000, output: 8_000 },
487        cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
488        capabilities: {
489          toolcall: true,
490          attachment: false,
491          reasoning: false,
492          temperature: true,
493          input: { text: true, image: false, audio: false, video: false },
494          output: { text: true, image: false, audio: false, video: false },
495        },
496        api: { npm: "@ai-sdk/anthropic" },
497        options: {},
498      } as never,
499      usage: stepFinish.usage!,
500      metadata: stepFinish.providerMetadata,
501    })
502    expect(result.tokens.cache.write).toBe(300)
503    expect(result.tokens.cache.read).toBe(200)
504  })
505 
506  test("captures Copilot billed usage from raw Anthropic message deltas per step", async () => {
507    const events = await adapt([
508      uncheckedAdapterEvent({
509        type: "raw",
510        rawValue: {
511          type: "message_delta",
512          copilot_usage: { total_nano_aiu: 4_473_525_000 },
513        },
514      }),
515      {
516        type: "finish-step",
517        response: { id: "msg_test", timestamp: new Date(0), modelId: "claude-sonnet-4.6" },
518        finishReason: "stop",
519        rawFinishReason: "end_turn",
520        usage: {
521          inputTokens: 11_774,
522          outputTokens: 39,
523          totalTokens: 11_813,
524          inputTokenDetails: { noCacheTokens: 3, cacheReadTokens: 0, cacheWriteTokens: 11_771 },
525          outputTokenDetails: { textTokens: 39, reasoningTokens: undefined },
526        },
527        providerMetadata: { anthropic: { cacheCreationInputTokens: 11_771 } },
528      },
529      {
530        type: "finish-step",
531        response: { id: "msg_follow_up", timestamp: new Date(0), modelId: "claude-sonnet-4.6" },
532        finishReason: "stop",
533        rawFinishReason: "end_turn",
534        usage: {
535          inputTokens: 1,
536          outputTokens: 1,
537          totalTokens: 2,
538          inputTokenDetails: { noCacheTokens: 1, cacheReadTokens: 0, cacheWriteTokens: 0 },
539          outputTokenDetails: { textTokens: 1, reasoningTokens: undefined },
540        },
541        providerMetadata: { anthropic: {} },
542      },
543    ])
544 
545    expect(events[0]).toMatchObject({
546      type: "step-finish",
547      providerMetadata: {
548        anthropic: { cacheCreationInputTokens: 11_771 },
549        copilot: { totalNanoAiu: 4_473_525_000 },
550      },
551    })
552    expect(events[1]).toMatchObject({ type: "step-finish", providerMetadata: { anthropic: {} } })
553    if (events[1].type !== "step-finish") throw new Error("expected step-finish")
554    expect(events[1].providerMetadata?.copilot).toBeUndefined()
555  })
556})
557 
558type Capture = {
559  url: URL
560  headers: Headers
561  body: Record<string, unknown>
562}
563 
564const state = {
565  server: null as ReturnType<typeof Bun.serve> | null,
566  queue: [] as Array<{
567    path: string
568    response: Response | ((req: Request, capture: Capture) => Response)
569    resolve: (value: Capture) => void
570  }>,
571}
572 
573function deferred<T>() {
574  const result = {} as { promise: Promise<T>; resolve: (value: T) => void }
575  result.promise = new Promise((resolve) => {
576    result.resolve = resolve
577  })
578  return result
579}
580 
581function waitRequest(pathname: string, response: Response) {
582  const pending = deferred<Capture>()
583  state.queue.push({ path: pathname, response, resolve: pending.resolve })
584  return pending.promise
585}
586 
587function timeout(ms: number) {
588  return new Promise<never>((_, reject) => {
589    setTimeout(() => reject(new Error(`timed out after ${ms}ms`)), ms)
590  })
591}
592 
593function waitStreamingRequest(pathname: string) {
594  const request = deferred<Capture>()
595  const requestAborted = deferred<void>()
596  const responseCanceled = deferred<void>()
597  const encoder = new TextEncoder()
598 
599  state.queue.push({
600    path: pathname,
601    resolve: request.resolve,
602    response(req: Request) {
603      req.signal.addEventListener("abort", () => requestAborted.resolve(), { once: true })
604 
605      return new Response(
606        new ReadableStream<Uint8Array>({
607          start(controller) {
608            controller.enqueue(
609              encoder.encode(
610                [
611                  `data: ${JSON.stringify({
612                    id: "chatcmpl-abort",
613                    object: "chat.completion.chunk",
614                    choices: [{ delta: { role: "assistant" } }],
615                  })}`,
616                ].join("\n\n") + "\n\n",
617              ),
618            )
619          },
620          cancel() {
621            responseCanceled.resolve()
622          },
623        }),
624        {
625          status: 200,
626          headers: { "Content-Type": "text/event-stream" },
627        },
628      )
629    },
630  })
631 
632  return {
633    request: request.promise,
634    requestAborted: requestAborted.promise,
635    responseCanceled: responseCanceled.promise,
636  }
637}
638 
639beforeAll(() => {
640  state.server = Bun.serve({
641    port: 0,
642    async fetch(req) {
643      const next = state.queue.shift()
644      if (!next) {
645        return new Response("unexpected request", { status: 500 })
646      }
647 
648      const url = new URL(req.url)
649      const body = (await req.json()) as Record<string, unknown>
650      next.resolve({ url, headers: req.headers, body })
651 
652      if (!url.pathname.endsWith(next.path)) {
653        return new Response("not found", { status: 404 })
654      }
655 
656      return typeof next.response === "function"
657        ? next.response(req, { url, headers: req.headers, body })
658        : next.response
659    },
660  })
661})
662 
663beforeEach(() => {
664  state.queue.length = 0
665})
666 
667afterAll(() => {
668  void state.server?.stop()
669})
670 
671function createChatStream(text: string) {
672  const payload =
673    [
674      `data: ${JSON.stringify({
675        id: "chatcmpl-1",
676        object: "chat.completion.chunk",
677        choices: [{ delta: { role: "assistant" } }],
678      })}`,
679      `data: ${JSON.stringify({
680        id: "chatcmpl-1",
681        object: "chat.completion.chunk",
682        choices: [{ delta: { content: text } }],
683      })}`,
684      `data: ${JSON.stringify({
685        id: "chatcmpl-1",
686        object: "chat.completion.chunk",
687        choices: [{ delta: {}, finish_reason: "stop" }],
688      })}`,
689      "data: [DONE]",
690    ].join("\n\n") + "\n\n"
691 
692  const encoder = new TextEncoder()
693  return new ReadableStream<Uint8Array>({
694    start(controller) {
695      controller.enqueue(encoder.encode(payload))
696      controller.close()
697    },
698  })
699}
700 
701const MODELS_FIXTURE = JSON.parse(
702  await Bun.file(path.join(import.meta.dir, "../tool/fixtures/models-api.json")).text(),
703) as Record<string, ModelsDev.Provider>
704 
705function loadFixture(providerID: string, modelID: string) {
706  const provider = MODELS_FIXTURE[providerID]
707  if (!provider) throw new Error(`Missing provider in fixture: ${providerID}`)
708  const model = provider.models[modelID]
709  if (!model) throw new Error(`Missing model in fixture: ${modelID}`)
710  return { provider, model }
711}
712 
713function configModel(model: ModelsDev.Model) {
714  return {
715    id: model.id,
716    name: model.name,
717    family: model.family,
718    release_date: model.release_date,
719    attachment: model.attachment,
720    reasoning: model.reasoning,
721    temperature: model.temperature,
722    tool_call: model.tool_call,
723    interleaved: model.interleaved,
724    cost: model.cost ? { ...model.cost, tiers: undefined } : undefined,
725    limit: model.limit,
726    modalities: model.modalities,
727    status: model.status,
728    provider: model.provider,
729  }
730}
731 
732function createEventStream(chunks: unknown[], includeDone = false) {
733  const lines = chunks.map((chunk) => `data: ${typeof chunk === "string" ? chunk : JSON.stringify(chunk)}`)
734  if (includeDone) {
735    lines.push("data: [DONE]")
736  }
737  const payload = lines.join("\n\n") + "\n\n"
738  const encoder = new TextEncoder()
739  return new ReadableStream<Uint8Array>({
740    start(controller) {
741      controller.enqueue(encoder.encode(payload))
742      controller.close()
743    },
744  })
745}
746 
747function createEventResponse(chunks: unknown[], includeDone = false) {
748  return new Response(createEventStream(chunks, includeDone), {
749    status: 200,
750    headers: { "Content-Type": "text/event-stream" },
751  })
752}
753 
754describe("session.llm.stream", () => {
755  const vivgridFixture = { providerID: "vivgrid", modelID: "gemini-3.1-pro-preview" }
756  it.instance(
757    "sends temperature, tokens, and reasoning options for openai-compatible models",
758    () =>
759      Effect.gen(function* () {
760        const fixture = loadFixture(vivgridFixture.providerID, vivgridFixture.modelID)
761        const request = waitRequest(
762          "/chat/completions",
763          new Response(createChatStream("Hello"), {
764            status: 200,
765            headers: { "Content-Type": "text/event-stream" },
766          }),
767        )
768 
769        const resolved = yield* Provider.use.getModel(
770          ProviderV2.ID.make(vivgridFixture.providerID),
771          ModelV2.ID.make(fixture.model.id),
772        )
773        const sessionID = SessionID.make("session-test-1")
774        const agent = {
775          name: "test",
776          mode: "primary",
777          options: {},
778          permission: [{ permission: "*", pattern: "*", action: "allow" }],
779          temperature: 0.4,
780          topP: 0.8,
781        } satisfies Agent.Info
782 
783        const user = {
784          id: MessageID.make("msg_user-1"),
785          sessionID,
786          role: "user",
787          time: { created: Date.now() },
788          agent: agent.name,
789          model: { providerID: ProviderV2.ID.make(vivgridFixture.providerID), modelID: resolved.id, variant: "high" },
790        } satisfies SessionV1.User
791 
792        yield* drain({
793          user,
794          sessionID,
795          model: resolved,
796          agent,
797          system: ["You are a helpful assistant."],
798          messages: [{ role: "user", content: "Hello" }],
799          tools: {},
800        })
801 
802        const capture = yield* Effect.promise(() => request)
803        const body = capture.body
804        const headers = capture.headers
805        const url = capture.url
806 
807        expect(url.pathname.startsWith("/v1/")).toBe(true)
808        expect(url.pathname.endsWith("/chat/completions")).toBe(true)
809        expect(headers.get("Authorization")).toBe("Bearer test-key")
810 
811        expect(body.model).toBe(resolved.api.id)
812        expect(body.temperature).toBe(0.4)
813        expect(body.top_p).toBe(0.8)
814        expect(body.stream).toBe(true)
815 
816        const maxTokens = (body.max_tokens as number | undefined) ?? (body.max_output_tokens as number | undefined)
817        const expectedMaxTokens = ProviderTransform.maxOutputTokens(resolved)
818        expect(maxTokens).toBe(expectedMaxTokens)
819 
820        const reasoning = (body.reasoningEffort as string | undefined) ?? (body.reasoning_effort as string | undefined)
821        expect(reasoning).toBe("high")
822      }),
823    {
824      config: () => ({
825        enabled_providers: [vivgridFixture.providerID],
826        provider: {
827          [vivgridFixture.providerID]: {
828            options: { apiKey: "test-key", baseURL: `${state.server!.url.origin}/v1` },
829          },
830        },
831      }),
832    },
833  )
834 
835  const cerebrasFixture = { providerID: "cerebras", modelID: "gpt-oss-120b" }
836  it.instance(
837    "replays Cerebras assistant reasoning using the provider-supported field",
838    () =>
839      Effect.gen(function* () {
840        const fixture = loadFixture(cerebrasFixture.providerID, cerebrasFixture.modelID)
841        const request = waitRequest(
842          "/chat/completions",
843          new Response(createChatStream("Hello"), {
844            status: 200,
845            headers: { "Content-Type": "text/event-stream" },
846          }),
847        )
848 
849        const resolved = yield* Provider.use.getModel(
850          ProviderV2.ID.make(cerebrasFixture.providerID),
851          ModelV2.ID.make(fixture.model.id),
852        )
853        const sessionID = SessionID.make("session-test-cerebras-reasoning")
854        const agent = {
855          name: "test",
856          mode: "primary",
857          options: {},
858          permission: [{ permission: "*", pattern: "*", action: "allow" }],
859        } satisfies Agent.Info
860 
861        const user = {
862          id: MessageID.make("msg_user-cerebras-reasoning"),
863          sessionID,
864          role: "user",
865          time: { created: Date.now() },
866          agent: agent.name,
867          model: { providerID: ProviderV2.ID.make(cerebrasFixture.providerID), modelID: resolved.id },
868        } satisfies SessionV1.User
869 
870        yield* drain({
871          user,
872          sessionID,
873          model: resolved,
874          agent,
875          system: ["You are a helpful assistant."],
876          messages: [
877            { role: "user", content: "Hello" },
878            {
879              role: "assistant",
880              content: [
881                { type: "reasoning", text: "thinking" },
882                { type: "text", text: "Previous answer" },
883              ],
884            },
885            { role: "user", content: "Continue" },
886          ] satisfies ModelMessage[],
887          tools: {},
888        })
889 
890        const capture = yield* Effect.promise(() => request)
891        const messages = capture.body.messages as Array<Record<string, unknown>>
892        const assistant = messages.find((msg) => msg.role === "assistant")
893 
894        expect(assistant?.reasoning).toBe("thinking")
895        expect(assistant && "reasoning_content" in assistant).toBe(false)
896      }),
897    {
898      config: () => ({
899        enabled_providers: [cerebrasFixture.providerID],
900        provider: {
901          [cerebrasFixture.providerID]: {
902            options: { apiKey: "test-key", baseURL: `${state.server!.url.origin}/v1` },
903          },
904        },
905      }),
906    },
907  )
908 
909  const mistralFixture = { providerID: "mistral", modelID: "mistral-small-latest" }
910  it.instance(
911    "replays native Mistral reasoning from chat history",
912    () =>
913      Effect.gen(function* () {
914        const fixture = loadFixture(mistralFixture.providerID, mistralFixture.modelID)
915        const request = waitRequest(
916          "/chat/completions",
917          createEventResponse(
918            [
919              {
920                id: "chatcmpl-mistral",
921                object: "chat.completion.chunk",
922                created: 0,
923                model: fixture.model.id,
924                choices: [{ index: 0, delta: { role: "assistant", content: "Hello" } }],
925              },
926              {
927                id: "chatcmpl-mistral",
928                object: "chat.completion.chunk",
929                created: 0,
930                model: fixture.model.id,
931                choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
932              },
933            ],
934            true,
935          ),
936        )
937 
938        const resolved = yield* Provider.use.getModel(
939          ProviderV2.ID.make(mistralFixture.providerID),
940          ModelV2.ID.make(fixture.model.id),
941        )
942        const sessionID = SessionID.make("session-test-mistral-reasoning")
943        const agent = {
944          name: "test",
945          mode: "primary",
946          options: {},
947          permission: [{ permission: "*", pattern: "*", action: "allow" }],
948        } satisfies Agent.Info
949 
950        const user = {
951          id: MessageID.make("msg_user-mistral-reasoning"),
952          sessionID,
953          role: "user",
954          time: { created: Date.now() },
955          agent: agent.name,
956          model: { providerID: ProviderV2.ID.make(mistralFixture.providerID), modelID: resolved.id },
957        } satisfies SessionV1.User
958 
959        const thinking = {
960          type: "thinking",
961          thinking: [
962            { type: "text", text: "thinking" },
963            {
964              type: "tool_reference",
965              tool: "web_search",
966              title: "Example result",
967              url: "https://example.com/tool",
968              favicon: "https://example.com/favicon.ico",
969              description: "Example description",
970            },
971            { type: "reference", reference_ids: [1, "source-2"] },
972          ],
973          closed: true,
974          signature: "sig-123",
975        }
976 
977        yield* drain({
978          user,
979          sessionID,
980          model: resolved,
981          agent,
982          system: ["You are a helpful assistant."],
983          messages: [
984            { role: "user", content: "Hello" },
985            {
986              role: "assistant",
987              content: [
988                {
989                  type: "reasoning",
990                  text: "thinking",
991                  providerOptions: { mistral: { thinking } },
992                },
993                { type: "text", text: "Previous answer" },
994              ],
995            },
996            { role: "user", content: "Continue" },
997          ] satisfies ModelMessage[],
998          tools: {},
999        })
1000 
1001        const capture = yield* Effect.promise(() => request)
1002        const messages = capture.body.messages as Array<Record<string, unknown>>
1003        expect(messages.find((message) => message.role === "assistant")).toEqual({
1004          role: "assistant",
1005          content: [thinking, { type: "text", text: "Previous answer" }],
1006        })
1007      }),
1008    {
1009      config: () => ({
1010        enabled_providers: [mistralFixture.providerID],
1011        provider: {
1012          [mistralFixture.providerID]: {
1013            options: { apiKey: "test-key", baseURL: `${state.server!.url.origin}/v1` },
1014          },
1015        },
1016      }),
1017    },
1018  )
1019 
1020  const alibabaQwenFixture = { providerID: "alibaba", modelID: "qwen-plus" }
1021  it.instance(
1022    "service stream cancellation cancels provider response body promptly",
1023    () =>
1024      Effect.gen(function* () {
1025        const fixture = loadFixture(alibabaQwenFixture.providerID, alibabaQwenFixture.modelID)
1026        const pending = waitStreamingRequest("/chat/completions")
1027 
1028        const resolved = yield* Provider.use.getModel(
1029          ProviderV2.ID.make(alibabaQwenFixture.providerID),
1030          ModelV2.ID.make(fixture.model.id),
1031        )
1032        const sessionID = SessionID.make("session-test-service-abort")
1033        const agent = {
1034          name: "test",
1035          mode: "primary",
1036          options: {},
1037          permission: [{ permission: "*", pattern: "*", action: "allow" }],
1038        } satisfies Agent.Info
1039        const user = {
1040          id: MessageID.make("msg_user-service-abort"),
1041          sessionID,
1042          role: "user",
1043          time: { created: Date.now() },
1044          agent: agent.name,
1045          model: { providerID: ProviderV2.ID.make(alibabaQwenFixture.providerID), modelID: resolved.id },
1046        } satisfies SessionV1.User
1047 
1048        const fiber = yield* drain({
1049          user,
1050          sessionID,
1051          model: resolved,
1052          agent,
1053          system: ["You are a helpful assistant."],
1054          messages: [{ role: "user", content: "Hello" }],
1055          tools: {},
1056        }).pipe(Effect.exit, Effect.forkScoped)
1057 
1058        yield* Effect.promise(() => pending.request)
1059        yield* Fiber.interrupt(fiber)
1060 
1061        yield* Effect.promise(() => Promise.race([pending.responseCanceled, timeout(500)]))
1062        const exit = yield* Fiber.await(fiber)
1063        // Fiber.await returns an Exit<Exit<...>>. Unwrap once.
1064        const inner = Exit.isSuccess(exit) ? exit.value : exit
1065        expect(Exit.isFailure(inner)).toBe(true)
1066        if (Exit.isFailure(inner)) {
1067          expect(Cause.hasInterrupts(inner.cause)).toBe(true)
1068        }
1069        yield* Effect.promise(() => Promise.race([pending.requestAborted, timeout(500)]).catch(() => undefined))
1070      }),
1071    {
1072      config: () => ({
1073        enabled_providers: [alibabaQwenFixture.providerID],
1074        provider: {
1075          [alibabaQwenFixture.providerID]: {
1076            options: { apiKey: "test-key", baseURL: `${state.server!.url.origin}/v1` },
1077          },
1078        },
1079      }),
1080    },
1081  )
1082 
1083  it.instance(
1084    "keeps tools enabled by prompt permissions",
1085    () =>
1086      Effect.gen(function* () {
1087        const fixture = loadFixture(alibabaQwenFixture.providerID, alibabaQwenFixture.modelID)
1088        const request = waitRequest(
1089          "/chat/completions",
1090          new Response(createChatStream("Hello"), {
1091            status: 200,
1092            headers: { "Content-Type": "text/event-stream" },
1093          }),
1094        )
1095 
1096        const resolved = yield* Provider.use.getModel(
1097          ProviderV2.ID.make(alibabaQwenFixture.providerID),
1098          ModelV2.ID.make(fixture.model.id),
1099        )
1100        const sessionID = SessionID.make("session-test-tools")
1101        const agent = {
1102          name: "test",
1103          mode: "primary",
1104          options: {},
1105          permission: [{ permission: "question", pattern: "*", action: "deny" }],
1106        } satisfies Agent.Info
1107 
1108        const user = {
1109          id: MessageID.make("msg_user-tools"),
1110          sessionID,
1111          role: "user",
1112          time: { created: Date.now() },
1113          agent: agent.name,
1114          model: { providerID: ProviderV2.ID.make(alibabaQwenFixture.providerID), modelID: resolved.id },
1115          tools: { question: true },
1116        } satisfies SessionV1.User
1117 
1118        yield* drain({
1119          user,
1120          sessionID,
1121          model: resolved,
1122          agent,
1123          permission: [{ permission: "question", pattern: "*", action: "allow" }],
1124          system: ["You are a helpful assistant."],
1125          messages: [{ role: "user", content: "Hello" }],
1126          tools: {
1127            question: tool({
1128              description: "Ask a question",
1129              inputSchema: z.object({}),
1130              execute: async () => ({ output: "" }),
1131            }),
1132          },
1133        })
1134 
1135        const capture = yield* Effect.promise(() => request)
1136        const tools = capture.body.tools as Array<{ function?: { name?: string } }> | undefined
1137        expect(tools?.some((item) => item.function?.name === "question")).toBe(true)
1138      }),
1139    {
1140      config: () => ({
1141        enabled_providers: [alibabaQwenFixture.providerID],
1142        provider: {
1143          [alibabaQwenFixture.providerID]: {
1144            options: { apiKey: "test-key", baseURL: `${state.server!.url.origin}/v1` },
1145          },
1146        },
1147      }),
1148    },
1149  )
1150 
1151  it.instance(
1152    "sends responses API payload for OpenAI models",
1153    () =>
1154      Effect.gen(function* () {
1155        const model = loadFixture("openai", "gpt-5.2").model
1156 
1157        const responseChunks = [
1158          {
1159            type: "response.created",
1160            response: {
1161              id: "resp-1",
1162              created_at: Math.floor(Date.now() / 1000),
1163              model: model.id,
1164              service_tier: null,
1165            },
1166          },
1167          {
1168            type: "response.output_item.added",
1169            output_index: 0,
1170            item: { type: "message", id: "item-1", status: "in_progress", role: "assistant", content: [] },
1171          },
1172          {
1173            type: "response.content_part.added",
1174            item_id: "item-1",
1175            output_index: 0,
1176            content_index: 0,
1177            part: { type: "output_text", text: "", annotations: [] },
1178          },
1179          {
1180            type: "response.output_text.delta",
1181            item_id: "item-1",
1182            delta: "Hello",
1183            logprobs: null,
1184          },
1185          {
1186            type: "response.completed",
1187            response: {
1188              incomplete_details: null,
1189              usage: {
1190                input_tokens: 1,
1191                input_tokens_details: null,
1192                output_tokens: 1,
1193                output_tokens_details: null,
1194              },
1195              service_tier: null,
1196            },
1197          },
1198        ]
1199        const request = waitRequest("/responses", createEventResponse(responseChunks, true))
1200 
1201        const resolved = yield* Provider.use.getModel(ProviderV2.ID.openai, ModelV2.ID.make(model.id))
1202        const sessionID = SessionID.make("session-test-2")
1203        const agent = {
1204          name: "test",
1205          mode: "primary",
1206          options: { reasoningMode: "pro" },
1207          permission: [{ permission: "*", pattern: "*", action: "allow" }],
1208          temperature: 0.2,
1209        } satisfies Agent.Info
1210 
1211        const user = {
1212          id: MessageID.make("msg_user-2"),
1213          sessionID,
1214          role: "user",
1215          time: { created: Date.now() },
1216          agent: agent.name,
1217          model: { providerID: ProviderV2.ID.make("openai"), modelID: resolved.id, variant: "high" },
1218        } satisfies SessionV1.User
1219 
1220        yield* drain({
1221          user,
1222          sessionID,
1223          model: resolved,
1224          agent,
1225          system: ["You are a helpful assistant."],
1226          messages: [{ role: "user", content: "Hello" }],
1227          tools: {},
1228        })
1229 
1230        const capture = yield* Effect.promise(() => request)
1231        const body = capture.body
1232 
1233        expect(capture.url.pathname.endsWith("/responses")).toBe(true)
1234        expect(body.model).toBe(resolved.api.id)
1235        expect(body.stream).toBe(true)
1236        expect((body.reasoning as { effort?: string } | undefined)?.effort).toBe("high")
1237        expect((body.reasoning as { mode?: string } | undefined)?.mode).toBe("pro")
1238 
1239        const maxTokens = body.max_output_tokens as number | undefined
1240        expect(maxTokens).toBe(undefined) // match codex cli behavior
1241      }),
1242    { config: () => openAIConfig(loadFixture("openai", "gpt-5.2").model, `${state.server!.url.origin}/v1`) },
1243  )
1244 
1245  it.instance(
1246    "keeps supported OpenAI models on AI SDK path when native flag is off",
1247    () =>
1248      Effect.gen(function* () {
1249        const model = loadFixture("openai", "gpt-5.2").model
1250        const request = waitRequest(
1251          "/responses",
1252          createEventResponse(
1253            [
1254              {
1255                type: "response.created",
1256                response: {
1257                  id: "resp-flag-off",
1258                  created_at: Math.floor(Date.now() / 1000),
1259                  model: model.id,
1260                  service_tier: null,
1261                },
1262              },
1263              {
1264                type: "response.output_item.added",
1265                output_index: 0,
1266                item: { type: "message", id: "item-flag-off", status: "in_progress", role: "assistant", content: [] },
1267              },
1268              {
1269                type: "response.content_part.added",
1270                item_id: "item-flag-off",
1271                output_index: 0,
1272                content_index: 0,
1273                part: { type: "output_text", text: "", annotations: [] },
1274              },
1275              {
1276                type: "response.output_text.delta",
1277                item_id: "item-flag-off",
1278                delta: "Flag off",
1279                logprobs: null,
1280              },
1281              {
1282                type: "response.completed",
1283                response: {
1284                  incomplete_details: null,
1285                  usage: {
1286                    input_tokens: 1,
1287                    input_tokens_details: null,
1288                    output_tokens: 1,
1289                    output_tokens_details: null,
1290                  },
1291                  service_tier: null,
1292                },
1293              },
1294            ],
1295            true,
1296          ),
1297        )
1298        const failingNativeClient = Layer.succeed(
1299          LLMClient.Service,
1300          LLMClient.Service.of({
1301            prepare: () => Effect.die(new Error("native LLM client should not be used when the flag is off")),
1302            stream: () => Stream.die(new Error("native LLM client should not be used when the flag is off")),
1303            generate: () => Effect.die(new Error("native LLM client should not be used when the flag is off")),
1304          }),
1305        )
1306 
1307        const resolved = yield* Provider.use.getModel(ProviderV2.ID.openai, ModelV2.ID.make(model.id))
1308        const sessionID = SessionID.make("session-test-native-flag-off")
1309        const agent = {
1310          name: "test",
1311          mode: "primary",
1312          options: {},
1313          permission: [{ permission: "*", pattern: "*", action: "allow" }],
1314        } satisfies Agent.Info
1315 
1316        yield* drainWith(
1317          AppNodeBuilder.build(LLM.node, [
1318            [LayerNodePlatform.llmClient, failingNativeClient],
1319            [RuntimeFlags.node, RuntimeFlags.layer({ experimentalNativeLlm: false })],
1320          ]),
1321          {
1322            user: {
1323              id: MessageID.make("msg_user-native-flag-off"),
1324              sessionID,
1325              role: "user",
1326              time: { created: Date.now() },
1327              agent: agent.name,
1328              model: { providerID: ProviderV2.ID.make("openai"), modelID: resolved.id, variant: "high" },
1329            } satisfies SessionV1.User,
1330            sessionID,
1331            model: resolved,
1332            agent,
1333            system: ["You are a helpful assistant."],
1334            messages: [{ role: "user", content: "Hello" }],
1335            tools: {},
1336          },
1337        )
1338 
1339        const capture = yield* Effect.promise(() => request)
1340        expect(capture.url.pathname.endsWith("/responses")).toBe(true)
1341        expect(capture.body.model).toBe(resolved.api.id)
1342      }),
1343    { config: () => openAIConfig(loadFixture("openai", "gpt-5.2").model, `${state.server!.url.origin}/v1`) },
1344  )
1345 
1346  it.instance(
1347    "streams OpenAI through native runtime when opted in",
1348    () =>
1349      Effect.gen(function* () {
1350        const model = loadFixture("openai", "gpt-5.2").model
1351        const chunks = [
1352          { type: "response.created", response: { id: "resp-native" } },
1353          {
1354            type: "response.output_item.added",
1355            item: { type: "message", id: "item-native", status: "in_progress" },
1356          },
1357          { type: "response.output_text.delta", item_id: "item-native", delta: "Hello native" },
1358          {
1359            type: "response.completed",
1360            response: {
1361              incomplete_details: null,
1362              usage: {
1363                input_tokens: 1,
1364                input_tokens_details: null,
1365                output_tokens: 1,
1366                output_tokens_details: null,
1367              },
1368            },
1369          },
1370        ]
1371        const request = waitRequest("/responses", createEventResponse(chunks, true))
1372 
1373        const resolved = yield* Provider.use.getModel(ProviderV2.ID.openai, ModelV2.ID.make(model.id))
1374        const sessionID = SessionID.make("session-test-native")
1375        const agent = {
1376          name: "test",
1377          mode: "primary",
1378          options: {},
1379          permission: [{ permission: "*", pattern: "*", action: "allow" }],
1380          temperature: 0.2,
1381        } satisfies Agent.Info
1382 
1383        yield* drainWith(llmLayerWithExecutor({ flags: { experimentalNativeLlm: true } }), {
1384          user: {
1385            id: MessageID.make("msg_user-native"),
1386            sessionID,
1387            role: "user",
1388            time: { created: Date.now() },
1389            agent: agent.name,
1390            model: { providerID: ProviderV2.ID.make("openai"), modelID: resolved.id, variant: "high" },
1391          } satisfies SessionV1.User,
1392          sessionID,
1393          model: resolved,
1394          agent,
1395          system: ["You are a helpful assistant."],
1396          messages: [{ role: "user", content: "Hello" }],
1397          tools: {},
1398        })
1399 
1400        const capture = yield* Effect.promise(() => request)
1401        expect(capture.url.pathname.endsWith("/responses")).toBe(true)
1402        expect(capture.headers.get("Authorization")).toBe("Bearer test-openai-key")
1403        expect(capture.body.model).toBe(model.id)
1404        expect(capture.body.stream).toBe(true)
1405        expect((capture.body.reasoning as { effort?: string } | undefined)?.effort).toBe("high")
1406        expect(capture.body.include).toEqual(["reasoning.encrypted_content"])
1407        expect(JSON.stringify(capture.body.input)).toContain("You are a helpful assistant.")
1408        expect(capture.body.input).toContainEqual({ role: "user", content: [{ type: "input_text", text: "Hello" }] })
1409      }),
1410    { config: () => openAIConfig(loadFixture("openai", "gpt-5.2").model, `${state.server!.url.origin}/v1`) },
1411  )
1412 
1413  it.instance(
1414    "uses injected native request executor for tool calls",
1415    () =>
1416      Effect.gen(function* () {
1417        const model = loadFixture("openai", "gpt-5.2").model
1418        const chunks = [
1419          {
1420            type: "response.output_item.added",
1421            item: { type: "function_call", id: "item-injected-tool", call_id: "call-injected-tool", name: "lookup" },
1422          },
1423          {
1424            type: "response.function_call_arguments.delta",
1425            item_id: "item-injected-tool",
1426            delta: '{"query":"weather"}',
1427          },
1428          {
1429            type: "response.output_item.done",
1430            item: {
1431              type: "function_call",
1432              id: "item-injected-tool",
1433              call_id: "call-injected-tool",
1434              name: "lookup",
1435              arguments: '{"query":"weather"}',
1436            },
1437          },
1438          {
1439            type: "response.completed",
1440            response: { incomplete_details: null, usage: { input_tokens: 1, output_tokens: 1 } },
1441          },
1442        ]
1443        let captured: Record<string, unknown> | undefined
1444        let executed: unknown
1445        const executor = Layer.succeed(
1446          RequestExecutor.Service,
1447          RequestExecutor.Service.of({
1448            execute: (request) =>
1449              Effect.gen(function* () {
1450                const web = yield* HttpClientRequest.toWeb(request).pipe(Effect.orDie)
1451                captured = (yield* Effect.promise(() => web.json())) as Record<string, unknown>
1452                return HttpClientResponse.fromWeb(request, createEventResponse(chunks, true))
1453              }),
1454          }),
1455        )
1456 
1457        const resolved = yield* Provider.use.getModel(ProviderV2.ID.openai, ModelV2.ID.make(model.id))
1458        const sessionID = SessionID.make("session-test-native-injected-tool")
1459        const agent = {
1460          name: "test",
1461          mode: "primary",
1462          options: {},
1463          permission: [{ permission: "*", pattern: "*", action: "allow" }],
1464        } satisfies Agent.Info
1465 
1466        yield* drainWith(llmLayerWithExecutor({ executor, flags: { experimentalNativeLlm: true } }), {
1467          user: {
1468            id: MessageID.make("msg_user-native-injected-tool"),
1469            sessionID,
1470            role: "user",
1471            time: { created: Date.now() },
1472            agent: agent.name,
1473            model: { providerID: ProviderV2.ID.make("openai"), modelID: resolved.id },
1474          } satisfies SessionV1.User,
1475          sessionID,
1476          model: resolved,
1477          agent,
1478          system: [],
1479          messages: [{ role: "user", content: "Use lookup" }],
1480          tools: {
1481            lookup: tool({
1482              description: "Lookup data",
1483              inputSchema: z.object({ query: z.string() }),
1484              execute: async (args, options) => {
1485                executed = { args, toolCallId: options.toolCallId }
1486                return { output: "looked up" }
1487              },
1488            }),
1489          },
1490        })
1491 
1492        expect(captured?.model).toBe(model.id)
1493        expect(captured?.tools).toEqual([
1494          {
1495            type: "function",
1496            name: "lookup",
1497            description: "Lookup data",
1498            strict: false,
1499            parameters: {
1500              type: "object",
1501              properties: { query: { type: "string" } },
1502              required: ["query"],
1503              additionalProperties: false,
1504              $schema: "http://json-schema.org/draft-07/schema#",
1505            },
1506          },
1507        ])
1508        expect(executed).toEqual({ args: { query: "weather" }, toolCallId: "call-injected-tool" })
1509      }),
1510    { config: () => openAIConfig(loadFixture("openai", "gpt-5.2").model, "https://injected-openai.test/v1") },
1511  )
1512 
1513  it.instance(
1514    "executes OpenAI tool calls through native runtime",
1515    () =>
1516      Effect.gen(function* () {
1517        const model = loadFixture("openai", "gpt-5.2").model
1518        const chunks = [
1519          {
1520            type: "response.output_item.added",
1521            item: { type: "function_call", id: "item-native-tool", call_id: "call-native-tool", name: "lookup" },
1522          },
1523          {
1524            type: "response.function_call_arguments.delta",
1525            item_id: "item-native-tool",
1526            delta: '{"query":"weather"}',
1527          },
1528          {
1529            type: "response.output_item.done",
1530            item: {
1531              type: "function_call",
1532              id: "item-native-tool",
1533              call_id: "call-native-tool",
1534              name: "lookup",
1535              arguments: '{"query":"weather"}',
1536            },
1537          },
1538          {
1539            type: "response.completed",
1540            response: { incomplete_details: null, usage: { input_tokens: 1, output_tokens: 1 } },
1541          },
1542        ]
1543        const request = waitRequest("/responses", createEventResponse(chunks, true))
1544        let executed: unknown
1545 
1546        const resolved = yield* Provider.use.getModel(ProviderV2.ID.openai, ModelV2.ID.make(model.id))
1547        const sessionID = SessionID.make("session-test-native-tool")
1548        const agent = {
1549          name: "test",
1550          mode: "primary",
1551          options: {},
1552          permission: [{ permission: "*", pattern: "*", action: "allow" }],
1553        } satisfies Agent.Info
1554 
1555        yield* drainWith(llmLayerWithExecutor({ flags: { experimentalNativeLlm: true } }), {
1556          user: {
1557            id: MessageID.make("msg_user-native-tool"),
1558            sessionID,
1559            role: "user",
1560            time: { created: Date.now() },
1561            agent: agent.name,
1562            model: { providerID: ProviderV2.ID.make("openai"), modelID: resolved.id },
1563          } satisfies SessionV1.User,
1564          sessionID,
1565          model: resolved,
1566          agent,
1567          system: [],
1568          messages: [{ role: "user", content: "Use lookup" }],
1569          tools: {
1570            lookup: tool({
1571              description: "Lookup data",
1572              inputSchema: z.object({ query: z.string() }),
1573              execute: async (args, options) => {
1574                executed = { args, toolCallId: options.toolCallId }
1575                return { output: "looked up" }
1576              },
1577            }),
1578          },
1579        })
1580 
1581        const capture = yield* Effect.promise(() => request)
1582        expect(capture.body.tools).toEqual([
1583          {
1584            type: "function",
1585            name: "lookup",
1586            description: "Lookup data",
1587            strict: false,
1588            parameters: {
1589              type: "object",
1590              properties: { query: { type: "string" } },
1591              required: ["query"],
1592              additionalProperties: false,
1593              $schema: "http://json-schema.org/draft-07/schema#",
1594            },
1595          },
1596        ])
1597        expect(executed).toEqual({ args: { query: "weather" }, toolCallId: "call-native-tool" })
1598      }),
1599    {
1600      config: () => {
1601        const model = loadFixture("openai", "gpt-5.2").model
1602        return {
1603          enabled_providers: ["openai"],
1604          provider: {
1605            openai: {
1606              name: "OpenAI",
1607              env: ["OPENAI_API_KEY"],
1608              npm: "@ai-sdk/openai",
1609              api: "https://api.openai.com/v1",
1610              models: { [model.id]: JSON.parse(JSON.stringify(model)) as ConfigModel },
1611              options: { apiKey: "test-openai-key", baseURL: `${state.server!.url.origin}/v1` },
1612            },
1613          },
1614        }
1615      },
1616    },
1617  )
1618 
1619  it.instance(
1620    "accepts user image attachments as data URLs for OpenAI models",
1621    () =>
1622      Effect.gen(function* () {
1623        const model = loadFixture("openai", "gpt-5.2").model
1624        const chunks = [
1625          {
1626            type: "response.created",
1627            response: {
1628              id: "resp-data-url",
1629              created_at: Math.floor(Date.now() / 1000),
1630              model: model.id,
1631              service_tier: null,
1632            },
1633          },
1634          {
1635            type: "response.output_item.added",
1636            output_index: 0,
1637            item: { type: "message", id: "item-data-url", status: "in_progress", role: "assistant", content: [] },
1638          },
1639          {
1640            type: "response.content_part.added",
1641            item_id: "item-data-url",
1642            output_index: 0,
1643            content_index: 0,
1644            part: { type: "output_text", text: "", annotations: [] },
1645          },
1646          {
1647            type: "response.output_text.delta",
1648            item_id: "item-data-url",
1649            delta: "Looks good",
1650            logprobs: null,
1651          },
1652          {
1653            type: "response.completed",
1654            response: {
1655              incomplete_details: null,
1656              usage: {
1657                input_tokens: 1,
1658                input_tokens_details: null,
1659                output_tokens: 1,
1660                output_tokens_details: null,
1661              },
1662              service_tier: null,
1663            },
1664          },
1665        ]
1666        const request = waitRequest("/responses", createEventResponse(chunks, true))
1667        const image = `data:image/png;base64,${Buffer.from(
1668          yield* Effect.promise(() =>
1669            Bun.file(path.join(import.meta.dir, "../tool/fixtures/large-image.png")).arrayBuffer(),
1670          ),
1671        ).toString("base64")}`
1672 
1673        const resolved = yield* Provider.use.getModel(ProviderV2.ID.openai, ModelV2.ID.make(model.id))
1674        const sessionID = SessionID.make("session-test-data-url")
1675        const agent = {
1676          name: "test",
1677          mode: "primary",
1678          options: {},
1679          permission: [{ permission: "*", pattern: "*", action: "allow" }],
1680        } satisfies Agent.Info
1681 
1682        const user = {
1683          id: MessageID.make("msg_user-data-url"),
1684          sessionID,
1685          role: "user",
1686          time: { created: Date.now() },
1687          agent: agent.name,
1688          model: { providerID: ProviderV2.ID.make("openai"), modelID: resolved.id },
1689        } satisfies SessionV1.User
1690 
1691        yield* drain({
1692          user,
1693          sessionID,
1694          model: resolved,
1695          agent,
1696          system: ["You are a helpful assistant."],
1697          messages: [
1698            {
1699              role: "user",
1700              content: [
1701                { type: "text", text: "Describe this image" },
1702                { type: "file", mediaType: "image/png", filename: "large-image.png", data: image },
1703              ],
1704            },
1705          ] as ModelMessage[],
1706          tools: {},
1707        })
1708 
1709        const capture = yield* Effect.promise(() => request)
1710        expect(capture.url.pathname.endsWith("/responses")).toBe(true)
1711      }),
1712    { config: () => openAIConfig(loadFixture("openai", "gpt-5.2").model, `${state.server!.url.origin}/v1`) },
1713  )
1714 
1715  const minimaxFixture = { providerID: "minimax", modelID: "MiniMax-M2.5" }
1716  it.instance(
1717    "sends messages API payload for Anthropic Compatible models",
1718    () =>
1719      Effect.gen(function* () {
1720        const model = loadFixture(minimaxFixture.providerID, minimaxFixture.modelID).model
1721 
1722        const chunks = [
1723          {
1724            type: "message_start",
1725            message: {
1726              id: "msg-1",
1727              model: model.id,
1728              usage: {
1729                input_tokens: 3,
1730                cache_creation_input_tokens: null,
1731                cache_read_input_tokens: null,
1732              },
1733            },
1734          },
1735          {
1736            type: "content_block_start",
1737            index: 0,
1738            content_block: { type: "text", text: "" },
1739          },
1740          {
1741            type: "content_block_delta",
1742            index: 0,
1743            delta: { type: "text_delta", text: "Hello" },
1744          },
1745          { type: "content_block_stop", index: 0 },
1746          {
1747            type: "message_delta",
1748            delta: { stop_reason: "end_turn", stop_sequence: null, container: null },
1749            usage: {
1750              input_tokens: 3,
1751              output_tokens: 2,
1752              cache_creation_input_tokens: null,
1753              cache_read_input_tokens: null,
1754            },
1755          },
1756          { type: "message_stop" },
1757        ]
1758        const request = waitRequest("/messages", createEventResponse(chunks))
1759 
1760        const resolved = yield* Provider.use.getModel(
1761          ProviderV2.ID.make(minimaxFixture.providerID),
1762          ModelV2.ID.make(model.id),
1763        )
1764        const sessionID = SessionID.make("session-test-3")
1765        const agent = {
1766          name: "test",
1767          mode: "primary",
1768          options: {},
1769          permission: [{ permission: "*", pattern: "*", action: "allow" }],
1770          temperature: 0.4,
1771          topP: 0.9,
1772        } satisfies Agent.Info
1773 
1774        const user = {
1775          id: MessageID.make("msg_user-3"),
1776          sessionID,
1777          role: "user",
1778          time: { created: Date.now() },
1779          agent: agent.name,
1780          model: { providerID: ProviderV2.ID.make("minimax"), modelID: ModelV2.ID.make("MiniMax-M2.5") },
1781        } satisfies SessionV1.User
1782 
1783        yield* drain({
1784          user,
1785          sessionID,
1786          model: resolved,
1787          agent,
1788          system: ["You are a helpful assistant."],
1789          messages: [{ role: "user", content: "Hello" }],
1790          tools: {},
1791        })
1792 
1793        const capture = yield* Effect.promise(() => request)
1794        const body = capture.body
1795 
1796        expect(capture.url.pathname.endsWith("/messages")).toBe(true)
1797        expect(body.model).toBe(resolved.api.id)
1798        expect(body.max_tokens).toBe(ProviderTransform.maxOutputTokens(resolved))
1799        expect(body.temperature).toBe(0.4)
1800        expect(body.top_p).toBe(0.9)
1801      }),
1802    {
1803      config: () => ({
1804        enabled_providers: [minimaxFixture.providerID],
1805        provider: {
1806          [minimaxFixture.providerID]: {
1807            options: { apiKey: "test-anthropic-key", baseURL: `${state.server!.url.origin}/v1` },
1808          },
1809        },
1810      }),
1811    },
1812  )
1813 
1814  it.instance(
1815    "sends anthropic tool_use blocks with tool_result immediately after them",
1816    () =>
1817      Effect.gen(function* () {
1818        const model = loadFixture("anthropic", "claude-opus-4-6").model
1819        const chunks = [
1820          {
1821            type: "message_start",
1822            message: {
1823              id: "msg-tool-order",
1824              model: model.id,
1825              usage: {
1826                input_tokens: 3,
1827                cache_creation_input_tokens: null,
1828                cache_read_input_tokens: null,
1829              },
1830            },
1831          },
1832          {
1833            type: "content_block_start",
1834            index: 0,
1835            content_block: { type: "text", text: "" },
1836          },
1837          {
1838            type: "content_block_delta",
1839            index: 0,
1840            delta: { type: "text_delta", text: "ok" },
1841          },
1842          { type: "content_block_stop", index: 0 },
1843          {
1844            type: "message_delta",
1845            delta: { stop_reason: "end_turn", stop_sequence: null, container: null },
1846            usage: {
1847              input_tokens: 3,
1848              output_tokens: 2,
1849              cache_creation_input_tokens: null,
1850              cache_read_input_tokens: null,
1851            },
1852          },
1853          { type: "message_stop" },
1854        ]
1855        const request = waitRequest("/messages", createEventResponse(chunks))
1856 
1857        const resolved = yield* Provider.use.getModel(ProviderV2.ID.make("anthropic"), ModelV2.ID.make(model.id))
1858        const sessionID = SessionID.make("session-test-anthropic-tools")
1859        const agent = {
1860          name: "test",
1861          mode: "primary",
1862          options: {},
1863          permission: [{ permission: "*", pattern: "*", action: "allow" }],
1864        } satisfies Agent.Info
1865        const user = {
1866          id: MessageID.make("msg_user-anthropic-tools"),
1867          sessionID,
1868          role: "user",
1869          time: { created: Date.now() },
1870          agent: agent.name,
1871          model: { providerID: ProviderV2.ID.make("anthropic"), modelID: resolved.id, variant: "max" },
1872        } satisfies SessionV1.User
1873 
1874        const input = [
1875          {
1876            info: {
1877              id: "msg_user",
1878              sessionID,
1879              role: "user",
1880              time: { created: 1 },
1881              agent: "gentleman",
1882              model: { providerID: "anthropic", modelID: "claude-opus-4-6", variant: "max" },
1883            },
1884            parts: [
1885              {
1886                id: "p_user",
1887                sessionID,
1888                messageID: "msg_user",
1889                type: "text",
1890                text: "Can you check whether there are any PDF files in my home directory?",
1891              },
1892            ],
1893          },
1894          {
1895            info: {
1896              id: "msg_call",
1897              sessionID,
1898              parentID: "msg_user",
1899              role: "assistant",
1900              mode: "gentleman",
1901              agent: "gentleman",
1902              variant: "max",
1903              path: { cwd: "/root", root: "/" },
1904              cost: 0,
1905              tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
1906              modelID: "claude-opus-4-6",
1907              providerID: "anthropic",
1908              time: { created: 2, completed: 3 },
1909              finish: "tool-calls",
1910            },
1911            parts: [
1912              {
1913                id: "p_step",
1914                sessionID,
1915                messageID: "msg_call",
1916                type: "step-start",
1917              },
1918              {
1919                id: "p_read",
1920                sessionID,
1921                messageID: "msg_call",
1922                type: "tool",
1923                tool: "read",
1924                callID: "toolu_01N8mDEzG8DSTs7UPHFtmgCT",
1925                state: {
1926                  status: "completed",
1927                  input: { filePath: "/root" },
1928                  output: "<path>/root</path>",
1929                  metadata: {},
1930                  title: "root",
1931                  time: { start: 10, end: 11 },
1932                },
1933              },
1934              {
1935                id: "p_glob",
1936                sessionID,
1937                messageID: "msg_call",
1938                type: "tool",
1939                tool: "glob",
1940                callID: "toolu_01APxrADs7VozN8uWzw9WwHr",
1941                state: {
1942                  status: "completed",
1943                  input: { pattern: "**/*.pdf", path: "/root" },
1944                  output: "No files found",
1945                  metadata: {},
1946                  title: "root",
1947                  time: { start: 12, end: 13 },
1948                },
1949              },
1950              {
1951                id: "p_text",
1952                sessionID,
1953                messageID: "msg_call",
1954                type: "text",
1955                text: "I checked your home directory and looked for PDF files.",
1956                time: { start: 14, end: 15 },
1957              },
1958            ],
1959          },
1960        ] as any[]
1961 
1962        const modelMessages = yield* Effect.promise(() => MessageV2.toModelMessages(input as any, resolved))
1963        yield* drain({
1964          user,
1965          sessionID,
1966          model: resolved,
1967          agent,
1968          system: [],
1969          messages: modelMessages,
1970          tools: {
1971            read: tool({
1972              description: "Stub read tool",
1973              inputSchema: z.object({ filePath: z.string() }),
1974              execute: async () => ({ output: "stub" }),
1975            }),
1976            glob: tool({
1977              description: "Stub glob tool",
1978              inputSchema: z.object({ pattern: z.string(), path: z.string().optional() }),
1979              execute: async () => ({ output: "stub" }),
1980            }),
1981          },
1982        })
1983 
1984        const capture = yield* Effect.promise(() => request)
1985        const body = capture.body
1986 
1987        expect(capture.url.pathname.endsWith("/messages")).toBe(true)
1988        const messages = body.messages as Array<{ role: string; content: Array<Record<string, unknown>> }>
1989        expect(messages[0]?.role).toBe("user")
1990        expect(messages[0]?.content[0]).toMatchObject({
1991          type: "text",
1992          text: "Can you check whether there are any PDF files in my home directory?",
1993        })
1994        expect(messages.some((message) => message.content.some((part) => "cache_control" in part))).toBe(true)
1995        const toolUseIndex = messages.findIndex((message) => message.content.some((part) => part.type === "tool_use"))
1996        expect(toolUseIndex).toBeGreaterThan(0)
1997        expect(messages[toolUseIndex].role).toBe("assistant")
1998        expect(messages[toolUseIndex].content.filter((part) => part.type === "tool_use")).toMatchObject([
1999          {
2000            type: "tool_use",
2001            id: "toolu_01N8mDEzG8DSTs7UPHFtmgCT",
2002            name: "read",
2003            input: { filePath: "/root" },
2004          },
2005          {
2006            type: "tool_use",
2007            id: "toolu_01APxrADs7VozN8uWzw9WwHr",
2008            name: "glob",
2009            input: { pattern: "**/*.pdf", path: "/root" },
2010          },
2011        ])
2012        expect(messages[toolUseIndex + 1]).toMatchObject({
2013          role: "user",
2014          content: [
2015            { type: "tool_result", tool_use_id: "toolu_01N8mDEzG8DSTs7UPHFtmgCT", content: "<path>/root</path>" },
2016            { type: "tool_result", tool_use_id: "toolu_01APxrADs7VozN8uWzw9WwHr", content: "No files found" },
2017          ],
2018        })
2019      }),
2020    {
2021      config: () => {
2022        const model = loadFixture("anthropic", "claude-opus-4-6").model
2023        return {
2024          enabled_providers: ["anthropic"],
2025          provider: {
2026            anthropic: {
2027              name: "Anthropic",
2028              env: ["ANTHROPIC_API_KEY"],
2029              npm: "@ai-sdk/anthropic",
2030              api: "https://api.anthropic.com/v1",
2031              models: { [model.id]: configModel(model) as ConfigModel },
2032              options: { apiKey: "test-anthropic-key", baseURL: `${state.server!.url.origin}/v1` },
2033            },
2034          },
2035        }
2036      },
2037    },
2038  )
2039 
2040  const geminiFixture = { providerID: "google", modelID: "gemini-2.5-flash" }
2041  it.instance(
2042    "sends Google API payload for Gemini models",
2043    () =>
2044      Effect.gen(function* () {
2045        const model = loadFixture(geminiFixture.providerID, geminiFixture.modelID).model
2046        const pathSuffix = `/v1beta/models/${model.id}:streamGenerateContent`
2047 
2048        const chunks = [
2049          {
2050            candidates: [{ content: { parts: [{ text: "Hello" }] }, finishReason: "STOP" }],
2051            usageMetadata: { promptTokenCount: 1, candidatesTokenCount: 1, totalTokenCount: 2 },
2052          },
2053        ]
2054        const request = waitRequest(pathSuffix, createEventResponse(chunks))
2055 
2056        const resolved = yield* Provider.use.getModel(
2057          ProviderV2.ID.make(geminiFixture.providerID),
2058          ModelV2.ID.make(model.id),
2059        )
2060        const sessionID = SessionID.make("session-test-4")
2061        const agent = {
2062          name: "test",
2063          mode: "primary",
2064          options: {},
2065          permission: [{ permission: "*", pattern: "*", action: "allow" }],
2066          temperature: 0.3,
2067          topP: 0.8,
2068        } satisfies Agent.Info
2069 
2070        const user = {
2071          id: MessageID.make("msg_user-4"),
2072          sessionID,
2073          role: "user",
2074          time: { created: Date.now() },
2075          agent: agent.name,
2076          model: { providerID: ProviderV2.ID.make(geminiFixture.providerID), modelID: resolved.id },
2077        } satisfies SessionV1.User
2078 
2079        yield* drain({
2080          user,
2081          sessionID,
2082          model: resolved,
2083          agent,
2084          system: ["You are a helpful assistant."],
2085          messages: [
2086            { role: "user", content: "Hello" },
2087            { role: "assistant", content: [{ type: "reasoning", text: "" }] },
2088          ],
2089          tools: {},
2090        })
2091 
2092        const capture = yield* Effect.promise(() => request)
2093        const body = capture.body
2094        const config = body.generationConfig as
2095          | { temperature?: number; topP?: number; maxOutputTokens?: number }
2096          | undefined
2097 
2098        expect(capture.url.pathname).toBe(pathSuffix)
2099        expect(body.contents).toEqual([{ role: "user", parts: [{ text: "Hello" }] }])
2100        expect(config?.temperature).toBe(0.3)
2101        expect(config?.topP).toBe(0.8)
2102        expect(config?.maxOutputTokens).toBe(ProviderTransform.maxOutputTokens(resolved))
2103      }),
2104    {
2105      config: () => ({
2106        enabled_providers: [geminiFixture.providerID],
2107        provider: {
2108          [geminiFixture.providerID]: {
2109            options: { apiKey: "test-google-key", baseURL: `${state.server!.url.origin}/v1beta` },
2110          },
2111        },
2112      }),
2113    },
2114  )
2115})
2116