sailfork / t3code-github / .repos/ effect/ packages/ ai/ openai-compat/ test/ OpenAiLanguageModel.test.ts

import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai-compat"
import { assert, describe, it } from "@effect/vitest"
import { Effect, Layer, Redacted, Ref, Schema, Stream } from "effect"
import { type AiError, LanguageModel, Prompt, Tool, Toolkit } from "effect/ai"
import { HttpClient, type HttpClientError, type HttpClientRequest, HttpClientResponse } from "effect/http"

describe("OpenAiLanguageModel", () => {
  for (const mode of ["complete", "stream"] as const) {
    it.effect(`prepares selected tool codecs once per ${mode} request and normalizes repeated calls`, () =>
      Effect.gen(function*() {
        let conversions = 0
        const Env = Schema.Record(Schema.String, Schema.String).check(
          Schema.makeFilter<object>(() => true, {
            representation: { id: "test/compat/toolCodec", payload: null },
            toJsonSchema: () => {
              conversions++
              return { minItems: 1 }
            }
          })
        )
        const ReadEnv = Tool.make("ReadEnv", { parameters: Schema.Struct({ env: Env }) })
        const Unselected = Tool.make("Unselected", {
          parameters: Schema.Struct({ opaque: Schema.declare((input): input is string => typeof input === "string") })
        })
        const toolkit = Toolkit.make(ReadEnv, Unselected)
        const toolkitLayer = toolkit.toLayer({
          ReadEnv: () => Effect.void,
          Unselected: () => Effect.void
        })
        const calls = ["call_1", "call_2"].map((id) => ({
          id,
          type: "function" as const,
          function: { name: "ReadEnv", arguments: JSON.stringify({ env: [{ 0: "PATH", 1: "/usr/bin" }] }) }
        }))
        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.gen(function*() {
                const body = yield* getRequestBody(request)
                assert.deepStrictEqual(body.tools.map((tool: any) => tool.function.name), ["ReadEnv"])
                assert.strictEqual(body.tools[0].function.parameters.properties.env.type, "array")
                return mode === "complete"
                  ? jsonResponse(
                    request,
                    makeChatCompletion({
                      choices: [{
                        index: 0,
                        finish_reason: "tool_calls",
                        message: { role: "assistant", content: null, tool_calls: calls }
                      }]
                    })
                  )
                  : sseResponse(request, [{
                    id: "chatcmpl_env",
                    object: "chat.completion.chunk",
                    model: "gpt-4o-mini",
                    created: 1,
                    choices: [{
                      index: 0,
                      delta: { tool_calls: calls.map((call, index) => ({ ...call, index })) },
                      finish_reason: "tool_calls"
                    }]
                  }, "[DONE]"])
              })
            )
          ))
        )
        for (let request = 1; request <= 2; request++) {
          const options = {
            prompt: "read the environment",
            toolkit,
            toolChoice: { oneOf: ["ReadEnv"] as Array<"ReadEnv"> },
            disableToolCallResolution: true
          }
          const calls = yield* (mode === "complete"
            ? LanguageModel.generateText(options).pipe(
              Effect.map((result) => result.toolCalls.map((part) => ({ id: part.id, params: part.params })))
            )
            : LanguageModel.streamText(options).pipe(
              Stream.runCollect,
              Effect.map((parts) =>
                parts.filter((part) => part.type === "tool-call").map((part) => ({ id: part.id, params: part.params }))
              )
            )).pipe(
              Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
              Effect.provide(toolkitLayer),
              Effect.provide(layer)
            )
          assert.deepStrictEqual(
            calls,
            [
              { id: "call_1", params: { env: { PATH: "/usr/bin" } } },
              { id: "call_2", params: { env: { PATH: "/usr/bin" } } }
            ]
          )
          assert.strictEqual(conversions, request)
        }
      }))
  }

  describe("generateText", () => {
    it.effect("serializes text-only user messages and decodes text output", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "stop",
                    message: {
                      role: "assistant",
                      content: "Hello, compat!"
                    }
                  }]
                })
              ))
            })
          ))
        )

        const result = yield* LanguageModel.generateText({
          prompt: Prompt.make([
            { role: "user", content: [Prompt.textPart({ text: "hello" })] },
            { role: "user", content: [Prompt.textPart({ text: "" })] },
            { role: "user", content: [Prompt.textPart({ text: "  Hello, 世界!\nGoodbye.  " })] },
            { role: "user", content: [Prompt.textPart({ text: "first" }), Prompt.textPart({ text: "second" })] },
            { role: "user", content: [] }
          ])
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(layer)
        )

        assert.strictEqual(result.text, "Hello, compat!")
        assert.isDefined(capturedRequest)
        if (capturedRequest === undefined) {
          return
        }

        const requestBody = yield* getRequestBody(capturedRequest)
        assert.strictEqual(requestBody.model, "gpt-4o-mini")
        assert.deepStrictEqual(requestBody.messages, [
          { role: "user", content: "hello" },
          { role: "user", content: "" },
          { role: "user", content: "  Hello, 世界!\nGoodbye.  " },
          { role: "user", content: "first\nsecond" },
          { role: "user", content: "" }
        ])
      }))

    it.effect("routes invalid tool call params through failureMode: return without failing the effect", () =>
      Effect.gen(function*() {
        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "tool_calls",
                    message: {
                      role: "assistant",
                      content: null,
                      tool_calls: [{
                        id: "call_1",
                        type: "function",
                        function: {
                          name: "ReturnModeTool",
                          arguments: JSON.stringify({ input: 123 })
                        }
                      }]
                    }
                  }]
                })
              ))
            )
          ))
        )

        const ReturnModeTool = Tool.make("ReturnModeTool", {
          description: "A test tool",
          failureMode: "return",
          parameters: Schema.Struct({ input: Schema.String }),
          success: Schema.Struct({ output: Schema.String }),
          failure: Schema.Struct({ error: Schema.String })
        })

        const toolkit = Toolkit.make(ReturnModeTool)
        const toolkitLayer = toolkit.toLayer({
          ReturnModeTool: ({ input }) => Effect.succeed({ output: `processed: ${input}` })
        })

        const result = yield* LanguageModel.generateText({
          prompt: "use the tool",
          toolkit
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(toolkitLayer),
          Effect.provide(layer)
        )

        assert.strictEqual(result.toolResults.length, 1)
        const toolResult = result.toolResults[0]!
        assert.strictEqual(toolResult.isFailure, true)
        const failure = toolResult.result as AiError.AiError
        assert.strictEqual(failure._tag, "AiError")
        assert.strictEqual(failure.reason._tag, "ToolParameterValidationError")
      }))

    it.effect("forwards reasoning config to chat completions request", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "stop",
                    message: {
                      role: "assistant",
                      content: "Done"
                    }
                  }]
                })
              ))
            })
          ))
        )

        yield* LanguageModel.generateText({ prompt: "hello" }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-5", {
            reasoning: {
              effort: "medium",
              summary: "auto"
            }
          })),
          Effect.provide(layer)
        )

        assert.isDefined(capturedRequest)
        if (capturedRequest === undefined) {
          return
        }

        const requestBody = yield* getRequestBody(capturedRequest)
        assert.deepStrictEqual(requestBody.reasoning, {
          effort: "medium",
          summary: "auto"
        })
      }))

    it.effect("forwards custom model config properties to chat completions request", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "stop",
                    message: {
                      role: "assistant",
                      content: "Done"
                    }
                  }]
                })
              ))
            })
          ))
        )

        yield* LanguageModel.generateText({ prompt: "hello" }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", {
            vendor_setting: {
              mode: "strict"
            }
          })),
          Effect.provide(layer)
        )

        assert.isDefined(capturedRequest)
        if (capturedRequest === undefined) {
          return
        }

        const requestBody = yield* getRequestBody(capturedRequest)
        assert.deepStrictEqual(requestBody.vendor_setting, {
          mode: "strict"
        })
      }))

    it.effect("preserves URL and base64 images in multimodal content order", () =>
      Effect.gen(function*() {
        const base64 = "iVBORw0KGgo="
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "stop",
                    message: {
                      role: "assistant",
                      content: "done"
                    }
                  }]
                })
              ))
            })
          ))
        )

        yield* LanguageModel.generateText({
          prompt: Prompt.make([{
            role: "user",
            content: [
              Prompt.textPart({ text: "first text" }),
              Prompt.filePart({
                mediaType: "image/png",
                data: new URL("https://example.com/image.png")
              }),
              Prompt.filePart({ mediaType: "image/png", data: "https://example.com/string-image.png" }),
              Prompt.filePart({ mediaType: "image/png", data: base64 }),
              Prompt.textPart({ text: "second text" })
            ]
          }])
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(layer)
        )

        assert.isDefined(capturedRequest)
        if (capturedRequest === undefined) {
          return
        }

        const requestBody = yield* getRequestBody(capturedRequest)
        const content = requestBody.messages[0]?.content
        assert.isTrue(Array.isArray(content))
        assert.deepStrictEqual(content, [
          {
            type: "text",
            text: "first text"
          },
          {
            type: "image_url",
            image_url: {
              url: "https://example.com/image.png",
              detail: "auto"
            }
          },
          {
            type: "image_url",
            image_url: {
              url: "https://example.com/string-image.png",
              detail: "auto"
            }
          },
          {
            type: "image_url",
            image_url: {
              url: `data:image/png;base64,${base64}`,
              detail: "auto"
            }
          },
          {
            type: "text",
            text: "second text"
          }
        ])
      }))

    it.effect("normalizes empty assistant message content to an empty string", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "stop",
                    message: {
                      role: "assistant",
                      content: "done"
                    }
                  }]
                })
              ))
            })
          ))
        )

        yield* LanguageModel.generateText({
          prompt: Prompt.make([
            { role: "user", content: "hello" },
            {
              role: "assistant",
              content: [Prompt.textPart({ text: "" })]
            },
            { role: "user", content: "continue" }
          ])
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(layer)
        )

        assert.isDefined(capturedRequest)
        if (capturedRequest === undefined) {
          return
        }

        const requestBody = yield* getRequestBody(capturedRequest)
        const assistantMessage = requestBody.messages.find((message: any) => message.role === "assistant")
        assert.isDefined(assistantMessage)
        assert.strictEqual(assistantMessage.content, "")
        assert.isUndefined(assistantMessage.tool_calls)
      }))

    it.effect("maps function_call output to tool-call part and sends function tool schema", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "tool_calls",
                    message: {
                      role: "assistant",
                      content: null,
                      tool_calls: [{
                        id: "call_1",
                        type: "function",
                        function: {
                          name: "TestTool",
                          arguments: JSON.stringify({ input: "hello" })
                        }
                      }]
                    }
                  }]
                })
              ))
            })
          ))
        )

        const result = yield* LanguageModel.generateText({
          prompt: "use the tool",
          toolkit: TestToolkit,
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(TestToolkitLayer),
          Effect.provide(layer)
        )

        const toolCall = result.content.find((part) => part.type === "tool-call")
        assert.isDefined(toolCall)
        if (toolCall?.type !== "tool-call") {
          return
        }

        assert.strictEqual(toolCall.name, "TestTool")
        assert.deepStrictEqual(toolCall.params, { input: "hello" })

        assert.isDefined(capturedRequest)
        if (capturedRequest === undefined) {
          return
        }

        const requestBody = yield* getRequestBody(capturedRequest)
        const functionTool = requestBody.tools.find((tool: any) => tool.type === "function")
        assert.isDefined(functionTool)
        assert.strictEqual(functionTool.function.name, "TestTool")
        assert.strictEqual(functionTool.function.strict, true)
      }))

    it.effect("decodes tool call params with the OpenAI codec", () =>
      Effect.gen(function*() {
        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "tool_calls",
                    message: {
                      role: "assistant",
                      content: null,
                      tool_calls: [{
                        id: "call_record_1",
                        type: "function",
                        function: {
                          name: "RecordTool",
                          arguments: JSON.stringify({ env: [{ 0: "PATH", 1: "/usr/bin" }] })
                        }
                      }]
                    }
                  }]
                })
              ))
            )
          ))
        )

        const result = yield* LanguageModel.generateText({
          prompt: "read the environment",
          toolkit: RecordToolkit,
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(RecordToolkitLayer),
          Effect.provide(layer)
        )

        const toolCall = result.content.find((part) => part.type === "tool-call")
        assert.isDefined(toolCall)
        if (toolCall?.type !== "tool-call") {
          return
        }
        assert.deepStrictEqual(toolCall.params, { env: { PATH: "/usr/bin" } })
      }))

    it.effect("preserves raw JSON Schema dynamic tool call params", () =>
      Effect.gen(function*() {
        const params = { query: "effect" }
        const client = makeHttpClient((request) =>
          Effect.succeed(jsonResponse(
            request,
            makeChatCompletion({
              choices: [{
                index: 0,
                finish_reason: "tool_calls",
                message: {
                  role: "assistant",
                  content: null,
                  tool_calls: [{
                    id: "call_dynamic_1",
                    type: "function",
                    function: { name: "DynamicTool", arguments: JSON.stringify(params) }
                  }]
                }
              }]
            })
          ))
        )
        const DynamicTool = Tool.dynamic("DynamicTool", {
          parameters: {
            type: "object",
            properties: { query: { type: "string" } },
            required: ["query"],
            additionalProperties: false
          } as const
        })
        const result = yield* LanguageModel.generateText({
          prompt: "use the dynamic tool",
          toolkit: Toolkit.make(DynamicTool),
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
          Effect.provideService(HttpClient.HttpClient, client)
        )

        assert.deepStrictEqual(result.toolCalls[0]?.params, params)
      }))

    it.effect("decodes Effect Schema dynamic tool call params with the OpenAI codec", () =>
      Effect.gen(function*() {
        const DynamicTool = Tool.dynamic("DynamicTool", {
          parameters: Schema.Struct({
            env: Schema.Record(Schema.String, Schema.String)
          })
        })
        const client = makeHttpClient((request) =>
          Effect.succeed(jsonResponse(
            request,
            makeChatCompletion({
              choices: [{
                index: 0,
                finish_reason: "tool_calls",
                message: {
                  role: "assistant",
                  content: null,
                  tool_calls: [{
                    id: "call_dynamic_1",
                    type: "function",
                    function: {
                      name: "DynamicTool",
                      arguments: JSON.stringify({ env: [{ 0: "PATH", 1: "/usr/bin" }] })
                    }
                  }]
                }
              }]
            })
          ))
        )
        const result = yield* LanguageModel.generateText({
          prompt: "use the dynamic tool",
          toolkit: Toolkit.make(DynamicTool),
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
          Effect.provideService(HttpClient.HttpClient, client)
        )

        assert.deepStrictEqual(result.toolCalls[0]?.params, { env: { PATH: "/usr/bin" } })
      }))

    it.effect("groups parallel tool calls into one assistant message", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(request, makeChatCompletion()))
            })
          ))
        )

        yield* LanguageModel.generateText({
          prompt: Prompt.make([
            { role: "user", content: "use both tools" },
            {
              role: "assistant",
              content: [
                Prompt.toolCallPart({
                  id: "call_1",
                  name: "TestTool",
                  params: { input: "first" },
                  providerExecuted: false
                }),
                Prompt.toolCallPart({
                  id: "call_2",
                  name: "TestTool",
                  params: { input: "second" },
                  providerExecuted: false
                })
              ]
            },
            {
              role: "tool",
              content: [
                Prompt.toolResultPart({
                  id: "call_1",
                  name: "TestTool",
                  isFailure: false,
                  result: { output: "first" },
                  providerExecuted: false
                }),
                Prompt.toolResultPart({
                  id: "call_2",
                  name: "TestTool",
                  isFailure: false,
                  result: { output: "second" },
                  providerExecuted: false
                })
              ]
            }
          ]),
          toolkit: TestToolkit
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(TestToolkitLayer),
          Effect.provide(layer)
        )

        assert.isDefined(capturedRequest)
        if (capturedRequest === undefined) {
          return
        }

        const requestBody = yield* getRequestBody(capturedRequest)
        assert.deepStrictEqual(requestBody.messages, [
          { role: "user", content: "use both tools" },
          {
            role: "assistant",
            content: null,
            tool_calls: [
              {
                id: "call_1",
                type: "function",
                function: { name: "TestTool", arguments: JSON.stringify({ input: "first" }) }
              },
              {
                id: "call_2",
                type: "function",
                function: { name: "TestTool", arguments: JSON.stringify({ input: "second" }) }
              }
            ]
          },
          { role: "tool", tool_call_id: "call_1", content: JSON.stringify({ output: "first" }) },
          { role: "tool", tool_call_id: "call_2", content: JSON.stringify({ output: "second" }) }
        ])
      }))

    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*() {
          let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

          const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
            Layer.provide(Layer.succeed(
              HttpClient.HttpClient,
              makeHttpClient((request) => {
                capturedRequest = request
                return Effect.succeed(jsonResponse(request, makeChatCompletion()))
              })
            ))
          )

          yield* LanguageModel.generateText({
            prompt: Prompt.make([
              {
                role: "assistant",
                content: [Prompt.toolCallPart({
                  id: "call_1",
                  name: "TestTool",
                  params: { input: "screenshot" },
                  providerExecuted: false
                })]
              },
              {
                role: "tool",
                content: [Prompt.toolResultPart({
                  id: "call_1",
                  name: "TestTool",
                  isFailure: false,
                  result: { output: "APPLICATION_ONLY" },
                  modelOutput,
                  providerExecuted: false
                })]
              }
            ]),
            toolkit: TestToolkit,
            disableToolCallResolution: true
          }).pipe(
            Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
            Effect.provide(layer)
          )

          assert.isDefined(capturedRequest)
          if (capturedRequest === undefined) {
            return
          }

          const requestBody = yield* getRequestBody(capturedRequest)
          assert.deepStrictEqual(requestBody.messages[1], {
            role: "tool",
            tool_call_id: "call_1",
            content
          })
        }))
    }

    it.effect("echoes tool call extra_content in follow-up requests", () =>
      Effect.gen(function*() {
        const extraContent = { google: { thought_signature: "signature-1" } }
        const requests: Array<HttpClientRequest.HttpClientRequest> = []

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              requests.push(request)
              return Effect.succeed(jsonResponse(
                request,
                requests.length > 1 ? makeChatCompletion() : makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "tool_calls",
                    message: {
                      role: "assistant",
                      content: null,
                      tool_calls: [{
                        id: "call_1",
                        type: "function",
                        extra_content: extraContent,
                        function: { name: "TestTool", arguments: JSON.stringify({ input: "hello" }) }
                      }]
                    }
                  }]
                })
              ))
            })
          ))
        )

        const generate = (prompt: Prompt.Prompt) =>
          LanguageModel.generateText({ prompt, toolkit: TestToolkit, disableToolCallResolution: true }).pipe(
            Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
            Effect.provide(layer)
          )

        const prompt = Prompt.make("use the tool")
        const first = yield* generate(prompt)
        yield* generate(Prompt.concat(prompt, Prompt.fromResponseParts(first.content)))

        const followUpBody = yield* getRequestBody(requests[1])
        assert.deepStrictEqual(followUpBody.messages[1].tool_calls[0].extra_content, extraContent)
      }))

    it.effect("converts dynamic tools to function type", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "stop",
                    message: {
                      role: "assistant",
                      content: "Done"
                    }
                  }]
                })
              ))
            })
          ))
        )

        const inputSchema = {
          type: "object",
          properties: {
            query: { type: "string" },
            limit: { type: "number" }
          },
          required: ["query"],
          additionalProperties: false
        } as const

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

        yield* LanguageModel.generateText({
          prompt: "use dynamic tool",
          toolkit: Toolkit.make(DynamicTool),
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(layer)
        )

        assert.isDefined(capturedRequest)
        if (capturedRequest === undefined) {
          return
        }

        const requestBody = yield* getRequestBody(capturedRequest)
        const functionTool = requestBody.tools?.find((tool: any) =>
          tool.type === "function" && tool.function?.name === "DynamicTool"
        )
        assert.isDefined(functionTool)
        assert.strictEqual(functionTool.function.description, "A dynamic tool")
        assert.deepStrictEqual(functionTool.function.parameters, inputSchema)
      }))

    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(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
          Effect.provideService(HttpClient.HttpClient, makeHttpClient(() => Effect.die("unexpected request"))),
          Effect.flip
        )

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

    it.effect("maps provider apply_patch function call back to custom provider-defined tool", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "tool_calls",
                    message: {
                      role: "assistant",
                      content: null,
                      tool_calls: [{
                        id: "call_1",
                        type: "function",
                        function: {
                          name: "apply_patch",
                          arguments: JSON.stringify({
                            call_id: "call_1",
                            operation: {
                              type: "delete_file",
                              path: "src/obsolete.ts"
                            }
                          })
                        }
                      }]
                    }
                  }]
                })
              ))
            })
          ))
        )

        const toolkit = Toolkit.make(CompatApplyPatchTool({}))
        const toolkitLayer = toolkit.toLayer({
          CompatApplyPatch: () =>
            Effect.succeed({
              status: "completed",
              output: "deleted"
            })
        })

        const result = yield* LanguageModel.generateText({
          prompt: "delete src/obsolete.ts",
          toolkit,
          toolChoice: { tool: "CompatApplyPatch" },
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(toolkitLayer),
          Effect.provide(layer)
        )

        const toolCall = result.content.find((part) => part.type === "tool-call")
        assert.isDefined(toolCall)
        if (toolCall?.type !== "tool-call") {
          return
        }

        assert.strictEqual(toolCall.name, "CompatApplyPatch")
        assert.deepStrictEqual(toolCall.params, {
          call_id: "call_1",
          operation: {
            type: "delete_file",
            path: "src/obsolete.ts"
          }
        })

        assert.isDefined(capturedRequest)
        if (capturedRequest === undefined) {
          return
        }

        const requestBody = yield* getRequestBody(capturedRequest)

        const functionTool = requestBody.tools.find((tool: any) => tool.type === "function")
        assert.isDefined(functionTool)
        assert.strictEqual(functionTool.function.name, "apply_patch")
        assert.deepStrictEqual(requestBody.tool_choice, {
          type: "function",
          function: {
            name: "apply_patch"
          }
        })
      }))

    it.effect("decodes usage when token detail fields are absent", () =>
      Effect.gen(function*() {
        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "stop",
                    message: {
                      role: "assistant",
                      content: "Hello"
                    }
                  }],
                  usage: {
                    prompt_tokens: 4,
                    completion_tokens: 5,
                    total_tokens: 9,
                    provider_future_field: true
                  }
                })
              ))
            )
          ))
        )

        const result = yield* LanguageModel.generateText({ prompt: "hello" }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(layer)
        )

        const finish = result.content.find((part) => part.type === "finish")
        assert.isDefined(finish)
        if (finish?.type !== "finish") {
          return
        }

        assert.deepStrictEqual(finish.usage.inputTokens, {
          uncached: 4,
          total: 4,
          cacheRead: 0,
          cacheWrite: undefined
        })
        assert.deepStrictEqual(finish.usage.outputTokens, {
          total: 5,
          text: 5,
          reasoning: 0
        })
      }))

    it.effect("surfaces reasoning from non-streaming responses", () =>
      Effect.gen(function*() {
        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "stop",
                    message: {
                      role: "assistant",
                      reasoning: "I should greet the user.",
                      content: "Hello!"
                    }
                  }]
                })
              ))
            )
          ))
        )

        const result = yield* LanguageModel.generateText({ prompt: "hello" }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(layer)
        )

        const reasoning = result.content.find((part) => part.type === "reasoning")
        assert.isDefined(reasoning)
        if (reasoning?.type !== "reasoning") {
          return
        }
        assert.strictEqual(reasoning.text, "I should greet the user.")
        assert.strictEqual(result.text, "Hello!")
      }))

    it.effect("surfaces reasoning_content from non-streaming responses", () =>
      Effect.gen(function*() {
        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "stop",
                    message: {
                      role: "assistant",
                      reasoning_content: "I should greet the user.",
                      content: "Hello!"
                    }
                  }]
                })
              ))
            )
          ))
        )

        const result = yield* LanguageModel.generateText({ prompt: "hello" }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(layer)
        )

        const reasoning = result.content.find((part) => part.type === "reasoning")
        assert.isDefined(reasoning)
        if (reasoning?.type !== "reasoning") {
          return
        }
        assert.strictEqual(reasoning.text, "I should greet the user.")
        assert.strictEqual(result.text, "Hello!")
      }))

    it.effect("returns invalid and undeclared tool calls when tool call validation is deferred", () =>
      Effect.gen(function*() {
        const client = makeHttpClient((request) =>
          Effect.succeed(jsonResponse(
            request,
            makeChatCompletion({
              choices: [{
                index: 0,
                finish_reason: "tool_calls",
                message: {
                  role: "assistant",
                  content: null,
                  tool_calls: [
                    { id: "call_1", type: "function", function: { name: "TestTool", arguments: "{\"input\":42}" } },
                    { id: "call_2", type: "function", function: { name: "Write", arguments: "{\"path\":\"a\"}" } }
                  ]
                }
              }]
            })
          ))
        )

        const result = yield* LanguageModel.generateText({
          prompt: "use the tools",
          toolkit: TestToolkit,
          disableToolCallResolution: true,
          toolCallValidation: "deferred"
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(TestToolkitLayer),
          Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
          Effect.provideService(HttpClient.HttpClient, client)
        )

        assert.deepStrictEqual(result.toolCalls.map(({ name, params }) => ({ name, params })), [
          { name: "TestTool", params: { input: 42 } },
          { name: "Write", params: { path: "a" } }
        ])
      }))

    it.effect("replays reasoning alongside assistant text and tool calls", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(request, makeChatCompletion()))
            })
          ))
        )

        const prompt = Prompt.make([
          { role: "user", content: "What is in a.txt?" },
          {
            role: "assistant",
            content: [
              { type: "reasoning", text: "The user wants a.txt; I should read it." },
              { type: "text", text: "Let me read it." },
              { type: "tool-call", id: "call_1", name: "TestTool", params: { input: "a.txt" } }
            ]
          },
          {
            role: "tool",
            content: [{ type: "tool-result", id: "call_1", name: "TestTool", isFailure: false, result: "hello" }]
          }
        ])

        yield* LanguageModel.generateText({ prompt, toolkit: TestToolkit, disableToolCallResolution: true }).pipe(
          Effect.provide(OpenAiLanguageModel.model("deepseek-reasoner")),
          Effect.provide(layer)
        )

        assert.isDefined(capturedRequest)
        if (capturedRequest === undefined) {
          return
        }

        const requestBody = yield* getRequestBody(capturedRequest)
        assert.deepStrictEqual(requestBody.messages, [
          { role: "user", content: "What is in a.txt?" },
          {
            role: "assistant",
            content: "Let me read it.",
            reasoning_content: "The user wants a.txt; I should read it.",
            tool_calls: [{
              id: "call_1",
              type: "function",
              function: { name: "TestTool", arguments: JSON.stringify({ input: "a.txt" }) }
            }]
          },
          { role: "tool", tool_call_id: "call_1", content: "hello" }
        ])
      }))

    it.effect("replays decoded Groq reasoning under its original field alongside text and tool calls", () =>
      Effect.gen(function*() {
        const requests: Array<HttpClientRequest.HttpClientRequest> = []

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              requests.push(request)
              return Effect.succeed(jsonResponse(
                request,
                requests.length > 1 ? makeChatCompletion() : makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "tool_calls",
                    message: {
                      role: "assistant",
                      reasoning: "Need the file",
                      content: "Let me read it.",
                      tool_calls: [{
                        id: "call_1",
                        type: "function",
                        function: { name: "TestTool", arguments: JSON.stringify({ input: "a.txt" }) }
                      }]
                    }
                  }]
                })
              ))
            })
          ))
        )

        const generate = (prompt: Prompt.Prompt) =>
          LanguageModel.generateText({ prompt, toolkit: TestToolkit, disableToolCallResolution: true }).pipe(
            Effect.provide(OpenAiLanguageModel.model("openai/gpt-oss-120b")),
            Effect.provide(layer)
          )

        const prompt = Prompt.make("What is in a.txt?")
        const first = yield* generate(prompt)
        yield* generate(Prompt.concat(
          Prompt.concat(prompt, Prompt.fromResponseParts(first.content)),
          Prompt.make([{
            role: "tool",
            content: [{ type: "tool-result", id: "call_1", name: "TestTool", isFailure: false, result: "hello" }]
          }])
        ))

        const followUpBody = yield* getRequestBody(requests[1])
        assert.deepStrictEqual(followUpBody.messages, [
          { role: "user", content: "What is in a.txt?" },
          {
            role: "assistant",
            content: "Let me read it.",
            reasoning: "Need the file",
            tool_calls: [{
              id: "call_1",
              type: "function",
              function: { name: "TestTool", arguments: JSON.stringify({ input: "a.txt" }) }
            }]
          },
          { role: "tool", tool_call_id: "call_1", content: "hello" }
        ])
      }))
  })

  describe("generateObject", () => {
    it.effect("uses json_schema format for structured output", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "stop",
                    message: {
                      role: "assistant",
                      content: JSON.stringify({ name: "Ada", age: 37 })
                    }
                  }]
                })
              ))
            })
          ))
        )

        const person = yield* LanguageModel.generateObject({
          prompt: "Return a person",
          schema: Schema.Struct({
            name: Schema.String,
            age: Schema.Number
          })
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(layer)
        )

        assert.strictEqual(person.value.name, "Ada")
        assert.strictEqual(person.value.age, 37)

        assert.isDefined(capturedRequest)
        if (capturedRequest === undefined) {
          return
        }

        const requestBody = yield* getRequestBody(capturedRequest)
        assert.strictEqual(requestBody.response_format.type, "json_schema")
        assert.strictEqual(requestBody.response_format.json_schema.strict, true)
      }))

    it.effect("uses OpenAI codec transformer for optional structured fields", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(
                request,
                makeChatCompletion({
                  choices: [{
                    index: 0,
                    finish_reason: "stop",
                    message: {
                      role: "assistant",
                      content: JSON.stringify({ name: "Ada", nickname: null })
                    }
                  }]
                })
              ))
            })
          ))
        )

        const person = yield* LanguageModel.generateObject({
          prompt: "Return a person",
          schema: Schema.Struct({
            name: Schema.String,
            nickname: Schema.optionalKey(Schema.String)
          })
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(layer)
        )

        assert.strictEqual(person.value.name, "Ada")
        assert.isUndefined(person.value.nickname)

        assert.isDefined(capturedRequest)
        if (capturedRequest === undefined) {
          return
        }

        const requestBody = yield* getRequestBody(capturedRequest)
        assert.deepStrictEqual(requestBody.response_format.json_schema.schema.required, ["name", "nickname"])
        assert.deepStrictEqual(requestBody.response_format.json_schema.schema.properties.nickname, {
          anyOf: [{ type: "string" }, { type: "null" }]
        })
      }))
  })

  describe("streamText", () => {
    it.effect("replays streamed assistant text and tool calls with store enabled", () =>
      Effect.gen(function*() {
        const requests: Array<HttpClientRequest.HttpClientRequest> = []

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              requests.push(request)
              return Effect.succeed(
                requests.length > 1
                  ? jsonResponse(request, makeChatCompletion())
                  : sseResponse(request, [
                    {
                      id: "chatcmpl_store_1",
                      object: "chat.completion.chunk",
                      model: "gpt-4o-mini",
                      created: 1,
                      choices: [{
                        index: 0,
                        delta: {
                          content: "Let me read it.",
                          tool_calls: [{
                            index: 0,
                            id: "call_1",
                            type: "function",
                            function: { name: "TestTool", arguments: JSON.stringify({ input: "a.txt" }) }
                          }]
                        },
                        finish_reason: "tool_calls"
                      }]
                    },
                    "[DONE]"
                  ])
              )
            })
          ))
        )

        const model = OpenAiLanguageModel.model("gpt-4o-mini", { store: true })
        const prompt = Prompt.make("What is in a.txt?")
        const parts = yield* LanguageModel.streamText({
          prompt,
          toolkit: TestToolkit,
          disableToolCallResolution: true
        }).pipe(
          Stream.runCollect,
          Effect.provide(model),
          Effect.provide(layer)
        )

        yield* LanguageModel.generateText({
          prompt: Prompt.concat(
            Prompt.concat(prompt, Prompt.fromResponseParts(parts)),
            Prompt.make([{
              role: "tool",
              content: [{ type: "tool-result", id: "call_1", name: "TestTool", isFailure: false, result: "hello" }]
            }])
          ),
          toolkit: TestToolkit,
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(model),
          Effect.provide(layer)
        )

        const followUpBody = yield* getRequestBody(requests[1])
        assert.deepStrictEqual(followUpBody.messages, [
          { role: "user", content: "What is in a.txt?" },
          {
            role: "assistant",
            content: "Let me read it.",
            tool_calls: [{
              id: "call_1",
              type: "function",
              function: { name: "TestTool", arguments: JSON.stringify({ input: "a.txt" }) }
            }]
          },
          { role: "tool", tool_call_id: "call_1", content: "hello" }
        ])
      }))

    it.effect("handles chat completion stream chunks", () =>
      Effect.gen(function*() {
        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(sseResponse(request, [
                {
                  id: "chatcmpl_test123",
                  object: "chat.completion.chunk",
                  model: "gpt-4o-mini",
                  created: 1,
                  choices: [{
                    index: 0,
                    delta: {},
                    finish_reason: "stop"
                  }]
                },
                "[DONE]"
              ]))
            )
          ))
        )

        const partsChunk = yield* LanguageModel.streamText({ prompt: "test" }).pipe(
          Stream.runCollect,
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(layer)
        )

        const parts = Array.from(partsChunk)

        assert.isTrue(parts.some((part) => part.type === "response-metadata"))

        const finish = parts.find((part) => part.type === "finish")
        assert.isDefined(finish)
        if (finish?.type === "finish") {
          assert.strictEqual(finish.reason, "stop")
        }
      }))

    it.effect("streams undeclared tool calls when tool call validation is deferred", () =>
      Effect.gen(function*() {
        const client = makeHttpClient((request) =>
          Effect.succeed(sseResponse(request, [
            {
              id: "chatcmpl_undeclared",
              object: "chat.completion.chunk",
              model: "gpt-4o-mini",
              created: 1,
              choices: [{
                index: 0,
                delta: {
                  tool_calls: [{
                    index: 0,
                    id: "call_1",
                    type: "function",
                    function: { name: "Write", arguments: JSON.stringify({ path: "a" }) }
                  }]
                },
                finish_reason: "tool_calls"
              }]
            },
            "[DONE]"
          ]))
        )

        const parts = yield* LanguageModel.streamText({
          prompt: "use the tools",
          toolkit: TestToolkit,
          disableToolCallResolution: true,
          toolCallValidation: "deferred"
        }).pipe(
          Stream.runCollect,
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(TestToolkitLayer),
          Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
          Effect.provideService(HttpClient.HttpClient, client)
        )

        assert.deepStrictEqual(
          parts.filter((part) => part.type === "tool-call").map(({ name, params }) => ({ name, params })),
          [{ name: "Write", params: { path: "a" } }]
        )
      }))

    it.effect("emits text when streamed tool_calls is null", () =>
      Effect.gen(function*() {
        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(sseResponse(request, [
                {
                  id: "chatcmpl_nullable_tool_calls",
                  object: "chat.completion.chunk",
                  model: "inception/mercury-2",
                  created: 1,
                  choices: [{
                    index: 0,
                    delta: {
                      content: "Hello",
                      role: "assistant",
                      tool_calls: null
                    },
                    finish_reason: null
                  }]
                },
                "[DONE]"
              ]))
            )
          ))
        )

        const partsChunk = yield* LanguageModel.streamText({ prompt: "test" }).pipe(
          Stream.runCollect,
          Effect.provide(OpenAiLanguageModel.model("inception/mercury-2")),
          Effect.provide(layer)
        )

        const text = Array.from(partsChunk)
          .filter((part) => part.type === "text-delta")
          .map((part) => part.delta)
          .join("")

        assert.strictEqual(text, "Hello")
      }))

    it.effect("preserves streamed text and tool args with nullable delta fields", () =>
      Effect.gen(function*() {
        const extraContent = { google: { thought_signature: "signature-1" } }
        const chunk = (delta: Record<string, unknown>) => ({
          id: "chatcmpl_nullable_delta_fields",
          object: "chat.completion.chunk",
          model: "gpt-4o-mini",
          created: 1,
          choices: [{ index: 0, delta, finish_reason: null }]
        })

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(sseResponse(request, [
                chunk({ content: "Hello", role: null }),
                chunk({
                  tool_calls: [{
                    index: 0,
                    id: "call_1",
                    type: "function",
                    extra_content: extraContent,
                    function: { name: "TestTool", arguments: "" }
                  }]
                }),
                chunk({
                  tool_calls: [{
                    index: 0,
                    id: null,
                    extra_content: null,
                    function: { name: null, arguments: "{\"in" }
                  }]
                }),
                chunk({
                  tool_calls: [{ index: 0, id: null, function: { name: null, arguments: "put\":\"hel" } }]
                }),
                chunk({
                  tool_calls: [{ index: 0, id: null, function: { name: null, arguments: "lo\"}" } }]
                }),
                {
                  id: "chatcmpl_nullable_delta_fields",
                  object: "chat.completion.chunk",
                  model: "gpt-4o-mini",
                  created: 1,
                  choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }]
                },
                "[DONE]"
              ]))
            )
          ))
        )

        const partsChunk = yield* LanguageModel.streamText({
          prompt: "use the tool",
          toolkit: TestToolkit,
          disableToolCallResolution: true
        }).pipe(
          Stream.runCollect,
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(TestToolkitLayer),
          Effect.provide(layer)
        )

        const parts = globalThis.Array.from(partsChunk)
        const text = parts
          .filter((part) => part.type === "text-delta")
          .map((part) => part.delta)
          .join("")
        const toolCall = parts.find((part) => part.type === "tool-call")

        assert.strictEqual(text, "Hello")
        assert.isDefined(toolCall)
        if (toolCall?.type !== "tool-call") {
          return
        }
        assert.strictEqual(toolCall.id, "call_1")
        assert.deepStrictEqual(toolCall.params, { input: "hello" })
        assert.deepStrictEqual(toolCall.metadata["openai-compat"] as unknown, { itemId: "call_1", extraContent })
      }))

    it.effect("decodes streamed tool call params with the OpenAI codec", () =>
      Effect.gen(function*() {
        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(sseResponse(request, [
                {
                  id: "chatcmpl_record_1",
                  object: "chat.completion.chunk",
                  model: "gpt-4o-mini",
                  created: 1,
                  choices: [{
                    index: 0,
                    delta: {
                      tool_calls: [{
                        index: 0,
                        id: "call_record_1",
                        type: "function",
                        function: {
                          name: "RecordTool",
                          arguments: JSON.stringify({ env: [{ 0: "PATH", 1: "/usr/bin" }] })
                        }
                      }]
                    },
                    finish_reason: "tool_calls"
                  }]
                },
                "[DONE]"
              ]))
            )
          ))
        )

        const partsChunk = yield* LanguageModel.streamText({
          prompt: "read the environment",
          toolkit: RecordToolkit,
          disableToolCallResolution: true
        }).pipe(
          Stream.runCollect,
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(RecordToolkitLayer),
          Effect.provide(layer)
        )

        const toolCall = globalThis.Array.from(partsChunk).find((part) => part.type === "tool-call")
        assert.isDefined(toolCall)
        if (toolCall?.type !== "tool-call") {
          return
        }
        assert.deepStrictEqual(toolCall.params, { env: { PATH: "/usr/bin" } })
      }))

    it.effect("maps local shell stream tool calls to local_shell call outputs", () =>
      Effect.gen(function*() {
        const capturedRequests = yield* Ref.make<ReadonlyArray<HttpClientRequest.HttpClientRequest>>([])
        const requestCount = yield* Ref.make(0)

        const httpClient = HttpClient.makeWith(
          Effect.fnUntraced(function*(requestEffect) {
            const request = yield* requestEffect
            yield* Ref.update(capturedRequests, (requests) => [...requests, request])
            const index = yield* Ref.getAndUpdate(requestCount, (value) => value + 1)

            if (index === 0) {
              return sseResponse(request, [makeLocalShellChunk(), "[DONE]"])
            }

            return jsonResponse(request, makeChatCompletion())
          }),
          Effect.succeed as HttpClient.HttpClient.Preprocess<HttpClientError.HttpClientError, never>
        )

        const layer = OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(HttpClient.HttpClient, httpClient))
        )

        const toolkit = Toolkit.make(CompatLocalShellTool({}))
        const toolkitLayer = toolkit.toLayer({
          CompatLocalShell: () => Effect.succeed("done")
        })

        const partsChunk = yield* LanguageModel.streamText({
          prompt: "Run pwd",
          toolkit,
          disableToolCallResolution: true
        }).pipe(
          Stream.runCollect,
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
          Effect.provide(toolkitLayer),
          Effect.provide(layer)
        )

        const toolCall = globalThis.Array.from(partsChunk).find((part) => part.type === "tool-call")
        assert.isDefined(toolCall)
        if (toolCall?.type !== "tool-call") {
          return
        }

        assert.strictEqual(toolCall.name, "CompatLocalShell")
        assert.deepStrictEqual(toolCall.params, { action: localShellAction })

        yield* LanguageModel.generateText({
          prompt: Prompt.make([
            { role: "user", content: "Run pwd" },
            {
              role: "assistant",