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

import { type Generated, OpenAiClient, OpenAiLanguageModel, OpenAiSchema, OpenAiTool } from "@effect/ai-openai"
import { assert, describe, it } from "@effect/vitest"
import { assertTrue, deepStrictEqual, strictEqual } from "@effect/vitest/utils"
import { Array, Context, Effect, Layer, Redacted, Ref, Schema, SchemaGetter, Stream } from "effect"
import { AiError, LanguageModel, Prompt, Response as AiResponse, Tool, Toolkit } from "effect/ai"
import { HttpClient, type HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http"

const webSearchFailures = [
  { tool: OpenAiTool.WebSearch({}), status: "failed" },
  { tool: OpenAiTool.WebSearch({}), status: "incomplete" },
  { tool: OpenAiTool.WebSearchPreview({}), status: "searching" }
] as const

const fileSearchOutcomes = [
  { status: "completed", isFailure: false, results: undefined },
  { status: "failed", isFailure: true, results: null },
  { status: "incomplete", isFailure: true, results: [{ file_id: "file_123", text: "Matching text" }] }
] as const

describe("OpenAiLanguageModel", () => {
  describe("make", () => {
    it.effect("sends correct model in request", () =>
      Effect.gen(function*() {
        const result = yield* LanguageModel.generateText({ prompt: "test" }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini"))
        )

        const metadata = result.content.find((part) => part.type === "response-metadata")

        strictEqual(metadata?.modelId, "gpt-4o-mini")
      }).pipe(Effect.provide(makeTestLayer())))

    it.effect("sends custom model string in request", () =>
      Effect.gen(function*() {
        const result = yield* LanguageModel.generateText({ prompt: "test" }).pipe(
          Effect.provide(OpenAiLanguageModel.model("ft:gpt-4o-mini:custom"))
        )

        const metadata = result.content.find((part) => part.type === "response-metadata")
        strictEqual(metadata?.modelId, "ft:gpt-4o-mini:custom")
      }).pipe(Effect.provide(makeTestLayer({ body: { model: "ft:gpt-4o-mini:custom" as any } }))))
  })

  describe("web search sources", () => {
    it.effect.each(["generateText", "streamText"] as const)(
      "preserves URL and API sources with %s",
      (method) =>
        Effect.gen(function*() {
          const sources = [
            { type: "url", url: "https://example.com/weather" },
            { type: "api", name: "oai-weather" }
          ] as const
          const action = { type: "search", query: "weather in London", sources } as const
          const item = makeWebSearchCall({ action })
          const event = { type: "response.output_item.done", sequence_number: 1, output_index: 0, item }
          const body = method === "generateText"
            ? JSON.stringify(makeDefaultResponse({ output: [item] }))
            : `data: ${JSON.stringify(event)}\n\n`
          const client = makeRawResponseClient(
            body,
            method === "generateText" ? "application/json" : "text/event-stream"
          )
          const options = { prompt: "Weather in London", toolkit: Toolkit.make(OpenAiTool.WebSearch({})) }
          const parts = yield* Effect.gen(function*() {
            if (method === "generateText") {
              const response = yield* LanguageModel.generateText(options)
              return response.content
            }
            return yield* LanguageModel.streamText(options).pipe(Stream.runCollect)
          }).pipe(
            Effect.provide(OpenAiLanguageModel.model("gpt-5.6")),
            Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
            Effect.provideService(HttpClient.HttpClient, client)
          )

          const calls = parts.filter((part) => part.type === "tool-call")
          deepStrictEqual(calls.map((part) => part.params), [{ action }])

          const results = parts.filter((part) => part.type === "tool-result")
          deepStrictEqual(results.map((part) => part.result), [{ action, status: "completed" }])
        })
    )
  })

  describe("web search find_in_page", () => {
    it.effect.each(["generateText", "streamText"] as const)(
      "preserves actions without a URL with %s",
      (method) =>
        Effect.gen(function*() {
          const action = { type: "find_in_page", pattern: "og:image" } as const
          const item = { type: "web_search_call", id: "ws_123", status: "completed", action }
          const event = { type: "response.output_item.done", sequence_number: 1, output_index: 0, item }
          const body = method === "generateText"
            ? JSON.stringify({ ...makeDefaultResponse(), output: [item] })
            : `data: ${JSON.stringify(event)}\n\n`
          const client = makeRawResponseClient(
            body,
            method === "generateText" ? "application/json" : "text/event-stream"
          )
          const options = { prompt: "Search the page", toolkit: Toolkit.make(OpenAiTool.WebSearch({})) }
          const parts = yield* Effect.gen(function*() {
            if (method === "generateText") return (yield* LanguageModel.generateText(options)).content
            return yield* LanguageModel.streamText(options).pipe(Stream.runCollect)
          }).pipe(
            Effect.provide(OpenAiLanguageModel.model("gpt-5.4")),
            Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
            Effect.provideService(HttpClient.HttpClient, client)
          )

          deepStrictEqual(parts.filter((part) => part.type === "tool-call").map((part) => part.params), [{ action }])
          deepStrictEqual<unknown>(
            parts.filter((part) => part.type === "tool-result").map((part) => part.result),
            [{ action, status: "completed" }]
          )
        })
    )
  })

  describe("web search without an action", () => {
    it.effect.each(
      [
        { method: "streamText", status: "incomplete", isFailure: true },
        { method: "generateText", status: "incomplete", isFailure: true },
        { method: "generateText", status: "completed", isFailure: false }
      ] as const
    )("preserves omitted actions for $status with $method", ({ method, status, isFailure }) =>
      Effect.gen(function*() {
        const item: Generated.WebSearchToolCall = { type: "web_search_call", id: "ws_123", status }
        const event = { type: "response.output_item.done", sequence_number: 1, output_index: 0, item }
        const body = method === "generateText"
          ? JSON.stringify(makeDefaultResponse({ output: [item] }))
          : `data: ${JSON.stringify(event)}\n\n`
        const client = makeRawResponseClient(body, method === "generateText" ? "application/json" : "text/event-stream")
        const options = { prompt: "Search the web", toolkit: Toolkit.make(OpenAiTool.WebSearch({})) }
        const parts = yield* Effect.gen(function*() {
          if (method === "generateText") return (yield* LanguageModel.generateText(options)).content
          return yield* LanguageModel.streamText(options).pipe(Stream.runCollect)
        }).pipe(
          Effect.provide(OpenAiLanguageModel.model("gpt-6-luna")),
          Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
          Effect.provideService(HttpClient.HttpClient, client)
        )

        deepStrictEqual(
          parts.filter((part) => part.type === "tool-call" || part.type === "tool-result")
            .map((part) => ({
              type: part.type,
              id: part.id,
              providerExecuted: part.providerExecuted,
              ...(part.type === "tool-call"
                ? { params: part.params }
                : { result: part.result, isFailure: part.isFailure })
            })),
          [
            { type: "tool-call", id: "ws_123", providerExecuted: true, params: {} },
            { type: "tool-result", id: "ws_123", providerExecuted: true, result: { status }, isFailure }
          ]
        )
      }))

    it.effect("rejects null and malformed actions when present", () =>
      Effect.forEach([null, { type: "find_in_page", url: "https://example.com", pattern: null }], (action) => {
        const event = {
          type: "response.output_item.done",
          sequence_number: 1,
          output_index: 0,
          item: { type: "web_search_call", id: "ws_123", status: "completed", action }
        }
        const client = makeRawResponseClient(`data: ${JSON.stringify(event)}\n\n`, "text/event-stream")
        return LanguageModel.streamText({ prompt: "Search", toolkit: Toolkit.make(OpenAiTool.WebSearch({})) }).pipe(
          Stream.runCollect,
          Effect.flip,
          Effect.tap((error) => {
            assert(AiError.isAiError(error))
            strictEqual(error.reason._tag, "InvalidOutputError")
            return Effect.void
          }),
          Effect.provide(OpenAiLanguageModel.model("gpt-6-luna")),
          Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
          Effect.provideService(HttpClient.HttpClient, client)
        )
      }))
  })

  describe("generateText", () => {
    describe("message preparation", () => {
      it.effect("forwards prompt cache, safety configuration and text breakpoints", () =>
        Effect.gen(function*() {
          const breakpoint = { mode: "explicit" } as const
          yield* LanguageModel.generateText({
            prompt: Prompt.make([
              Prompt.systemMessage({
                content: "Stable instructions",
                options: { openai: { promptCacheBreakpoint: breakpoint } }
              }),
              Prompt.userMessage({
                content: [Prompt.textPart({
                  text: "Stable context",
                  options: { openai: { promptCacheBreakpoint: breakpoint } }
                })]
              })
            ])
          }).pipe(
            Effect.provide(OpenAiLanguageModel.model("gpt-5.6", {
              prompt_cache_key: "assistant:v1",
              prompt_cache_options: { mode: "explicit", ttl: "30m", comparison_response_id: "resp_baseline" },
              prompt_cache_retention: "24h",
              safety_identifier: "user-hash-123"
            }))
          )

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

          strictEqual(body.prompt_cache_key, "assistant:v1")
          strictEqual(body.prompt_cache_retention, "24h")
          strictEqual(body.safety_identifier, "user-hash-123")
          deepStrictEqual(body.prompt_cache_options, {
            mode: "explicit",
            ttl: "30m",
            comparison_response_id: "resp_baseline"
          })
          deepStrictEqual(body.input, [{
            role: "developer",
            content: [{
              type: "input_text",
              text: "Stable instructions",
              prompt_cache_breakpoint: breakpoint
            }]
          }, {
            role: "user",
            content: [{
              type: "input_text",
              text: "Stable context",
              prompt_cache_breakpoint: breakpoint
            }]
          }])
        }).pipe(Effect.provide(makeTestLayer({ body: { model: "gpt-5.6" as any } }))))

      it.effect("forwards image and file breakpoints", () =>
        Effect.gen(function*() {
          const breakpoint = { mode: "explicit" } as const
          yield* LanguageModel.generateText({
            prompt: Prompt.make([
              Prompt.userMessage({
                content: [
                  Prompt.filePart({
                    mediaType: "image/png",
                    data: new URL("https://example.com/image.png"),
                    options: { openai: { promptCacheBreakpoint: breakpoint } }
                  }),
                  Prompt.filePart({
                    mediaType: "application/pdf",
                    data: new URL("https://example.com/document.pdf"),
                    options: { openai: { promptCacheBreakpoint: breakpoint } }
                  })
                ]
              })
            ])
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-5.6")))

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

          deepStrictEqual(body.input, [{
            role: "user",
            content: [{
              type: "input_image",
              image_url: "https://example.com/image.png",
              detail: "auto",
              prompt_cache_breakpoint: breakpoint
            }, {
              type: "input_file",
              file_url: "https://example.com/document.pdf",
              prompt_cache_breakpoint: breakpoint
            }]
          }])
        }).pipe(Effect.provide(makeTestLayer({ body: { model: "gpt-5.6" as any } }))))

      it.effect("forwards implicit prompt cache mode without text breakpoints", () =>
        Effect.gen(function*() {
          yield* LanguageModel.generateText({ prompt: "Stable context" }).pipe(
            Effect.provide(OpenAiLanguageModel.model("gpt-5.6", {
              prompt_cache_options: { mode: "implicit" }
            }))
          )

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

          deepStrictEqual(body.prompt_cache_options, { mode: "implicit" })
          deepStrictEqual(body.input, [{
            role: "user",
            content: [{ type: "input_text", text: "Stable context" }]
          }])
        }).pipe(Effect.provide(makeTestLayer({ body: { model: "gpt-5.6" as any } }))))

      describe("system messages", () => {
        it.effect("uses system role for standard models", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "system", content: "You are a helpful assistant" },
                { role: "user", content: "Hello" }
              ])
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

            const systemMessage = body.input.find((m: any) => m.role === "system")
            assert.isDefined(systemMessage)
            deepStrictEqual(systemMessage.content, [{
              type: "input_text",
              text: "You are a helpful assistant"
            }])
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("uses developer role for reasoning models", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "system", content: "You are a helpful assistant" },
                { role: "user", content: "Hello" }
              ])
            }).pipe(Effect.provide(OpenAiLanguageModel.model("o1")))

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

            const devMessage = body.input.find((m: any) => m.role === "developer")
            assert.isDefined(devMessage)
            deepStrictEqual(devMessage.content, [{
              type: "input_text",
              text: "You are a helpful assistant"
            }])
          }).pipe(Effect.provide(makeTestLayer({ body: { model: "o1" } }))))

        it.effect("uses developer role for gpt-5 models", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "system", content: "You are a helpful assistant" },
                { role: "user", content: "Hello" }
              ])
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-5")))

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

            const devMessage = body.input.find((m: any) => m.role === "developer")
            assert.isDefined(devMessage)
          }).pipe(Effect.provide(makeTestLayer({ body: { model: "gpt-5" } }))))

        it.effect("uses developer role for o3 models", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "system", content: "You are a helpful assistant" },
                { role: "user", content: "Hello" }
              ])
            }).pipe(Effect.provide(OpenAiLanguageModel.model("o3-mini")))

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

            const devMessage = body.input.find((m: any) => m.role === "developer")
            assert.isDefined(devMessage)
          }).pipe(Effect.provide(makeTestLayer({ body: { model: "o3-mini" } }))))
      })

      describe("user messages", () => {
        it.effect("converts text parts to input_text", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: "Hello world"
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

            const userMessage = body.input.find((m: any) => m.role === "user")
            assert.isDefined(userMessage)
            deepStrictEqual(userMessage.content, [{ type: "input_text", text: "Hello world" }])
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("handles image URLs", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([{
                role: "user",
                content: [
                  Prompt.filePart({
                    mediaType: "image/png",
                    data: new URL("https://example.com/image.png")
                  })
                ]
              }])
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

            const userMessage = body.input.find((m: any) => m.role === "user")
            deepStrictEqual(userMessage.content, [{
              type: "input_image",
              image_url: "https://example.com/image.png",
              detail: "auto"
            }])
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("handles image strings", () =>
          Effect.gen(function*() {
            const base64 = "iVBORw0KGgo="
            const dataUrl = `data:image/png;base64,${base64}`
            const upperCaseDataUrl = `DATA:image/png;base64,${base64}`
            const url = "https://example.com/image.png"

            yield* LanguageModel.generateText({
              prompt: Prompt.make([Prompt.userMessage({
                content: [base64, dataUrl, upperCaseDataUrl, url].map((data) =>
                  Prompt.filePart({ mediaType: "image/png", data })
                )
              })])
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

            assert.deepStrictEqual(body.input, [{
              role: "user",
              content: [
                { type: "input_image", image_url: `data:image/png;base64,${base64}`, detail: "auto" },
                { type: "input_image", image_url: dataUrl, detail: "auto" },
                { type: "input_image", image_url: upperCaseDataUrl, detail: "auto" },
                { type: "input_image", image_url: url, detail: "auto" }
              ]
            }])
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("handles image with custom detail level", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([{
                role: "user",
                content: [
                  Prompt.filePart({
                    mediaType: "image/png",
                    data: new URL("https://example.com/image.png"),
                    options: { openai: { imageDetail: "high" } }
                  })
                ]
              }])
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

            const userMessage = body.input.find((m: any) => m.role === "user")
            strictEqual(userMessage.content[0].detail, "high")
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("handles image file IDs with configured prefixes", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([{
                role: "user",
                content: [
                  Prompt.filePart({
                    mediaType: "image/png",
                    data: "file-abc123"
                  })
                ]
              }])
            }).pipe(
              Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", {
                fileIdPrefixes: ["file-"]
              }))
            )

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

            const userMessage = body.input.find((m: any) => m.role === "user")
            deepStrictEqual(userMessage.content, [{
              type: "input_image",
              file_id: "file-abc123",
              detail: "auto"
            }])
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("handles image base64 data", () =>
          Effect.gen(function*() {
            const imageData = new Uint8Array([137, 80, 78, 71]) // PNG magic bytes

            yield* LanguageModel.generateText({
              prompt: Prompt.make([{
                role: "user",
                content: [
                  Prompt.filePart({
                    mediaType: "image/png",
                    data: imageData
                  })
                ]
              }])
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

            const userMessage = body.input.find((m: any) => m.role === "user")
            assert.isTrue(userMessage.content[0].image_url.startsWith("data:image/png;base64,"))
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("handles PDF URLs", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([{
                role: "user",
                content: [
                  Prompt.filePart({
                    mediaType: "application/pdf",
                    data: new URL("https://example.com/document.pdf")
                  })
                ]
              }])
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

            const userMessage = body.input.find((m: any) => m.role === "user")
            deepStrictEqual(userMessage.content, [{
              type: "input_file",
              file_url: "https://example.com/document.pdf"
            }])
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("handles PDF base64 data with filename", () =>
          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",
                    data: pdfData,
                    fileName: "document.pdf"
                  })
                ]
              }])
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

            const userMessage = body.input.find((m: any) => m.role === "user")
            strictEqual(userMessage.content[0].type, "input_file")
            strictEqual(userMessage.content[0].filename, "document.pdf")
            assert.isTrue(userMessage.content[0].file_data.startsWith("data:application/pdf;base64,"))
          }).pipe(Effect.provide(makeTestLayer())))

        const pdfStringCases = [
          {
            label: "base64",
            data: "JVBERi0xLjcK",
            content: {
              type: "input_file",
              filename: "part-0.pdf",
              file_data: "data:application/pdf;base64,JVBERi0xLjcK"
            }
          },
          {
            label: "data URL",
            data: "data:application/pdf;base64,JVBERi0xLjcK",
            content: {
              type: "input_file",
              filename: "part-0.pdf",
              file_data: "data:application/pdf;base64,JVBERi0xLjcK"
            }
          },
          {
            label: "HTTPS URL",
            data: "https://example.com/document.pdf",
            content: { type: "input_file", file_url: "https://example.com/document.pdf" }
          }
        ]

        for (const { content, data, label } of pdfStringCases) {
          it.effect(`handles PDF ${label} strings`, () =>
            Effect.gen(function*() {
              yield* LanguageModel.generateText({
                prompt: Prompt.make([{
                  role: "user",
                  content: [Prompt.filePart({ mediaType: "application/pdf", data })]
                }])
              }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

              const userMessage = body.input.find((m: any) => m.role === "user")
              deepStrictEqual(userMessage.content, [content])
            }).pipe(Effect.provide(makeTestLayer())))
        }
      })

      describe("assistant messages", () => {
        it.effect("converts text parts to message output", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "user", content: "Hello" },
                {
                  role: "assistant",
                  content: [Prompt.textPart({ text: "Hi there!" })]
                },
                { role: "user", content: "How are you?" }
              ])
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

            const assistantMessage = body.input.find((m: any) => m.type === "message" && m.role === "assistant")
            assert.isDefined(assistantMessage)
            strictEqual(assistantMessage.content[0].type, "output_text")
            strictEqual(assistantMessage.content[0].text, "Hi there!")
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("converts reasoning parts", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "user", content: "Think step by step" },
                {
                  role: "assistant",
                  content: [
                    Prompt.reasoningPart({
                      text: "Let me think...",
                      options: { openai: { itemId: "reasoning_123" } }
                    })
                  ]
                },
                { role: "user", content: "Continue" }
              ])
            }).pipe(Effect.provide(OpenAiLanguageModel.model("o1")))

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

            const reasoningItem = body.input.find((m: any) => m.type === "reasoning")
            assert.isDefined(reasoningItem)
            strictEqual(reasoningItem.id, "reasoning_123")
          }).pipe(Effect.provide(makeTestLayer({ body: { model: "o1" } }))))

        it.effect("replays encrypted reasoning from response parts", () =>
          Effect.gen(function*() {
            const history = Prompt.fromResponseParts([
              AiResponse.makePart("reasoning-start", {
                id: "reasoning_123:0",
                metadata: { openai: { itemId: "reasoning_123" } }
              }),
              AiResponse.makePart("reasoning-delta", {
                id: "reasoning_123:0",
                delta: "Let me think..."
              }),
              AiResponse.makePart("reasoning-end", {
                id: "reasoning_123:0",
                metadata: {
                  openai: {
                    itemId: "reasoning_123",
                    encryptedContent: "encrypted-reasoning"
                  }
                }
              })
            ])

            yield* LanguageModel.generateText({
              prompt: Prompt.concat(history, Prompt.make("Continue"))
            }).pipe(Effect.provide(OpenAiLanguageModel.model("o1")))

            const requests = yield* MockHttpClient.requests
            const body = yield* getRequestBody(requests[0])
            const reasoningItem = body.input.find((item: any) => item.type === "reasoning")

            assert.isDefined(reasoningItem)
            deepStrictEqual(reasoningItem, {
              type: "reasoning",
              id: "reasoning_123",
              summary: [{ type: "summary_text", text: "Let me think..." }],
              encrypted_content: "encrypted-reasoning"
            })
          }).pipe(Effect.provide(makeTestLayer({ body: { model: "o1" } }))))

        it.effect("replays encrypted reasoning statelessly for an unknown model", () =>
          Effect.gen(function*() {
            const history = Prompt.fromResponseParts([
              AiResponse.makePart("reasoning-start", {
                id: "reasoning_123:0",
                metadata: { openai: { itemId: "reasoning_123" } }
              }),
              AiResponse.makePart("reasoning-delta", {
                id: "reasoning_123:0",
                delta: "Let me think..."
              }),
              AiResponse.makePart("reasoning-end", {
                id: "reasoning_123:0",
                metadata: {
                  openai: {
                    itemId: "reasoning_123",
                    encryptedContent: "encrypted-reasoning"
                  }
                }
              })
            ])

            yield* LanguageModel.generateText({
              prompt: Prompt.concat(history, Prompt.make("Continue"))
            }).pipe(Effect.provide(OpenAiLanguageModel.model("custom-model", { store: false })))

            const requests = yield* MockHttpClient.requests
            const body = yield* getRequestBody(requests[0])
            const reasoningItem = body.input.find((item: any) => item.type === "reasoning")

            assert.isDefined(reasoningItem)
            deepStrictEqual(reasoningItem, {
              type: "reasoning",
              id: "reasoning_123",
              summary: [{ type: "summary_text", text: "Let me think..." }],
              encrypted_content: "encrypted-reasoning"
            })
          }).pipe(Effect.provide(makeTestLayer({ body: { model: "custom-model" } }))))

        it.effect("serializes stored assistant history according to item reference config", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: storedHistoryPrompt,
              toolkit: TestToolkit,
              disableToolCallResolution: true
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", { store: true })))

            yield* LanguageModel.generateText({
              prompt: storedHistoryPrompt,
              toolkit: TestToolkit,
              disableToolCallResolution: true
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", {
              store: true,
              useItemReferences: false
            })))

            const requests = yield* MockHttpClient.requests
            const referencedBody = yield* getRequestBody(requests[0])
            const inlineBody = yield* getRequestBody(requests[1])

            assert.deepStrictEqual(referencedBody.input, [
              { role: "user", content: [{ type: "input_text", text: "Question" }] },
              { type: "item_reference", id: "msg_1" },
              { type: "item_reference", id: "rs_1" },
              { type: "item_reference", id: "fc_1" },
              { type: "function_call_output", call_id: "call_1", output: "{\"output\":\"result\"}" },
              { role: "user", content: [{ type: "input_text", text: "Continue" }] }
            ])

            assert.deepStrictEqual(inlineBody.input, [
              { role: "user", content: [{ type: "input_text", text: "Question" }] },
              {
                id: "msg_1",
                type: "message",
                role: "assistant",
                status: "completed",
                content: [{
                  type: "output_text",
                  text: "Answer",
                  annotations: [],
                  logprobs: []
                }]
              },
              {
                type: "reasoning",
                id: "rs_1",
                summary: [{ type: "summary_text", text: "Thinking" }],
                encrypted_content: "encrypted-reasoning"
              },
              {
                type: "function_call",
                name: "TestTool",
                call_id: "call_1",
                arguments: "{\"input\":\"value\"}",
                id: "fc_1"
              },
              { type: "function_call_output", call_id: "call_1", output: "{\"output\":\"result\"}" },
              { role: "user", content: [{ type: "input_text", text: "Continue" }] }
            ])
            strictEqual(inlineBody.useItemReferences, undefined)
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("replays matched provider-executed history inline", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: providerExecutedHistoryPrompt,
              toolkit: Toolkit.make(OpenAiTool.WebSearch({})),
              disableToolCallResolution: true
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", {
              store: true,
              useItemReferences: false
            })))

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

            assert.deepStrictEqual(body.input, [
              { role: "user", content: [{ type: "input_text", text: "Search" }] },
              {
                type: "web_search_call",
                id: "ws_1",
                status: "completed",
                action: { type: "search", query: "Effect TypeScript" }
              },
              { role: "user", content: [{ type: "input_text", text: "Continue" }] }
            ])
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("replays web search history with an omitted action", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "user", content: "Search" },
                {
                  role: "assistant",
                  content: [
                    Prompt.toolCallPart({ id: "ws_1", name: "OpenAiWebSearch", params: {}, providerExecuted: true }),
                    Prompt.toolResultPart({
                      id: "ws_1",
                      name: "OpenAiWebSearch",
                      providerExecuted: true,
                      isFailure: true,
                      result: { status: "incomplete" }
                    })
                  ]
                },
                { role: "user", content: "Continue" }
              ]),
              toolkit: Toolkit.make(OpenAiTool.WebSearch({})),
              disableToolCallResolution: true
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-6-luna", {
              store: true,
              useItemReferences: false
            })))

            const body = yield* getRequestBody((yield* MockHttpClient.requests)[0])
            deepStrictEqual(body.input?.[1], { type: "web_search_call", id: "ws_1", status: "incomplete" })
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("fails locally when provider-executed history cannot be replayed inline", () =>
          Effect.gen(function*() {
            const cases = [
              providerExecutedCall,
              providerExecutedResult
            ] as const
            yield* Effect.forEach(cases, (part) =>
              LanguageModel.generateText({
                prompt: Prompt.make([
                  { role: "user", content: "Search" },
                  {
                    role: "assistant",
                    content: [part]
                  },
                  { role: "user", content: "Continue" }
                ]),
                toolkit: Toolkit.make(OpenAiTool.WebSearch({})),
                disableToolCallResolution: true
              }).pipe(
                Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini", {
                  store: true,
                  useItemReferences: false
                })),
                Effect.flip,
                Effect.tap((error) =>
                  Effect.sync(() => {
                    strictEqual(error.reason._tag, "InvalidRequestError")
                    if (error.reason._tag === "InvalidRequestError") {
                      assert.include(error.reason.description, "OpenAiWebSearch")
                      assert.include(error.reason.description, "ws_1")
                    }
                  })
                )
              ))

            strictEqual((yield* MockHttpClient.requests).length, 0)
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("converts tool call parts to function_call", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "user", content: "Use the tool" },
                {
                  role: "assistant",
                  content: [
                    Prompt.toolCallPart({
                      id: "call_abc",
                      name: "TestTool",
                      params: { input: "test" },
                      providerExecuted: false
                    })
                  ]
                },
                {
                  role: "tool",
                  content: [
                    Prompt.toolResultPart({
                      id: "call_abc",
                      name: "TestTool",
                      isFailure: false,
                      result: { output: "result" },
                      providerExecuted: false
                    })
                  ]
                }
              ]),
              toolkit: TestToolkit
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

            const functionCall = body.input.find((m: any) => m.type === "function_call")
            assert.isDefined(functionCall)
            strictEqual(functionCall.name, "TestTool")
            strictEqual(functionCall.call_id, "call_abc")
          }).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))
      })

      describe("tool messages", () => {
        it.effect("converts tool results to function_call_output", () =>
          Effect.gen(function*() {
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "user", content: "Use the tool" },
                {
                  role: "assistant",
                  content: [
                    Prompt.toolCallPart({
                      id: "call_abc",
                      name: "TestTool",
                      params: { input: "test" },
                      providerExecuted: false
                    })
                  ]
                },
                {
                  role: "tool",
                  content: [
                    Prompt.toolResultPart({
                      id: "call_abc",
                      name: "TestTool",
                      isFailure: false,
                      result: { output: "result" },
                      providerExecuted: false
                    })
                  ]
                }
              ]),
              toolkit: TestToolkit
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

            const toolOutput = body.input.find((m: any) => m.type === "function_call_output")
            assert.isDefined(toolOutput)
            strictEqual(toolOutput.call_id, "call_abc")
            strictEqual(toolOutput.output, JSON.stringify({ output: "result" }))
          }).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))

        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: "TestTool",
                      params: { input: "test" },
                      providerExecuted: false
                    })
                  ]
                },
                {
                  role: "tool",
                  content: [
                    Prompt.toolResultPart({
                      id: "call_text",
                      name: "TestTool",
                      isFailure: false,
                      result: "PLAIN_TEXT_SENTINEL\n",
                      providerExecuted: false
                    })
                  ]
                }
              ]),
              toolkit: TestToolkit
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

            const requests = yield* MockHttpClient.requests
            const body = yield* getRequestBody(requests[0])
            const toolOutput = body.input.find((item: any) => item.type === "function_call_output")

            assert.isDefined(toolOutput)
            strictEqual(toolOutput.output, "PLAIN_TEXT_SENTINEL\n")
          }).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))

        const png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVR4nGP4DwQACfsD/fteaysAAAAASUVORK5CYII="
        const modelOutputCases = [
          {
            label: "as native input items",
            modelOutput: [
              Prompt.textPart({ text: "Screenshot" }),
              Prompt.filePart({ mediaType: "image/png", data: png })
            ],
            output: [
              { type: "input_text", text: "Screenshot" },
              { type: "input_image", image_url: `data:image/png;base64,${png}` }
            ]
          },
          { label: "without the result when it is empty", modelOutput: [], output: "" }
        ]

        for (const { label, modelOutput, output } 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: "TestTool",
                        params: { input: "test" },
                        providerExecuted: false
                      })
                    ]
                  },
                  {
                    role: "tool",
                    content: [
                      Prompt.toolResultPart({
                        id: "call_image",
                        name: "TestTool",
                        isFailure: false,
                        result: { output: png },
                        modelOutput,
                        providerExecuted: false
                      })
                    ]
                  }
                ]),
                toolkit: TestToolkit
              }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

              const requests = yield* MockHttpClient.requests
              const body = yield* getRequestBody(requests[0])
              const toolOutput = body.input.find((item: any) => item.type === "function_call_output")

              strictEqual(toolOutput.call_id, "call_image")
              deepStrictEqual(
                Array.isArray(toolOutput.output)
                  ? toolOutput.output.map(({ detail: _, ...item }: any) => item)
                  : toolOutput.output,
                output
              )
            }).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))
        }

        it.effect("emits only the specialized output for apply_patch results", () =>
          Effect.gen(function*() {
            const toolkit = Toolkit.make(OpenAiTool.ApplyPatch({}))
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "user", content: "Apply a patch" },
                {
                  role: "assistant",
                  content: [Prompt.toolCallPart({
                    id: "call_apply_patch",
                    name: "OpenAiApplyPatch",
                    params: {
                      call_id: "call_apply_patch",
                      operation: { type: "delete_file", path: "old.ts" }
                    },
                    providerExecuted: false
                  })]
                },
                {
                  role: "tool",
                  content: [Prompt.toolResultPart({
                    id: "call_apply_patch",
                    name: "OpenAiApplyPatch",
                    isFailure: false,
                    result: { status: "completed", output: "deleted" },
                    providerExecuted: false
                  })]
                }
              ]),
              toolkit,
              disableToolCallResolution: true
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

            const requests = yield* MockHttpClient.requests
            const body = yield* getRequestBody(requests[0])
            const outputs = body.input.filter((item: any) =>
              item.call_id === "call_apply_patch" && item.type.endsWith("_output")
            )

            deepStrictEqual(outputs.map((item: any) => item.type), ["apply_patch_call_output"])
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("emits only the specialized output for shell results", () =>
          Effect.gen(function*() {
            const toolkit = Toolkit.make(OpenAiTool.Shell({}))
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "user", content: "Run a shell command" },
                {
                  role: "assistant",
                  content: [Prompt.toolCallPart({
                    id: "call_shell",
                    name: "OpenAiShell",
                    params: {
                      action: {
                        commands: ["echo hello"],
                        timeout_ms: null,
                        max_output_length: null
                      }
                    },
                    providerExecuted: false
                  })]
                },
                {
                  role: "tool",
                  content: [Prompt.toolResultPart({
                    id: "call_shell",
                    name: "OpenAiShell",
                    isFailure: false,
                    result: {
                      output: [{
                        stdout: "hello\n",
                        stderr: "",
                        outcome: { type: "exit", exit_code: 0 }
                      }]
                    },
                    providerExecuted: false
                  })]
                }
              ]),
              toolkit,
              disableToolCallResolution: true
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

            const requests = yield* MockHttpClient.requests
            const body = yield* getRequestBody(requests[0])
            const outputs = body.input.filter((item: any) =>
              item.call_id === "call_shell" && item.type.endsWith("_output")
            )

            deepStrictEqual(outputs.map((item: any) => item.type), ["shell_call_output"])
          }).pipe(Effect.provide(makeTestLayer())))

        it.effect("emits only the specialized output for local_shell results", () =>
          Effect.gen(function*() {
            const toolkit = Toolkit.make(OpenAiTool.LocalShell({}))
            yield* LanguageModel.generateText({
              prompt: Prompt.make([
                { role: "user", content: "Run a local shell command" },
                {
                  role: "assistant",
                  content: [Prompt.toolCallPart({
                    id: "call_local_shell",
                    name: "OpenAiLocalShell",
                    params: {
                      action: {
                        type: "exec",
                        command: ["echo", "hello"],
                        env: {}
                      }
                    },
                    providerExecuted: false
                  })]
                },
                {
                  role: "tool",
                  content: [Prompt.toolResultPart({
                    id: "call_local_shell",
                    name: "OpenAiLocalShell",
                    isFailure: false,
                    result: { output: "hello\n" },
                    providerExecuted: false
                  })]
                }
              ]),
              toolkit,
              disableToolCallResolution: true
            }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

            const requests = yield* MockHttpClient.requests
            const body = yield* getRequestBody(requests[0])
            const outputs = body.input.filter((item: any) =>
              item.call_id === "call_local_shell" && item.type.endsWith("_output")
            )

            deepStrictEqual(outputs.map((item: any) => item.type), ["local_shell_call_output"])
          }).pipe(Effect.provide(makeTestLayer())))
      })
    })

    describe("tool preparation", () => {
      it.effect("converts user-defined tools to function type", () =>
        Effect.gen(function*() {
          yield* LanguageModel.generateText({
            prompt: "Use the tool",
            toolkit: TestToolkit
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

          const tool = body.tools?.find((t: any) => t.type === "function")
          assert.isDefined(tool)
          strictEqual(tool.name, "TestTool")
          strictEqual(tool.description, "A test tool")
          strictEqual(tool.strict, true)
        }).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))

      it.effect("empty object on properties for empty parameters", () =>
        Effect.gen(function*() {
          const EmptyTool = Tool.make("EmptyParamsTool", {
            description: "Empty params tool",
            parameters: Tool.EmptyParams,
            success: Schema.String
          })
          const toolkit = Toolkit.make(EmptyTool)
          const toolkitLayer = toolkit.toLayer({
            EmptyParamsTool: () => Effect.succeed("ok")
          })

          yield* LanguageModel.generateText({
            prompt: "Use the tool",
            toolkit
          }).pipe(Effect.provide([OpenAiLanguageModel.model("gpt-4o-mini"), toolkitLayer]))

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

          const tool = body.tools?.find((t: any) => t.type === "function" && t.name === "EmptyParamsTool")
          assert.isDefined(tool)
          deepStrictEqual(tool.parameters, {
            type: "object",
            properties: {},
            additionalProperties: false
          })
        }).pipe(Effect.provide(makeTestLayer())))

      it.effect("converts dynamic tools to function type", () =>
        Effect.gen(function*() {
          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 the dynamic tool",
            toolkit: Toolkit.make(DynamicTool),
            disableToolCallResolution: true
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

          const tool = body.tools?.find((entry: any) => entry.type === "function" && entry.name === "DynamicTool")
          assert.isDefined(tool)
          strictEqual(tool.description, "A dynamic tool")
          deepStrictEqual(tool.parameters, inputSchema)
        }).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(OpenAiLanguageModel.model("gpt-4o-mini")), Effect.flip)

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

      it.effect("empty object on properties for empty parameters", () =>
        Effect.gen(function*() {
          const EmptyTool = Tool.make("EmptyParamsTool", {
            description: "Empty params tool",
            parameters: Tool.EmptyParams,
            success: Schema.String
          })
          const toolkit = Toolkit.make(EmptyTool)
          const toolkitLayer = toolkit.toLayer({
            EmptyParamsTool: () => Effect.succeed("ok")
          })

          yield* LanguageModel.generateText({
            prompt: "Use the tool",
            toolkit
          }).pipe(Effect.provide([OpenAiLanguageModel.model("gpt-4o-mini"), toolkitLayer]))

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

          const tool = body.tools?.find((t: any) => t.type === "function" && t.name === "EmptyParamsTool")
          assert.isDefined(tool)
          deepStrictEqual(tool.parameters, {
            type: "object",
            properties: {},
            additionalProperties: false
          })
        }).pipe(Effect.provide(makeTestLayer())))

      it.effect("handles tool choice auto", () =>
        Effect.gen(function*() {
          yield* LanguageModel.generateText({
            prompt: "Use the tool",
            toolkit: TestToolkit,
            toolChoice: "auto"
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

          strictEqual(body.tool_choice, "auto")
        }).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))

      it.effect("handles tool choice none", () =>
        Effect.gen(function*() {
          yield* LanguageModel.generateText({
            prompt: "Use the tool",
            toolkit: TestToolkit,
            toolChoice: "none"
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

          strictEqual(body.tool_choice, "none")
        }).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))

      it.effect("handles tool choice required", () =>
        Effect.gen(function*() {
          yield* LanguageModel.generateText({
            prompt: "Use the tool",
            toolkit: TestToolkit,
            toolChoice: "required"
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

          strictEqual(body.tool_choice, "required")
        }).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))

      it.effect("handles specific tool choice", () =>
        Effect.gen(function*() {
          yield* LanguageModel.generateText({
            prompt: "Use the tool",
            toolkit: TestToolkit,
            toolChoice: { tool: "TestTool" }
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

          deepStrictEqual(body.tool_choice, { type: "function", name: "TestTool" })
        }).pipe(Effect.provide([makeTestLayer(), TestToolkitLayer])))

      it.effect("adds code_interpreter tool", () =>
        Effect.gen(function*() {
          const toolkit = Toolkit.make(OpenAiTool.CodeInterpreter({ container: { type: "auto" } }))

          yield* LanguageModel.generateText({
            prompt: "Run some code",
            toolkit
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

          const tool = body.tools?.find((t: any) => t.type === "code_interpreter")
          assert.isDefined(tool)
        }).pipe(Effect.provide(makeTestLayer())))

      it.effect("adds web_search tool", () =>
        Effect.gen(function*() {
          const toolkit = Toolkit.make(OpenAiTool.WebSearch({}))

          yield* LanguageModel.generateText({
            prompt: "Search the web",
            toolkit
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

          const tool = body.tools?.find((t: any) => t.type === "web_search")
          assert.isDefined(tool)
        }).pipe(Effect.provide(makeTestLayer())))

      it.effect("adds file_search tool with vector store IDs", () =>
        Effect.gen(function*() {
          const toolkit = Toolkit.make(OpenAiTool.FileSearch({
            vector_store_ids: ["vs_123"]
          }))

          yield* LanguageModel.generateText({
            prompt: "Search files",
            toolkit
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

          const tool = body.tools?.find((t: any) => t.type === "file_search")
          assert.isDefined(tool)
          deepStrictEqual(tool.vector_store_ids, ["vs_123"])
        }).pipe(Effect.provide(makeTestLayer())))
    })

    describe("response format", () => {
      it.effect("uses text format by default", () =>
        Effect.gen(function*() {
          yield* LanguageModel.generateText({
            prompt: "Hello"
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

          strictEqual(body.text?.format?.type, "text")
        }).pipe(Effect.provide(makeTestLayer())))

      it.effect("uses json_schema format for structured output", () =>
        Effect.gen(function*() {
          yield* LanguageModel.generateObject({
            prompt: "Give me a person",
            schema: Schema.Struct({
              name: Schema.String,
              age: Schema.Number
            })
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

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

          strictEqual(body.text?.format?.type, "json_schema")
          strictEqual(body.text?.format?.strict, true)
        }).pipe(Effect.provide(makeTestLayer({
          body: {
            output: [makeTextOutput(JSON.stringify({ name: "John", age: 30 }))]
          }
        }))))
    })

    describe("response handling", () => {
      it.effect("preserves ultrafast service tier alongside prompt cache diagnostics", () =>
        Effect.gen(function*() {
          const diagnostics = {
            type: "cache_miss",
            reason: "tools_changed",
            cache_missed_tokens: 1024,
            comparison_reusable_tokens: 2048
          } as const
          const body = JSON.stringify({
            ...makeDefaultResponse({ service_tier: "ultrafast" }),
            prompt_cache_diagnostics: diagnostics
          })
          const result = yield* LanguageModel.generateText({ prompt: "test" }).pipe(
            Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")),
            Effect.provide(OpenAiClient.layer({ apiKey: Redacted.make("sk-test-key") })),
            Effect.provideService(HttpClient.HttpClient, makeRawResponseClient(body, "application/json"))
          )

          const finish = result.content.find((part) => part.type === "finish")
          assert.isDefined(finish)
          deepStrictEqual(finish.metadata.openai, {
            serviceTier: "ultrafast",
            promptCacheDiagnostics: diagnostics
          })
        }))

      it.effect("extracts text from output_text", () =>
        Effect.gen(function*() {
          const result = yield* LanguageModel.generateText({
            prompt: "Hello"
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

          strictEqual(result.text, "Hello, world!")
        }).pipe(Effect.provide(makeTestLayer({
          body: { output: [makeTextOutput("Hello, world!")] }
        }))))

      it.effect("extracts multiple text parts", () =>
        Effect.gen(function*() {
          const result = yield* LanguageModel.generateText({
            prompt: "Hello"
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

          const textParts = result.content.filter((p) => p.type === "text")
          strictEqual(textParts.length, 2)
        }).pipe(Effect.provide(makeTestLayer({
          body: {
            output: [
              makeTextOutput("First"),
              makeTextOutput("Second", { id: "msg_456" })
            ]
          }
        }))))

      it.effect("handles refusal content", () =>
        Effect.gen(function*() {
          const result = yield* LanguageModel.generateText({
            prompt: "Do something bad"
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

          const textPart = result.content.find((p) => p.type === "text")
          strictEqual(textPart?.text, "")
          strictEqual(textPart?.metadata?.openai?.refusal, "I cannot do that")
        }).pipe(Effect.provide(makeTestLayer({
          body: {
            output: [{
              type: "message",
              id: "msg_123",
              role: "assistant",
              status: "completed",
              content: [{ type: "refusal", refusal: "I cannot do that" }]
            }]
          }
        }))))

      it.effect("parses function call arguments", () =>
        Effect.gen(function*() {
          const result = yield* LanguageModel.generateText({
            prompt: "Use the tool",
            toolkit: TestToolkit
          }).pipe(Effect.provide(OpenAiLanguageModel.model("gpt-4o-mini")))

          const toolCall = result.content.find((p) => p.type === "tool-call")
          assert.isDefined(toolCall)
          if (toolCall?.type === "tool-call") {
            strictEqual(toolCall.name, "TestTool")
            deepStrictEqual(toolCall.params, { input: "hello" })
          }
        }).pipe(
          Effect.provide([
            makeTestLayer({
              body: { output: [makeFunctionCall("TestTool", { input: "hello" })] }
            }),