sailfork / t3code-github / .repos/ effect/ packages/ ai/ openrouter/ test/ OpenRouterLanguageModel.test.ts

import { Generated, OpenRouterClient, OpenRouterLanguageModel } from "@effect/ai-openrouter"
import { assert, describe, it } from "@effect/vitest"
import { deepStrictEqual, strictEqual } from "@effect/vitest/utils"
import { Array, Context, Effect, Layer, Redacted, Ref, Schema, Stream } from "effect"
import { LanguageModel, Model, Prompt, Tool, Toolkit } from "effect/ai"
import { HttpClient, type HttpClientError, type HttpClientRequest, HttpClientResponse } from "effect/http"

describe("OpenRouterLanguageModel", () => {
  describe("strictJsonSchema", () => {
    for (
      const [model, strict] of [
        ["openai/gpt-4o-mini", true],
        ["google/gemini-2.5-flash", null]
      ] as const
    ) {
      it.effect(`defaults response strictness to ${strict} for ${model}`, () =>
        Effect.gen(function*() {
          yield* LanguageModel.generateObject({
            prompt: "Give me a name",
            schema: Schema.Struct({ name: Schema.String })
          }).pipe(Effect.provide(OpenRouterLanguageModel.model(model)))

          const requests = yield* MockHttpClient.requests
          const body = yield* getRequestBody(requests[0])
          strictEqual(body.response_format.json_schema.strict, strict)
        }).pipe(Effect.provide(makeTestLayer({
          body: {
            choices: [{
              finish_reason: "stop",
              index: 0,
              message: { role: "assistant", content: JSON.stringify({ name: "Alice" }) }
            }]
          }
        }))))
    }

    it.effect("omits false from requests while preserving response strictness", () =>
      Effect.gen(function*() {
        yield* LanguageModel.generateObject({
          prompt: "Give me a name",
          schema: Schema.Struct({ name: Schema.String })
        }).pipe(Effect.provide(OpenRouterLanguageModel.model("openai/gpt-4o-mini", { strictJsonSchema: false })))

        const requests = yield* MockHttpClient.requests
        const body = yield* getRequestBody(requests[0])
        strictEqual(body.response_format.json_schema.strict, false)
        assert.notProperty(body, "strictJsonSchema")
      }).pipe(Effect.provide(makeTestLayer({
        body: {
          choices: [{
            finish_reason: "stop",
            index: 0,
            message: { role: "assistant", content: JSON.stringify({ name: "Alice" }) }
          }]
        }
      }))))

    it.effect("omits true from streaming requests while preserving tool strictness", () =>
      Effect.gen(function*() {
        const tool = Tool.make("FlexibleTool", { parameters: Schema.Struct({ query: Schema.String }) })
          .annotate(Tool.Strict, false)
        yield* LanguageModel.streamText({
          prompt: "Use a tool",
          toolkit: Toolkit.make(tool),
          disableToolCallResolution: true
        }).pipe(
          Stream.runDrain,
          Effect.provide(OpenRouterLanguageModel.model("openai/gpt-4o-mini", { strictJsonSchema: true }))
        )

        const requests = yield* MockHttpClient.requests
        const body = yield* getRequestBody(requests[0])
        strictEqual(body.stream, true)
        strictEqual(body.tools[0].function.strict, false)
        assert.notProperty(body, "strictJsonSchema")
      }).pipe(Effect.provide(makeStreamTestLayer([]))))
  })

  it.effect("model provides openrouter provider metadata", () =>
    Effect.gen(function*() {
      strictEqual(yield* Model.ProviderName, "openrouter")
    }).pipe(
      Effect.provide(OpenRouterLanguageModel.model("google/gemini-2.5-flash")),
      Effect.provide(makeTestLayer())
    ))

  describe("generateText", () => {
    describe("message preparation", () => {
      describe("audio file parts", () => {
        it.effect("converts audio bytes to input_audio", () =>
          Effect.gen(function*() {
            const audioData = new Uint8Array([0x49, 0x44, 0x33, 0x04]) // ID3v2 magic bytes

            yield* LanguageModel.generateText({
              prompt: Prompt.make([{
                role: "user",
                content: [
                  Prompt.filePart({
                    mediaType: "audio/mpeg",
                    data: audioData
                  })
                ]
              }])
            }).pipe(Effect.provide(OpenRouterLanguageModel.model("google/gemini-2.5-flash")))

            const requests = yield* MockHttpClient.requests
            const body = yield* getRequestBody(requests[0])

            const userMessage = body.messages.find((message: any) => message.role === "user")
            deepStrictEqual(userMessage.content, [{
              type: "input_audio",
              input_audio: {
                data: "SUQzBA==",
                format: "mp3"
              }
            }])
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("converts base64 data url audio to input_audio", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([{
                role: "user",
                content: [
                  Prompt.filePart({
                    mediaType: "audio/wav",
                    data: "data:audio/wav;base64,UklGRg=="
                  })
                ]
              }])
            }).pipe(Effect.provide(OpenRouterLanguageModel.model("google/gemini-2.5-flash")))

            const requests = yield* MockHttpClient.requests
            const body = yield* getRequestBody(requests[0])

            const userMessage = body.messages.find((message: any) => message.role === "user")
            deepStrictEqual(userMessage.content, [{
              type: "input_audio",
              input_audio: {
                data: "UklGRg==",
                format: "wav"
              }
            }])
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("maps audio media types to OpenRouter audio formats", () =>
          Effect.gen(function*() {
            const mediaTypes: ReadonlyArray<readonly [mediaType: string, format: string]> = [
              ["audio/aac", "aac"],
              ["audio/x-aiff", "aiff"],
              ["audio/flac", "flac"],
              ["audio/L16", "pcm16"],
              ["audio/mp4", "m4a"],
              ["audio/mp3", "mp3"],
              ["audio/ogg", "ogg"],
              ["audio/x-wav", "wav"]
            ]

            yield* LanguageModel.generateText({
              prompt: Prompt.make([{
                role: "user",
                content: mediaTypes.map(([mediaType]) =>
                  Prompt.filePart({
                    mediaType,
                    data: new Uint8Array([0x00])
                  })
                )
              }])
            }).pipe(Effect.provide(OpenRouterLanguageModel.model("google/gemini-2.5-flash")))

            const requests = yield* MockHttpClient.requests
            const body = yield* getRequestBody(requests[0])

            const userMessage = body.messages.find((message: any) => message.role === "user")
            deepStrictEqual(
              userMessage.content.map((item: any) => item.input_audio.format),
              mediaTypes.map(([, format]) => format)
            )
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("fails on unsupported audio media types", () =>
          Effect.gen(function*() {
            const error = yield* LanguageModel.generateText({
              prompt: Prompt.make([{
                role: "user",
                content: [
                  Prompt.filePart({
                    mediaType: "audio/webm",
                    data: new Uint8Array([0x00])
                  })
                ]
              }])
            }).pipe(
              Effect.provide(OpenRouterLanguageModel.model("google/gemini-2.5-flash")),
              Effect.flip
            )

            strictEqual(error.reason._tag, "InvalidUserInputError")
            assert.include(error.message, "audio/webm")
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("fails on audio URLs", () =>
          Effect.gen(function*() {
            const error = yield* LanguageModel.generateText({
              prompt: Prompt.make([{
                role: "user",
                content: [
                  Prompt.filePart({
                    mediaType: "audio/mpeg",
                    data: new URL("https://example.com/audio.mp3")
                  })
                ]
              }])
            }).pipe(
              Effect.provide(OpenRouterLanguageModel.model("google/gemini-2.5-flash")),
              Effect.flip
            )

            strictEqual(error.reason._tag, "InvalidUserInputError")
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("converts non-audio files to file blocks", () =>
          Effect.gen(function*() {
            const pdfData = new Uint8Array([0x25, 0x50, 0x44, 0x46]) // %PDF

            yield* LanguageModel.generateText({
              prompt: Prompt.make([{
                role: "user",
                content: [
                  Prompt.filePart({
                    mediaType: "application/pdf",
                    fileName: "document.pdf",
                    data: pdfData
                  })
                ]
              }])
            }).pipe(Effect.provide(OpenRouterLanguageModel.model("google/gemini-2.5-flash")))

            const requests = yield* MockHttpClient.requests
            const body = yield* getRequestBody(requests[0])

            const userMessage = body.messages.find((message: any) => message.role === "user")
            deepStrictEqual(userMessage.content, [{
              type: "file",
              file: {
                filename: "document.pdf",
                file_data: "data:application/pdf;base64,JVBERg=="
              }
            }])
          }).pipe(Effect.provide(makeTestLayer())))
      })

      it.effect("preserves string tool results", () =>
        Effect.gen(function*() {
          yield* LanguageModel.generateText({
            prompt: Prompt.make([
              { role: "user", content: "Use the tool" },
              {
                role: "assistant",
                content: [Prompt.toolCallPart({
                  id: "call_text",
                  name: "text_tool",
                  params: {},
                  providerExecuted: false
                })]
              },
              {
                role: "tool",
                content: [Prompt.toolResultPart({
                  id: "call_text",
                  name: "text_tool",
                  result: "PLAIN_TEXT_SENTINEL\n",
                  isFailure: false,
                  providerExecuted: false
                })]
              }
            ]),
            disableToolCallResolution: true
          }).pipe(Effect.provide(OpenRouterLanguageModel.model("google/gemini-2.5-flash")))

          const requests = yield* MockHttpClient.requests
          const body = yield* getRequestBody(requests[0])
          const toolResult = body.messages.find((message: any) => message.role === "tool")

          assert.isDefined(toolResult)
          strictEqual(toolResult.content, "PLAIN_TEXT_SENTINEL\n")
        }).pipe(Effect.provide(makeTestLayer())))

      const modelOutputCases = [
        {
          label: "as text with file placeholders",
          modelOutput: [
            Prompt.textPart({ text: "Screenshot" }),
            Prompt.filePart({ mediaType: "image/png", fileName: "screenshot.png", data: "iVBORw0KGgo=" })
          ],
          content: "Screenshot\n[image/png screenshot.png omitted]"
        },
        { label: "as an empty string when it is empty", modelOutput: [], content: "" }
      ]

      for (const { content, label, modelOutput } of modelOutputCases) {
        it.effect(`sends tool result model output ${label}`, () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "user", content: "Use the tool" },
                {
                  role: "assistant",
                  content: [Prompt.toolCallPart({
                    id: "call_image",
                    name: "image_tool",
                    params: {},
                    providerExecuted: false
                  })]
                },
                {
                  role: "tool",
                  content: [Prompt.toolResultPart({
                    id: "call_image",
                    name: "image_tool",
                    result: { output: "APPLICATION_ONLY" },
                    modelOutput,
                    isFailure: false,
                    providerExecuted: false
                  })]
                }
              ]),
              disableToolCallResolution: true
            }).pipe(Effect.provide(OpenRouterLanguageModel.model("google/gemini-2.5-flash")))

            const requests = yield* MockHttpClient.requests
            const body = yield* getRequestBody(requests[0])
            const toolResult = body.messages.find((message: any) => message.role === "tool")

            assert.isDefined(toolResult)
            strictEqual(toolResult.content, content)
          }).pipe(Effect.provide(makeTestLayer())))
      }

      describe("cache control", () => {
        const ephemeral = { type: "ephemeral" } as const
        const oneHour = { type: "ephemeral", ttl: "1h" } as const
        const cached = { openrouter: { cacheControl: ephemeral } }
        const partCached = { openrouter: { cacheControl: oneHour } }

        it.effect("sends cached void tool results without throwing", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([{
                role: "tool",
                content: [Prompt.toolResultPart({
                  id: "call_void",
                  name: "void_tool",
                  result: undefined,
                  isFailure: false,
                  providerExecuted: false
                })],
                options: cached
              }]),
              disableToolCallResolution: true
            }).pipe(Effect.provide(OpenRouterLanguageModel.model("anthropic/claude-sonnet-4.5")))

            const requests = yield* MockHttpClient.requests
            const body = yield* getRequestBody(requests[0])
            const toolResult = body.messages.find((message: any) => message.role === "tool")
            strictEqual(toolResult.tool_call_id, "call_void")
          }).pipe(Effect.provide(makeTestLayer())))

        for (const partLevel of [false, true]) {
          it.effect(
            partLevel
              ? "preserves part breakpoints and prefers them to message breakpoints"
              : "puts message breakpoints on the last assistant text and tool result",
            () =>
              Effect.gen(function*() {
                yield* LanguageModel.generateText({
                  prompt: Prompt.make([
                    { role: "user", content: "Look up both" },
                    {
                      role: "assistant",
                      content: [
                        Prompt.reasoningPart({ text: "Thinking" }),
                        Prompt.textPart({ text: "First", options: partLevel ? partCached : undefined }),
                        Prompt.textPart({ text: "Second" }),
                        Prompt.textPart({ text: "Last", options: partLevel ? partCached : undefined }),
                        ...["a", "b", "c"].map((id) =>
                          Prompt.toolCallPart({ id, name: "lookup", params: {}, providerExecuted: false })
                        )
                      ],
                      options: cached
                    },
                    {
                      role: "tool",
                      content: [
                        ...["a", "b", "c"].map((id) =>
                          Prompt.toolResultPart({
                            id,
                            name: "lookup",
                            result: id === "c" ? { value: 42 } : id,
                            isFailure: false,
                            providerExecuted: false,
                            options: partLevel && id !== "b" ? partCached : undefined
                          })
                        ),
                        Prompt.toolApprovalResponsePart({ approvalId: "approval", approved: true })
                      ],
                      options: cached
                    }
                  ]),
                  disableToolCallResolution: true
                }).pipe(Effect.provide(OpenRouterLanguageModel.model("anthropic/claude-sonnet-4.5")))

                const requests = yield* MockHttpClient.requests
                const body = yield* getRequestBody(requests[0])
                const assistant = body.messages.find((message: any) => message.role === "assistant")
                deepStrictEqual(assistant.content, [
                  partLevel
                    ? { type: "text", text: "First", cache_control: oneHour }
                    : { type: "text", text: "First" },
                  { type: "text", text: "Second" },
                  { type: "text", text: "Last", cache_control: partLevel ? oneHour : ephemeral }
                ])
                strictEqual(assistant.reasoning, "Thinking")
                deepStrictEqual(assistant.tool_calls, [
                  { id: "a", type: "function", function: { name: "lookup", arguments: "{}" } },
                  { id: "b", type: "function", function: { name: "lookup", arguments: "{}" } },
                  { id: "c", type: "function", function: { name: "lookup", arguments: "{}" } }
                ])
                deepStrictEqual(body.messages.filter((message: any) => message.role === "tool"), [
                  {
                    role: "tool",
                    tool_call_id: "a",
                    content: partLevel ? [{ type: "text", text: "a", cache_control: oneHour }] : "a"
                  },
                  { role: "tool", tool_call_id: "b", content: "b" },
                  {
                    role: "tool",
                    tool_call_id: "c",
                    content: [{ type: "text", text: "{\"value\":42}", cache_control: partLevel ? oneHour : ephemeral }]
                  }
                ])
              }).pipe(Effect.provide(makeTestLayer()))
          )
        }
      })
    })

    describe("tool preparation", () => {
      it.effect("passes raw JSON schema for dynamic tools", () =>
        Effect.gen(function*() {
          const inputSchema = {
            properties: {
              query: { type: "string" }
            }
          } as const

          const DynamicTool = Tool.dynamic("DynamicTool", {
            description: "A dynamic tool",
            parameters: inputSchema
          })

          yield* LanguageModel.generateText({
            prompt: "Use the dynamic tool",
            toolkit: Toolkit.make(DynamicTool),
            disableToolCallResolution: true
          }).pipe(Effect.provide(OpenRouterLanguageModel.model("google/gemini-2.5-flash")))

          const requests = yield* MockHttpClient.requests
          const body = yield* getRequestBody(requests[0])

          const tool = body.tools?.find((entry: any) =>
            entry.type === "function" && entry.function.name === "DynamicTool"
          )
          assert.isDefined(tool)
          strictEqual(tool.function.description, "A dynamic tool")
          deepStrictEqual(tool.function.parameters, inputSchema)
        }).pipe(Effect.provide(makeTestLayer())))

      it.effect("passes object union parameters through", () =>
        Effect.gen(function*() {
          const UnionTool = Tool.make("UnionTool", {
            parameters: Schema.Union([
              Schema.Struct({ query: Schema.String }).annotate({ identifier: "Query" }),
              Schema.Struct({ id: Schema.String })
            ])
          })

          yield* LanguageModel.generateText({
            prompt: "Use the tool",
            toolkit: Toolkit.make(UnionTool),
            disableToolCallResolution: true
          }).pipe(Effect.provide(OpenRouterLanguageModel.model("google/gemini-2.5-flash")))

          const requests = yield* MockHttpClient.requests
          const body = yield* getRequestBody(requests[0])

          deepStrictEqual(body.tools[0].function.parameters, {
            anyOf: [
              { $ref: "#/$defs/Query" },
              { type: "object", properties: { id: { type: "string" } }, required: ["id"], additionalProperties: true }
            ],
            $defs: {
              Query: {
                type: "object",
                properties: { query: { type: "string" } },
                required: ["query"],
                additionalProperties: true
              }
            }
          })
        }).pipe(Effect.provide(makeTestLayer())))

      it.effect("names the tool when its parameters are not an object schema", () =>
        Effect.gen(function*() {
          const error = yield* LanguageModel.generateText({
            prompt: "Use the tool",
            toolkit: Toolkit.make(Tool.make("NoParams", { parameters: Schema.Struct({}) })),
            disableToolCallResolution: true
          }).pipe(Effect.provide(OpenRouterLanguageModel.model("google/gemini-2.5-flash")), Effect.flip)

          strictEqual(error.reason._tag, "UnsupportedSchemaError")
          assert.include(error.message, `"NoParams"`)
          assert.include(error.message, "Tool.EmptyParams")
        }).pipe(Effect.provide(makeTestLayer())))
    })

    describe("usage", () => {
      it.effect("derives text and uncached tokens when details are subsets of their totals", () =>
        Effect.gen(function*() {
          const result = yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
            Effect.provide(OpenRouterLanguageModel.model("openai/gpt-4o-mini"))
          )

          deepStrictEqual(
            result.usage.inputTokens,
            { uncached: 70, total: 100, cacheRead: 30, cacheWrite: 0 },
            "subset input usage"
          )
          deepStrictEqual(result.usage.outputTokens, { total: 50, text: 30, reasoning: 20 }, "subset output usage")
        }).pipe(Effect.provide(makeTestLayer({
          body: {
            usage: {
              prompt_tokens: 100,
              prompt_tokens_details: { cached_tokens: 30 },
              completion_tokens: 50,
              completion_tokens_details: { reasoning_tokens: 20 },
              total_tokens: 150
            }
          }
        }))))

      it.effect("preserves totals when detail counts equal their parent counts", () =>
        Effect.gen(function*() {
          const result = yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
            Effect.provide(OpenRouterLanguageModel.model("openai/gpt-4o-mini"))
          )

          deepStrictEqual(
            result.usage.inputTokens,
            { uncached: 0, total: 100, cacheRead: 100, cacheWrite: 0 },
            "input usage at equality"
          )
          deepStrictEqual(result.usage.outputTokens, { total: 20, text: 0, reasoning: 20 }, "output usage at equality")
        }).pipe(Effect.provide(makeTestLayer({
          body: {
            usage: {
              prompt_tokens: 100,
              prompt_tokens_details: { cached_tokens: 100 },
              completion_tokens: 20,
              completion_tokens_details: { reasoning_tokens: 20 },
              total_tokens: 120
            }
          }
        }))))

      it.effect("treats reasoning tokens as disjoint when they exceed completion tokens", () =>
        Effect.gen(function*() {
          const result = yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
            Effect.provide(OpenRouterLanguageModel.model("openai/gpt-4o-mini"))
          )

          deepStrictEqual(result.usage.outputTokens, { total: 30, text: 10, reasoning: 20 }, "disjoint reasoning usage")
        }).pipe(Effect.provide(makeTestLayer({
          body: {
            usage: {
              prompt_tokens: 100,
              completion_tokens: 10,
              completion_tokens_details: { reasoning_tokens: 20 },
              total_tokens: 110
            }
          }
        }))))

      it.effect("treats cached tokens as disjoint when they exceed prompt tokens", () =>
        Effect.gen(function*() {
          const result = yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
            Effect.provide(OpenRouterLanguageModel.model("openai/gpt-4o-mini"))
          )

          deepStrictEqual(
            result.usage.inputTokens,
            { uncached: 100, total: 400, cacheRead: 300, cacheWrite: 0 },
            "disjoint cached usage"
          )
        }).pipe(Effect.provide(makeTestLayer({
          body: {
            usage: {
              prompt_tokens: 100,
              prompt_tokens_details: { cached_tokens: 300 },
              completion_tokens: 10,
              total_tokens: 110
            }
          }
        }))))
    })
  })

  describe("streamText", () => {
    describe("usage", () => {
      it.effect("treats streamed reasoning tokens as disjoint when they exceed completion tokens", () =>
        Effect.gen(function*() {
          const parts = yield* LanguageModel.streamText({ prompt: "Hello" }).pipe(
            Stream.runCollect,
            Effect.provide(OpenRouterLanguageModel.model("openai/gpt-4o-mini")),
            Effect.provide(makeStreamTestLayer([{
              id: "response-1",
              object: "chat.completion.chunk",
              model: "openai/gpt-4o-mini",
              created: 1,
              choices: [],
              usage: {
                prompt_tokens: 100,
                completion_tokens: 10,
                completion_tokens_details: { reasoning_tokens: 20 },
                total_tokens: 110
              }
            }]))
          )

          const finishPart = parts.find((part) => part.type === "finish")
          deepStrictEqual(
            finishPart?.usage.outputTokens,
            { total: 30, text: 10, reasoning: 20 },
            "streamed disjoint reasoning usage"
          )
        }))
    })

    it.effect("preserves streamed citation start and end indexes", () =>
      Effect.gen(function*() {
        const parts = yield* LanguageModel.streamText({ prompt: "cite a source" }).pipe(
          Stream.runCollect,
          Effect.provide(OpenRouterLanguageModel.model("openai/gpt-4o-mini")),
          Effect.provide(makeStreamTestLayer([{
            id: "response-1",
            object: "chat.completion.chunk",
            model: "openai/gpt-4o-mini",
            created: 1,
            choices: [{
              index: 0,
              delta: {
                annotations: [{
                  type: "url_citation",
                  url_citation: {
                    url: "https://example.com/source",
                    title: "source",
                    start_index: 2,
                    end_index: 9
                  }
                }]
              }
            }]
          }]))
        )

        const source = globalThis.Array.from(parts).find((part) => part.type === "source")
        assert.isDefined(source)
        if (source?.type === "source") {
          assert.deepStrictEqual(source.metadata, {
            openrouter: { startIndex: 2, endIndex: 9 }
          })
        }
      }))

    it.effect("uses lowercase openrouter reasoning-end metadata", () =>
      Effect.gen(function*() {
        const reasoningDetails = [{
          type: "reasoning.text",
          text: "thinking",
          signature: "signature-final",
          format: "unknown"
        }] as const
        const parts = yield* LanguageModel.streamText({ prompt: "reason then answer" }).pipe(
          Stream.runCollect,
          Effect.provide(OpenRouterLanguageModel.model("openai/gpt-4o-mini")),
          Effect.provide(makeStreamTestLayer([
            {
              id: "response-1",
              object: "chat.completion.chunk",
              model: "openai/gpt-4o-mini",
              created: 1,
              choices: [{ index: 0, delta: { reasoning_details: reasoningDetails } }]
            },
            {
              id: "response-1",
              object: "chat.completion.chunk",
              model: "openai/gpt-4o-mini",
              created: 1,
              choices: [{ index: 0, finish_reason: "stop", delta: { content: "answer" } }]
            }
          ]))
        )

        const reasoningEnd = parts.find((part) => part.type === "reasoning-end")
        deepStrictEqual(reasoningEnd?.metadata, { openrouter: { reasoningDetails } })
      }))

    it.effect("emits incremental tool parameter fragments", () =>
      Effect.gen(function*() {
        const ProbeTool = Tool.make("ProbeTool", {
          parameters: Schema.Struct({ a: Schema.Number }),
          success: Schema.String
        })
        const toolkit = Toolkit.make(ProbeTool)
        const parts = yield* LanguageModel.streamText({
          prompt: "call the tool",
          toolkit,
          disableToolCallResolution: true
        }).pipe(
          Stream.runCollect,
          Effect.provide(OpenRouterLanguageModel.model("openai/gpt-4o-mini")),
          Effect.provide(toolkit.toLayer({ ProbeTool: () => Effect.succeed("ok") })),
          Effect.provide(makeStreamTestLayer([
            {
              id: "response-1",
              object: "chat.completion.chunk",
              model: "openai/gpt-4o-mini",
              created: 1,
              choices: [{
                index: 0,
                delta: {
                  tool_calls: [{
                    index: 0,
                    id: "call-1",
                    type: "function",
                    function: { name: "ProbeTool", arguments: "{\"a\":" }
                  }]
                }
              }]
            },
            {
              id: "response-1",
              object: "chat.completion.chunk",
              model: "openai/gpt-4o-mini",
              created: 1,
              choices: [{
                index: 0,
                delta: { tool_calls: [{ index: 0 }] }
              }]
            },
            {
              id: "response-1",
              object: "chat.completion.chunk",
              model: "openai/gpt-4o-mini",
              created: 1,
              choices: [{
                index: 0,
                finish_reason: "tool_calls",
                delta: { tool_calls: [{ index: 0, function: { arguments: "1}" } }] }
              }]
            }
          ]))
        )

        deepStrictEqual(
          globalThis.Array.from(parts)
            .filter((part) => part.type === "tool-params-delta")
            .map((part) => part.delta),
          ["{\"a\":", "1}"]
        )
      }))
  })
})

// =============================================================================
// Test Infrastructure
// =============================================================================

class MockOpenRouterResponse extends Context.Service<MockOpenRouterResponse, {
  readonly status: number
  readonly body: typeof Generated.SendChatCompletionRequest200.Type
  readonly headers?: Record<string, string> | undefined
}>()("MockOpenRouterResponse") {}

class MockHttpClient extends Context.Service<MockHttpClient, {
  readonly requests: Effect.Effect<ReadonlyArray<HttpClientRequest.HttpClientRequest>>
}>()("MockHttpClient") {
  static requests = Effect.service(MockHttpClient).pipe(
    Effect.flatMap((client) => client.requests)
  )
}

const encodeResponse = Schema.encodeEffect(Generated.SendChatCompletionRequest200)

const makeHttpClient = Effect.gen(function*() {
  const capturedRequests = yield* Ref.make<ReadonlyArray<HttpClientRequest.HttpClientRequest>>([])
  const response = yield* MockOpenRouterResponse
  const body = yield* Effect.orDie(encodeResponse(response.body))

  const httpClient = HttpClient.makeWith(
    Effect.fnUntraced(function*(requestEffect) {
      const request = yield* requestEffect
      yield* Ref.update(capturedRequests, Array.append(request))
      return HttpClientResponse.fromWeb(
        request,
        new Response(JSON.stringify(body), {
          headers: response.headers ?? {},
          status: response.status
        })
      )
    }),
    Effect.succeed as HttpClient.HttpClient.Preprocess<HttpClientError.HttpClientError, never>
  )

  return Context.make(HttpClient.HttpClient, httpClient).pipe(
    Context.add(MockHttpClient, MockHttpClient.of({ requests: Ref.get(capturedRequests) }))
  )
})

const HttpClientLayer = Layer.effectContext(makeHttpClient)

const makeDefaultResponse = (
  overrides: Partial<typeof Generated.SendChatCompletionRequest200.Type> = {}
): typeof Generated.SendChatCompletionRequest200.Type => ({
  id: "gen-test123",
  choices: [{
    finish_reason: "stop",
    index: 0,
    message: {
      role: "assistant",
      content: "Hello!"
    }
  }],
  created: 1234567890,
  model: "google/gemini-2.5-flash",
  object: "chat.completion",
  system_fingerprint: null,
  ...overrides
})

const makeTestLayer = (options: {
  readonly body?: Partial<typeof Generated.SendChatCompletionRequest200.Type>
  readonly status?: number
  readonly headers?: Record<string, string>
} = {}) =>
  OpenRouterClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
    Layer.provideMerge(HttpClientLayer),
    Layer.provide(Layer.succeed(MockOpenRouterResponse, {
      body: makeDefaultResponse(options.body),
      status: options.status ?? 200,
      headers: options.headers ?? {}
    }))
  )

const getRequestBody = Effect.fnUntraced(function*(request: HttpClientRequest.HttpClientRequest) {
  const body = request.body
  if (body._tag === "Uint8Array") {
    const text = new TextDecoder().decode(body.body)
    return JSON.parse(text)
  }
  return yield* Effect.die(new Error("Expected Uint8Array body"))
})

const makeStreamTestLayer = (events: ReadonlyArray<typeof Generated.ChatStreamChunk.Encoded>) => {
  const body = events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join("") + "data: [DONE]\n\n"
  const httpClientLayer = Layer.effectContext(Effect.gen(function*() {
    const capturedRequests = yield* Ref.make<ReadonlyArray<HttpClientRequest.HttpClientRequest>>([])
    const httpClient = HttpClient.makeWith(
      Effect.fnUntraced(function*(requestEffect) {
        const request = yield* requestEffect
        yield* Ref.update(capturedRequests, Array.append(request))
        return HttpClientResponse.fromWeb(
          request,
          new Response(body, {
            status: 200,
            headers: { "content-type": "text/event-stream" }
          })
        )
      }),
      Effect.succeed as HttpClient.HttpClient.Preprocess<HttpClientError.HttpClientError, never>
    )
    return Context.make(HttpClient.HttpClient, httpClient).pipe(
      Context.add(MockHttpClient, MockHttpClient.of({ requests: Ref.get(capturedRequests) }))
    )
  }))
  return OpenRouterClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
    Layer.provideMerge(httpClientLayer)
  )
}