sailfork / t3code-github / .repos/ effect/ packages/ ai/ anthropic/ test/ AnthropicLanguageModel.test.ts

import { AnthropicClient, AnthropicLanguageModel, AnthropicTool } from "@effect/ai-anthropic"
import { assert, describe, it } from "@effect/vitest"
import { assertDefined } from "@effect/vitest/utils"
import { Cause, Effect, Exit, Layer, Option, Redacted, Schema, Stream, Tracer } from "effect"
import {
  type AiError,
  AnthropicStructuredOutput,
  LanguageModel,
  Prompt,
  Response as AiResponse,
  Tool,
  Toolkit
} from "effect/ai"
import { HttpClient, type HttpClientError, type HttpClientRequest, HttpClientResponse } from "effect/http"

describe("AnthropicLanguageModel", () => {
  describe("streamText", () => {
    it.effect("reports total input tokens and cache usage on the span", () =>
      Effect.gen(function*() {
        const spans: Array<Tracer.NativeSpan> = []
        const tracer = Tracer.make({
          span(options) {
            const span = new Tracer.NativeSpan(options)
            spans.push(span)
            return span
          }
        })
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(sseResponse(request, [
                {
                  type: "message_start",
                  message: {
                    id: "msg_test_1",
                    type: "message",
                    role: "assistant",
                    model: "claude-sonnet-4-20250514",
                    content: [],
                    stop_reason: null,
                    stop_sequence: null,
                    usage: {
                      cache_creation: null,
                      cache_creation_input_tokens: 20,
                      cache_read_input_tokens: 30,
                      input_tokens: 10,
                      output_tokens: 0,
                      service_tier: null
                    }
                  }
                },
                {
                  type: "message_delta",
                  delta: { stop_reason: "end_turn", stop_sequence: null },
                  usage: {
                    cache_creation_input_tokens: null,
                    cache_read_input_tokens: null,
                    input_tokens: null,
                    output_tokens: 5
                  }
                },
                { type: "message_stop" }
              ]))
            )
          ))
        )

        const parts = yield* LanguageModel.streamText({ prompt: "Hello" }).pipe(
          Stream.runCollect,
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(layer),
          Effect.withTracer(tracer)
        )
        const finish = parts.find((part) => part.type === "finish")
        assertDefined(finish)
        assert.deepStrictEqual(finish.usage.inputTokens, { uncached: 10, total: 60, cacheRead: 30, cacheWrite: 20 })
        const span = spans.find((span) => span.name === "LanguageModel.streamText")
        assertDefined(span)
        assert.strictEqual(span.attributes.get("gen_ai.usage.input_tokens"), 60)
        assert.strictEqual(span.attributes.get("gen_ai.usage.cache_read.input_tokens"), 30)
        assert.strictEqual(span.attributes.get("gen_ai.usage.cache_write.input_tokens"), 20)
        assert.strictEqual(span.attributes.get("gen_ai.usage.output_tokens"), 5)
      }))

    it.effect("accepts minimal usage and preserves input and cache tokens omitted from message_delta", () =>
      Effect.gen(function*() {
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(sseResponse(request, [
                {
                  type: "message_start",
                  message: {
                    id: "msg_test_1",
                    type: "message",
                    role: "assistant",
                    model: "claude-sonnet-4-20250514",
                    content: [],
                    stop_reason: null,
                    stop_sequence: null,
                    usage: {
                      cache_creation_input_tokens: 20,
                      cache_read_input_tokens: 30,
                      input_tokens: 10,
                      output_tokens: 1
                    }
                  }
                },
                {
                  type: "message_delta",
                  delta: { stop_reason: "end_turn", stop_sequence: null },
                  usage: { output_tokens: 5 }
                },
                { type: "message_stop" }
              ]))
            )
          ))
        )

        const parts = yield* LanguageModel.streamText({ prompt: "Hello" }).pipe(
          Stream.runCollect,
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(layer)
        )
        const finish = parts.find((part) => part.type === "finish")
        assertDefined(finish)
        assert.deepStrictEqual(finish.usage.inputTokens, { uncached: 10, total: 60, cacheRead: 30, cacheWrite: 20 })
        assert.strictEqual(finish.usage.outputTokens.total, 5)
      }))

    for (
      const [label, geo] of [
        ["missing", {}],
        ["null", { inference_geo: null }],
        ["string", { inference_geo: "us" }]
      ] as const
    ) {
      it.effect(`accepts ${label} usage.inference_geo in message_start`, () =>
        Effect.gen(function*() {
          const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
            Layer.provide(Layer.succeed(
              HttpClient.HttpClient,
              makeHttpClient((request) =>
                Effect.succeed(sseResponse(request, [
                  {
                    type: "message_start",
                    message: {
                      id: "msg_test_1",
                      type: "message",
                      role: "assistant",
                      model: "claude-sonnet-4-20250514",
                      content: [],
                      stop_reason: null,
                      stop_sequence: null,
                      usage: {
                        cache_creation: null,
                        cache_creation_input_tokens: null,
                        cache_read_input_tokens: null,
                        ...geo,
                        input_tokens: 10,
                        output_tokens: 0,
                        service_tier: null
                      }
                    }
                  },
                  { type: "content_block_start", index: 0, content_block: { type: "text", text: "Hello" } },
                  { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Hello" } },
                  { type: "content_block_stop", index: 0 },
                  {
                    type: "message_delta",
                    delta: { stop_reason: "end_turn", stop_sequence: null },
                    usage: {
                      cache_creation_input_tokens: null,
                      cache_read_input_tokens: null,
                      input_tokens: null,
                      output_tokens: 5
                    }
                  },
                  { type: "message_stop" }
                ]))
              )
            ))
          )

          const parts = yield* LanguageModel.streamText({ prompt: "Hello" }).pipe(
            Stream.runCollect,
            Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
            Effect.provide(layer)
          )
          assert.isTrue(
            globalThis.Array.from(parts).some((part) => part.type === "text-delta" && part.delta === "Hello")
          )
        }))
    }

    it.effect("decodes thinking deltas without the beta token estimate", () =>
      Effect.gen(function*() {
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(sseResponse(request, [
                {
                  type: "message_start",
                  message: {
                    id: "msg_test_1",
                    type: "message",
                    role: "assistant",
                    model: "claude-sonnet-4-20250514",
                    content: [],
                    stop_reason: null,
                    stop_sequence: null,
                    usage: {
                      cache_creation: null,
                      cache_creation_input_tokens: null,
                      cache_read_input_tokens: null,
                      input_tokens: 10,
                      output_tokens: 0,
                      service_tier: null
                    }
                  }
                },
                {
                  type: "content_block_start",
                  index: 0,
                  content_block: { type: "thinking", thinking: "", signature: "" }
                },
                // The documented thinking delta, without `estimated_tokens` from the token-count beta
                { type: "content_block_delta", index: 0, delta: { type: "thinking_delta", thinking: "Thinking..." } },
                { type: "content_block_stop", index: 0 },
                {
                  type: "message_delta",
                  delta: { stop_reason: "end_turn", stop_sequence: null },
                  usage: {
                    cache_creation_input_tokens: null,
                    cache_read_input_tokens: null,
                    input_tokens: null,
                    output_tokens: 5
                  }
                },
                { type: "message_stop" }
              ]))
            )
          ))
        )

        const parts = yield* LanguageModel.streamText({ prompt: "Hello" }).pipe(
          Stream.runCollect,
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(layer)
        )
        assert.isTrue(
          globalThis.Array.from(parts).some((part) => part.type === "reasoning-delta" && part.delta === "Thinking...")
        )
      }))

    it.effect("decodes tool call params in content_block_stop", () =>
      Effect.gen(function*() {
        const toolParams = { pattern: "*.ts" }

        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(sseResponse(request, [
                {
                  type: "message_start",
                  message: {
                    id: "msg_test_1",
                    type: "message",
                    role: "assistant",
                    model: "claude-sonnet-4-20250514",
                    content: [],
                    stop_reason: null,
                    stop_sequence: null,
                    usage: {
                      cache_creation: null,
                      cache_creation_input_tokens: null,
                      cache_read_input_tokens: null,
                      inference_geo: null,
                      input_tokens: 10,
                      output_tokens: 0,
                      service_tier: null
                    }
                  }
                },
                {
                  type: "content_block_start",
                  index: 0,
                  content_block: {
                    type: "tool_use",
                    id: "toolu_test_1",
                    name: "GlobTool",
                    input: {}
                  }
                },
                {
                  type: "content_block_delta",
                  index: 0,
                  delta: {
                    type: "input_json_delta",
                    partial_json: JSON.stringify(toolParams)
                  }
                },
                {
                  type: "content_block_stop",
                  index: 0
                },
                {
                  type: "message_delta",
                  delta: {
                    stop_reason: "tool_use",
                    stop_sequence: null
                  },
                  usage: {
                    cache_creation_input_tokens: null,
                    cache_read_input_tokens: null,
                    input_tokens: null,
                    output_tokens: 5
                  }
                },
                {
                  type: "message_stop"
                }
              ]))
            )
          ))
        )

        const GlobTool = Tool.make("GlobTool", {
          description: "Search for files",
          parameters: Schema.Struct({ pattern: Schema.String }),
          success: Schema.String
        })

        const toolkit = Toolkit.make(GlobTool)
        const toolkitLayer = toolkit.toLayer({
          GlobTool: () => Effect.succeed("found.ts")
        })

        const partsChunk = yield* LanguageModel.streamText({
          prompt: "find ts files",
          toolkit,
          disableToolCallResolution: true
        }).pipe(
          Stream.runCollect,
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(toolkitLayer),
          Effect.provide(layer)
        )

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

        assert.strictEqual(toolCall.name, "GlobTool")
        assert.deepStrictEqual(toolCall.params, toolParams)
      }))

    it.effect("streams undeclared tool calls when tool call validation is deferred", () =>
      Effect.gen(function*() {
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(sseResponse(request, [
                {
                  type: "message_start",
                  message: {
                    id: "msg_test_1",
                    type: "message",
                    role: "assistant",
                    model: "claude-sonnet-4-20250514",
                    content: [],
                    stop_reason: null,
                    stop_sequence: null,
                    usage: {
                      cache_creation: null,
                      cache_creation_input_tokens: null,
                      cache_read_input_tokens: null,
                      inference_geo: null,
                      input_tokens: 10,
                      output_tokens: 0,
                      service_tier: null
                    }
                  }
                },
                {
                  type: "content_block_start",
                  index: 0,
                  content_block: { type: "tool_use", id: "toolu_test_1", name: "Write", input: {} }
                },
                {
                  type: "content_block_delta",
                  index: 0,
                  delta: { type: "input_json_delta", partial_json: JSON.stringify({ path: "a" }) }
                },
                { type: "content_block_stop", index: 0 },
                {
                  type: "message_delta",
                  delta: { stop_reason: "tool_use", stop_sequence: null },
                  usage: {
                    cache_creation_input_tokens: null,
                    cache_read_input_tokens: null,
                    input_tokens: null,
                    output_tokens: 5
                  }
                },
                { type: "message_stop" }
              ]))
            )
          ))
        )
        const Read = Tool.make("Read", {
          parameters: Schema.Struct({ path: Schema.String }),
          success: Schema.String
        })
        const toolkit = Toolkit.make(Read)

        const parts = yield* LanguageModel.streamText({
          prompt: "use the tools",
          toolkit,
          disableToolCallResolution: true,
          toolCallValidation: "deferred"
        }).pipe(
          Stream.runCollect,
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(toolkit.toLayer({ Read: () => Effect.succeed("") })),
          Effect.provide(layer)
        )

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

    for (const blockType of ["tool_use", "server_tool_use"] as const) {
      it.effect(`fails with AiError for malformed streamed ${blockType} JSON`, () =>
        Effect.gen(function*() {
          const toolName = blockType === "tool_use" ? "GlobTool" : "web_search"
          const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
            Layer.provide(Layer.succeed(
              HttpClient.HttpClient,
              makeHttpClient((request) =>
                Effect.succeed(sseResponse(request, [
                  {
                    type: "message_start",
                    message: {
                      id: "msg_test_1",
                      type: "message",
                      role: "assistant",
                      model: "claude-sonnet-4-20250514",
                      content: [],
                      stop_reason: null,
                      stop_sequence: null,
                      usage: {
                        cache_creation: null,
                        cache_creation_input_tokens: null,
                        cache_read_input_tokens: null,
                        inference_geo: null,
                        input_tokens: 10,
                        output_tokens: 0,
                        service_tier: null
                      }
                    }
                  },
                  {
                    type: "content_block_start",
                    index: 0,
                    content_block: {
                      type: blockType,
                      id: blockType === "tool_use" ? "toolu_test_1" : "srvtoolu_test_1",
                      name: toolName,
                      input: {}
                    }
                  },
                  {
                    type: "content_block_delta",
                    index: 0,
                    delta: { type: "input_json_delta", partial_json: "{\"pattern\":" }
                  },
                  {
                    type: "content_block_delta",
                    index: 0,
                    delta: { type: "input_json_delta", partial_json: "\"*.ts" }
                  },
                  { type: "content_block_stop", index: 0 },
                  {
                    type: "message_delta",
                    delta: { stop_reason: "max_tokens", stop_sequence: null },
                    usage: {
                      cache_creation_input_tokens: null,
                      cache_read_input_tokens: null,
                      input_tokens: null,
                      output_tokens: 5
                    }
                  },
                  { type: "message_stop" }
                ]))
              )
            ))
          )
          const toolkit = Toolkit.make(
            Tool.make("GlobTool", { parameters: Schema.Struct({ pattern: Schema.String }) }),
            AnthropicTool.WebSearch_20250305({})
          )
          const exit = yield* LanguageModel.streamText({
            prompt: "find ts files",
            toolkit,
            disableToolCallResolution: true
          }).pipe(
            Stream.runCollect,
            Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
            Effect.provide(layer),
            Effect.exit
          )

          assert.isTrue(Exit.isFailure(exit))
          if (!Exit.isFailure(exit)) {
            return yield* Effect.die(new Error("Expected malformed tool JSON to fail"))
          }
          assert.isFalse(Cause.hasDies(exit.cause))
          const error = Option.getOrThrow(Cause.findErrorOption(exit.cause))
          assert.strictEqual(error._tag, "AiError")
          assert.strictEqual(error.reason._tag, "ToolParameterValidationError")
        }))
    }

    it.effect("routes invalid tool call params through failureMode: return without failing the stream", () =>
      Effect.gen(function*() {
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(sseResponse(request, [
                {
                  type: "message_start",
                  message: {
                    id: "msg_test_1",
                    type: "message",
                    role: "assistant",
                    model: "claude-sonnet-4-20250514",
                    content: [],
                    stop_reason: null,
                    stop_sequence: null,
                    usage: {
                      cache_creation: null,
                      cache_creation_input_tokens: null,
                      cache_read_input_tokens: null,
                      inference_geo: null,
                      input_tokens: 10,
                      output_tokens: 0,
                      service_tier: null
                    }
                  }
                },
                {
                  type: "content_block_start",
                  index: 0,
                  content_block: {
                    type: "tool_use",
                    id: "toolu_test_1",
                    name: "GlobTool",
                    input: {}
                  }
                },
                {
                  type: "content_block_delta",
                  index: 0,
                  delta: {
                    type: "input_json_delta",
                    partial_json: JSON.stringify({ pattern: 123 })
                  }
                },
                {
                  type: "content_block_stop",
                  index: 0
                },
                {
                  type: "message_delta",
                  delta: {
                    stop_reason: "tool_use",
                    stop_sequence: null
                  },
                  usage: {
                    cache_creation_input_tokens: null,
                    cache_read_input_tokens: null,
                    input_tokens: null,
                    output_tokens: 5
                  }
                },
                {
                  type: "message_stop"
                }
              ]))
            )
          ))
        )

        const GlobTool = Tool.make("GlobTool", {
          description: "Search for files",
          failureMode: "return",
          parameters: Schema.Struct({ pattern: Schema.String }),
          success: Schema.String,
          failure: Schema.String
        })

        const toolkit = Toolkit.make(GlobTool)
        const toolkitLayer = toolkit.toLayer({
          GlobTool: () => Effect.succeed("found.ts")
        })

        const partsChunk = yield* LanguageModel.streamText({
          prompt: "find ts files",
          toolkit
        }).pipe(
          Stream.runCollect,
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(toolkitLayer),
          Effect.provide(layer)
        )

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

        assert.strictEqual(toolResult.isFailure, true)
        const failure = toolResult.result as AiError.AiError
        assert.strictEqual(failure._tag, "AiError")
        assert.strictEqual(failure.reason._tag, "ToolParameterValidationError")
      }))

    const codeExecutionCases = [
      {
        providerName: "bash_code_execution",
        toolParams: { command: "pwd" },
        expectedParams: { type: "bash_code_execution", command: "pwd" }
      },
      {
        providerName: "text_editor_code_execution",
        toolParams: { command: "view", path: "/tmp/example.txt" },
        expectedParams: {
          type: "text_editor_code_execution",
          command: "view",
          path: "/tmp/example.txt"
        }
      }
    ] as const

    for (const { expectedParams, providerName, toolParams } of codeExecutionCases) {
      it.effect(`emits valid JSON for streamed ${providerName} parameters`, () =>
        Effect.gen(function*() {
          const toolkit = Toolkit.make(AnthropicTool.CodeExecution_20250522())
          const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
            Layer.provide(Layer.succeed(
              HttpClient.HttpClient,
              makeHttpClient((request) =>
                Effect.succeed(sseResponse(request, [
                  {
                    type: "message_start",
                    message: {
                      id: "msg_test_1",
                      type: "message",
                      role: "assistant",
                      model: "claude-sonnet-4-20250514",
                      content: [],
                      stop_reason: null,
                      stop_sequence: null,
                      usage: {
                        cache_creation: null,
                        cache_creation_input_tokens: null,
                        cache_read_input_tokens: null,
                        inference_geo: null,
                        input_tokens: 1,
                        output_tokens: 0,
                        service_tier: null
                      }
                    }
                  },
                  {
                    type: "content_block_start",
                    index: 0,
                    content_block: {
                      type: "server_tool_use",
                      id: "srvtoolu_test_1",
                      name: providerName,
                      input: {}
                    }
                  },
                  {
                    type: "content_block_delta",
                    index: 0,
                    delta: {
                      type: "input_json_delta",
                      partial_json: JSON.stringify(toolParams)
                    }
                  },
                  {
                    type: "content_block_stop",
                    index: 0
                  },
                  {
                    type: "message_delta",
                    delta: {
                      stop_reason: "tool_use",
                      stop_sequence: null
                    },
                    usage: {
                      cache_creation_input_tokens: null,
                      cache_read_input_tokens: null,
                      input_tokens: null,
                      output_tokens: 1
                    }
                  },
                  {
                    type: "message_stop"
                  }
                ]))
              )
            ))
          )

          const partsChunk = yield* LanguageModel.streamText({
            prompt: "run pwd",
            toolkit,
            disableToolCallResolution: true
          }).pipe(
            Stream.runCollect,
            Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
            Effect.provide(layer)
          )

          const parts = globalThis.Array.from(partsChunk)

          const delta = parts.find((part) => part.type === "tool-params-delta")
          assert.isDefined(delta)
          if (delta?.type === "tool-params-delta") {
            assert.deepStrictEqual(JSON.parse(delta.delta), expectedParams)
          }

          const toolCall = parts.find((part) => part.type === "tool-call")
          assert.isDefined(toolCall)
          if (toolCall?.type === "tool-call") {
            assert.deepStrictEqual(toolCall.params, expectedParams)
          }
        }))
    }

    // `Model` is an open enum in Anthropic's spec (`anyOf: [{ type: string }, ...consts]`), and it is
    // $ref'd by response schemas. Responses must therefore decode for model ids that are newer than the
    // generated literals, and the id must survive decoding unchanged.
    it.effect("decodes responses for a model id that is not a known literal", () =>
      Effect.gen(function*() {
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(sseResponse(request, [
                {
                  type: "message_start",
                  message: {
                    id: "msg_test_1",
                    type: "message",
                    role: "assistant",
                    model: "claude-not-a-known-model-id",
                    content: [],
                    stop_reason: null,
                    stop_sequence: null,
                    usage: {
                      cache_creation: null,
                      cache_creation_input_tokens: null,
                      cache_read_input_tokens: null,
                      inference_geo: null,
                      input_tokens: 10,
                      output_tokens: 0,
                      service_tier: null
                    }
                  }
                },
                {
                  type: "content_block_start",
                  index: 0,
                  content_block: { type: "text", text: "" }
                },
                {
                  type: "content_block_delta",
                  index: 0,
                  delta: { type: "text_delta", text: "Hello" }
                },
                {
                  type: "content_block_stop",
                  index: 0
                },
                {
                  type: "message_delta",
                  delta: {
                    stop_reason: "end_turn",
                    stop_sequence: null
                  },
                  usage: {
                    cache_creation_input_tokens: null,
                    cache_read_input_tokens: null,
                    input_tokens: null,
                    output_tokens: 5
                  }
                },
                {
                  type: "message_stop"
                }
              ]))
            )
          ))
        )

        const partsChunk = yield* LanguageModel.streamText({
          prompt: "say hello"
        }).pipe(
          Stream.runCollect,
          Effect.provide(AnthropicLanguageModel.model("claude-not-a-known-model-id")),
          Effect.provide(layer)
        )

        const parts = globalThis.Array.from(partsChunk)
        const metadata = parts.find((part) => part.type === "response-metadata")
        assert.isDefined(metadata)
        if (metadata?.type !== "response-metadata") {
          return
        }

        assert.strictEqual(metadata.modelId, "claude-not-a-known-model-id")

        const text = parts.find((part) => part.type === "text-delta")
        assert.isDefined(text)
        if (text?.type !== "text-delta") {
          return
        }

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

    it.effect("emits response metadata for a fallback block", () =>
      Effect.gen(function*() {
        const fallback = {
          type: "fallback",
          from: { model: "claude-opus-5-5" },
          to: { model: "claude-opus-4-8" },
          trigger: { type: "refusal", category: "cyber" }
        } as const
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(sseResponse(request, [
                {
                  type: "message_start",
                  message: {
                    id: "msg_test_1",
                    type: "message",
                    role: "assistant",
                    model: "claude-opus-4-8",
                    content: [],
                    stop_reason: null,
                    stop_sequence: null,
                    usage: {
                      cache_creation: null,
                      cache_creation_input_tokens: null,
                      cache_read_input_tokens: null,
                      input_tokens: 10,
                      output_tokens: 0,
                      service_tier: null
                    }
                  }
                },
                { type: "content_block_start", index: 0, content_block: fallback },
                { type: "content_block_stop", index: 0 },
                {
                  type: "message_delta",
                  delta: { stop_reason: "end_turn", stop_sequence: null },
                  usage: {
                    cache_creation_input_tokens: null,
                    cache_read_input_tokens: null,
                    input_tokens: null,
                    output_tokens: 5
                  }
                },
                { type: "message_stop" }
              ]))
            )
          ))
        )

        const parts = yield* LanguageModel.streamText({ prompt: "Hello" }).pipe(
          Stream.runCollect,
          Effect.provide(AnthropicLanguageModel.model("claude-opus-5-5")),
          Effect.provide(layer)
        )
        const metadata = globalThis.Array.from(parts).find((part) =>
          part.type === "response-metadata" && part.metadata.anthropic?.fallback !== undefined
        )
        assert.strictEqual(metadata?.type === "response-metadata" ? metadata.modelId : undefined, "claude-opus-4-8")
        assert.deepStrictEqual(
          metadata?.type === "response-metadata" ? metadata.metadata.anthropic?.fallback : undefined,
          fallback
        )
      }))
  })

  describe("generateText", () => {
    for (
      const [label, geo] of [
        ["missing", {}],
        ["null", { inference_geo: null }],
        ["string", { inference_geo: "us" }]
      ] as const
    ) {
      it.effect(`accepts ${label} usage.inference_geo in a message response`, () =>
        Effect.gen(function*() {
          const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
            Layer.provide(Layer.succeed(
              HttpClient.HttpClient,
              makeHttpClient((request) =>
                Effect.succeed(jsonResponse(request, {
                  id: "msg_test_1",
                  type: "message",
                  role: "assistant",
                  model: "claude-sonnet-4-20250514",
                  content: [{ type: "text", text: "Hello" }],
                  stop_reason: "end_turn",
                  stop_sequence: null,
                  usage: {
                    cache_creation: null,
                    cache_creation_input_tokens: null,
                    cache_read_input_tokens: null,
                    ...geo,
                    input_tokens: 10,
                    output_tokens: 5,
                    service_tier: null
                  }
                }))
              )
            ))
          )

          const response = yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
            Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
            Effect.provide(layer)
          )
          assert.isTrue(response.content.some((part) => part.type === "text" && part.text === "Hello"))
        }))
    }

    it.effect("accepts minimal usage in a message response", () =>
      Effect.gen(function*() {
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(jsonResponse(request, {
                id: "msg_test_1",
                type: "message",
                role: "assistant",
                model: "claude-sonnet-4-20250514",
                content: [{ type: "text", text: "Hello" }],
                stop_reason: "end_turn",
                stop_sequence: null,
                usage: { input_tokens: 3, output_tokens: 1 }
              }))
            )
          ))
        )

        const response = yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(layer)
        )
        assert.deepStrictEqual(response.usage.inputTokens, { uncached: 3, total: 3, cacheRead: 0, cacheWrite: 0 })
      }))

    it.effect("emits response metadata for a fallback block and keeps fallback usage iterations", () =>
      Effect.gen(function*() {
        const fallback = {
          type: "fallback",
          from: { model: "claude-opus-5-5" },
          to: { model: "claude-opus-4-8" },
          trigger: { type: "refusal", category: "cyber" }
        } as const
        const iterations = [
          {
            type: "message",
            model: "claude-opus-5-5",
            cache_creation: null,
            cache_creation_input_tokens: 0,
            cache_read_input_tokens: 0,
            input_tokens: 10,
            output_tokens: 0
          },
          {
            type: "fallback_message",
            model: "claude-opus-4-8",
            cache_creation: null,
            cache_creation_input_tokens: 0,
            cache_read_input_tokens: 0,
            input_tokens: 10,
            output_tokens: 5
          }
        ] as const
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(jsonResponse(request, {
                id: "msg_test_1",
                type: "message",
                role: "assistant",
                model: "claude-opus-4-8",
                content: [fallback, { type: "text", text: "Hello" }],
                stop_reason: "end_turn",
                stop_sequence: null,
                usage: {
                  cache_creation: null,
                  cache_creation_input_tokens: null,
                  cache_read_input_tokens: null,
                  input_tokens: 10,
                  output_tokens: 5,
                  service_tier: null,
                  iterations
                }
              }))
            )
          ))
        )

        const response = yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
          Effect.provide(AnthropicLanguageModel.model("claude-opus-5-5")),
          Effect.provide(layer)
        )
        const metadata = response.content.find((part) =>
          part.type === "response-metadata" && part.metadata.anthropic?.fallback !== undefined
        )
        assert.strictEqual(metadata?.type === "response-metadata" ? metadata.modelId : undefined, "claude-opus-4-8")
        assert.deepStrictEqual(
          metadata?.type === "response-metadata" ? metadata.metadata.anthropic?.fallback : undefined,
          fallback
        )
        const finish = response.content.find((part) => part.type === "finish")
        assert.deepStrictEqual(
          finish?.type === "finish" ? finish.metadata.anthropic?.usage?.iterations : undefined,
          iterations
        )
      }))

    it.effect("reports length when the model context window is exceeded", () =>
      Effect.gen(function*() {
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(jsonResponse(request, {
                id: "msg_test_1",
                type: "message",
                role: "assistant",
                model: "claude-sonnet-4-20250514",
                content: [{ type: "text", text: "Hello" }],
                stop_reason: "model_context_window_exceeded",
                stop_sequence: null,
                usage: {
                  cache_creation: null,
                  cache_creation_input_tokens: null,
                  cache_read_input_tokens: null,
                  input_tokens: 10,
                  output_tokens: 5,
                  service_tier: null
                }
              }))
            )
          ))
        )

        const response = yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(layer)
        )
        assert.strictEqual(response.finishReason, "length")
      }))

    it.effect("reports total input tokens and cache usage on the span", () =>
      Effect.gen(function*() {
        const spans: Array<Tracer.NativeSpan> = []
        const tracer = Tracer.make({
          span(options) {
            const span = new Tracer.NativeSpan(options)
            spans.push(span)
            return span
          }
        })
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) =>
              Effect.succeed(jsonResponse(request, {
                id: "msg_test_1",
                type: "message",
                role: "assistant",
                model: "claude-sonnet-4-20250514",
                content: [{ type: "text", text: "Hello" }],
                stop_reason: "end_turn",
                stop_sequence: null,
                usage: {
                  cache_creation: null,
                  cache_creation_input_tokens: 20,
                  cache_read_input_tokens: 30,
                  input_tokens: 10,
                  output_tokens: 5,
                  service_tier: null
                }
              }))
            )
          ))
        )

        yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(layer),
          Effect.withTracer(tracer)
        )
        const span = spans.find((span) => span.name === "LanguageModel.generateText")
        assertDefined(span)
        const attributes = span.attributes
        assert.strictEqual(attributes.get("gen_ai.provider.name"), "anthropic")
        assert.strictEqual(attributes.get("gen_ai.usage.input_tokens"), 60)
        assert.strictEqual(attributes.get("gen_ai.usage.cache_read.input_tokens"), 30)
        assert.strictEqual(attributes.get("gen_ai.usage.cache_write.input_tokens"), 20)
        assert.strictEqual(attributes.get("gen_ai.usage.output_tokens"), 5)
      }))

    it.effect("omits strictJsonSchema from the request while preserving tool strictness", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
        const model = "claude-sonnet-4-5"
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(request, {
                id: "msg_test_1",
                type: "message",
                role: "assistant",
                model,
                content: [{ type: "text", text: "Hello" }],
                stop_reason: "end_turn",
                stop_sequence: null,
                usage: {
                  cache_creation: null,
                  cache_creation_input_tokens: null,
                  cache_read_input_tokens: null,
                  inference_geo: null,
                  input_tokens: 1,
                  output_tokens: 1,
                  service_tier: null
                }
              }))
            })
          ))
        )

        yield* LanguageModel.generateText({
          prompt: "Hello",
          toolkit: Toolkit.make(Tool.make("Search", {
            parameters: Schema.Struct({ query: Schema.String }),
            success: Schema.String
          })),
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(AnthropicLanguageModel.model(model, { strictJsonSchema: false })),
          Effect.provide(layer)
        )

        assert.isDefined(capturedRequest)
        const body = yield* getRequestBody(capturedRequest)
        assert.strictEqual(body.model, model)
        assert.strictEqual(body.tools[0].name, "Search")
        assert.strictEqual(body.tools[0].strict, false)
        assert.notProperty(body, "strictJsonSchema")
      }))

    it.effect("preserves string tool results", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(request, {
                id: "msg_test_1",
                type: "message",
                role: "assistant",
                model: "claude-sonnet-4-20250514",
                content: [{ type: "text", text: "Done" }],
                stop_reason: "end_turn",
                stop_sequence: null,
                usage: {
                  cache_creation: null,
                  cache_creation_input_tokens: null,
                  cache_read_input_tokens: null,
                  inference_geo: null,
                  input_tokens: 10,
                  output_tokens: 5,
                  service_tier: null
                }
              }))
            })
          ))
        )

        yield* LanguageModel.generateText({
          prompt: Prompt.make([
            { role: "user", content: "Use the tool" },
            {
              role: "assistant",
              content: [Prompt.toolCallPart({
                id: "call_text",
                name: "text_tool",
                params: {},
                providerExecuted: false
              })]
            },
            {
              role: "tool",
              content: [Prompt.toolResultPart({
                id: "call_text",
                name: "text_tool",
                result: "PLAIN_TEXT_SENTINEL\n",
                isFailure: false,
                providerExecuted: false
              })]
            }
          ]),
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(layer)
        )

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

        const body = yield* getRequestBody(capturedRequest)
        const toolResult = body.messages
          .flatMap((message: any) => Array.isArray(message.content) ? message.content : [])
          .find((block: any) => block.type === "tool_result")

        assert.isDefined(toolResult)
        assert.strictEqual(toolResult.content, "PLAIN_TEXT_SENTINEL\n")
      }))

    const png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVR4nGP4DwQACfsD/fteaysAAAAASUVORK5CYII="
    const pdf = "JVBERi0xLjcK"
    const modelOutputCases = [
      {
        label: "as native content blocks",
        modelOutput: [
          Prompt.textPart({ text: "Screenshot of /home" }),
          Prompt.filePart({ mediaType: "image/png", data: png }),
          Prompt.filePart({ mediaType: "application/pdf", data: `data:application/pdf;base64,${pdf}` })
        ],
        content: [
          { type: "text", text: "Screenshot of /home" },
          { type: "image", source: { type: "base64", media_type: "image/png", data: png } },
          { type: "document", source: { type: "base64", media_type: "application/pdf", data: pdf }, title: null }
        ]
      },
      { label: "without the result 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 = undefined
          const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
            Layer.provide(Layer.succeed(
              HttpClient.HttpClient,
              makeHttpClient((request) => {
                capturedRequest = request
                return Effect.succeed(jsonResponse(request, {
                  id: "msg_test_1",
                  type: "message",
                  role: "assistant",
                  model: "claude-sonnet-4-20250514",
                  content: [{ type: "text", text: "Done" }],
                  stop_reason: "end_turn",
                  stop_sequence: null,
                  usage: {
                    cache_creation: null,
                    cache_creation_input_tokens: null,
                    cache_read_input_tokens: null,
                    inference_geo: null,
                    input_tokens: 1,
                    output_tokens: 1,
                    service_tier: null
                  }
                }))
              })
            ))
          )

          yield* LanguageModel.generateText({
            prompt: Prompt.make([
              { role: "user", content: "Take a screenshot" },
              {
                role: "assistant",
                content: [Prompt.toolCallPart({
                  id: "call_screenshot",
                  name: "screenshot",
                  params: {},
                  providerExecuted: false
                })]
              },
              {
                role: "tool",
                content: [Prompt.toolResultPart({
                  id: "call_screenshot",
                  name: "screenshot",
                  result: { path: "/home", png },
                  modelOutput,
                  isFailure: false,
                  providerExecuted: false
                })]
              }
            ]),
            disableToolCallResolution: true
          }).pipe(
            Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
            Effect.provide(layer)
          )

          assert.isDefined(capturedRequest)
          const body = yield* getRequestBody(capturedRequest)
          const toolResult = body.messages
            .flatMap((message: any) => Array.isArray(message.content) ? message.content : [])
            .find((block: any) => block.type === "tool_result")

          assert.strictEqual(toolResult.tool_use_id, "call_screenshot")
          assert.deepStrictEqual(
            Array.isArray(toolResult.content)
              ? toolResult.content.map(({ cache_control: _, ...block }: any) => block)
              : toolResult.content,
            content
          )
        }))
    }

    it.effect("preserves base64 image string payloads", () =>
      Effect.gen(function*() {
        const base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVR4nGP4DwQACfsD/fteaysAAAAASUVORK5CYII="
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(request, {
                id: "msg_test_1",
                type: "message",
                role: "assistant",
                model: "claude-sonnet-4-20250514",
                content: [{ type: "text", text: "Done" }],
                stop_reason: "end_turn",
                stop_sequence: null,
                usage: {
                  cache_creation: null,
                  cache_creation_input_tokens: null,
                  cache_read_input_tokens: null,
                  inference_geo: null,
                  input_tokens: 1,
                  output_tokens: 1,
                  service_tier: null
                }
              }))
            })
          ))
        )

        yield* LanguageModel.generateText({
          prompt: Prompt.make([Prompt.userMessage({
            content: [Prompt.filePart({ mediaType: "image/png", data: base64 })]
          })])
        }).pipe(
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(layer)
        )

        assert.isDefined(capturedRequest)
        const body = yield* getRequestBody(capturedRequest)
        assert.strictEqual(body.messages[0].content[0].source.data, base64)
      }))

    it.effect("encodes dynamic tools", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(request, {
                id: "msg_test_1",
                type: "message",
                role: "assistant",
                model: "claude-sonnet-4-20250514",
                content: [{ type: "text", text: "Done" }],
                stop_reason: "end_turn",
                stop_sequence: null,
                usage: {
                  cache_creation: null,
                  cache_creation_input_tokens: null,
                  cache_read_input_tokens: null,
                  inference_geo: null,
                  input_tokens: 10,
                  output_tokens: 5,
                  service_tier: null
                }
              }))
            })
          ))
        )

        const inputSchema = {
          properties: {
            query: { type: "string" }
          }
        } as const

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

        yield* LanguageModel.generateText({
          prompt: "Use the dynamic tool",
          toolkit: Toolkit.make(DynamicTool),
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(layer)
        )

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

        const body = yield* getRequestBody(capturedRequest)
        const dynamicTool = body.tools.find((tool: any) => tool.name === "DynamicTool")

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

        assert.strictEqual(dynamicTool.description, "A dynamic tool")
        assert.deepStrictEqual(dynamicTool.input_schema, 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(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(AnthropicClient.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("sends recursive parameters for a non-strict tool and returns nested tool call params", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
        const model = "claude-sonnet-4-5"
        const params = { filter: { name: null, OR: [{ name: "Anna" }, { name: "Ben" }] } }
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(request, {
                id: "msg_test_1",
                type: "message",
                role: "assistant",
                model,
                content: [{ type: "tool_use", id: "toolu_test_1", name: "ListContacts", input: params }],
                stop_reason: "tool_use",
                stop_sequence: null,
                usage: {
                  cache_creation: null,
                  cache_creation_input_tokens: null,
                  cache_read_input_tokens: null,
                  inference_geo: null,
                  input_tokens: 1,
                  output_tokens: 1,
                  service_tier: null
                }
              }))
            })
          ))
        )

        const response = yield* LanguageModel.generateText({
          prompt: "Find the contacts named Anna or Ben",
          toolkit: Toolkit.make(RecursiveFilterTool),
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(AnthropicLanguageModel.model(model, { strictJsonSchema: false })),
          Effect.provide(layer)
        )

        assert.isDefined(capturedRequest)
        const body = yield* getRequestBody(capturedRequest)
        assert.strictEqual(body.tools[0].strict, false)
        const inputSchema = body.tools[0].input_schema
        assert.strictEqual(inputSchema.type, "object")
        assert.deepStrictEqual(inputSchema.properties.filter, { $ref: "#/$defs/Filter" })
        assert.deepStrictEqual(inputSchema.$defs.Filter.properties.OR.items, { $ref: "#/$defs/Filter" })
        assert.strictEqual(response.toolCalls.length, 1)
        const { filter } = response.toolCalls[0].params
        assert.isUndefined(filter.name)
        assert.deepStrictEqual(filter.OR, [{ name: "Anna" }, { name: "Ben" }])
      }))

    it.effect("rejects recursive parameters for a strict tool", () =>
      Effect.gen(function*() {
        const error = yield* LanguageModel.generateText({
          prompt: "Find the contacts named Anna or Ben",
          toolkit: Toolkit.make(RecursiveFilterTool),
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-5")),
          Effect.provide(AnthropicClient.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, "Recursive schemas are not supported")
      }))

    it.effect("serializes provider-executed web_search parts from the assistant message", () =>
      Effect.gen(function*() {
        let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
        const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            makeHttpClient((request) => {
              capturedRequest = request
              return Effect.succeed(jsonResponse(request, {
                id: "msg_test_2",
                type: "message",
                role: "assistant",
                model: "claude-sonnet-4-20250514",
                content: [{ type: "text", text: "You're welcome" }],
                stop_reason: "end_turn",
                stop_sequence: null,
                usage: {
                  cache_creation: null,
                  cache_creation_input_tokens: null,
                  cache_read_input_tokens: null,
                  inference_geo: null,
                  input_tokens: 10,
                  output_tokens: 5,
                  service_tier: null
                }
              }))
            })
          ))
        )

        const searchResults = [{
          type: "web_search_result",
          url: "https://example.com/gold",
          title: "Gold price",
          encrypted_content: "encrypted",
          page_age: null
        }]

        const history = Prompt.fromResponseParts([
          AiResponse.makePart("tool-call", {
            id: "srvtoolu_1",
            name: "AnthropicWebSearch",
            params: { query: "gold price today" },
            providerExecuted: true
          }),
          AiResponse.makePart("tool-result", {
            id: "srvtoolu_1",
            name: "AnthropicWebSearch",
            isFailure: false,
            result: searchResults,
            encodedResult: searchResults,
            preliminary: false,
            providerExecuted: true
          }),
          AiResponse.makePart("text", { text: "Gold is around $4,000." })
        ])

        const prompt = Prompt.concat(
          Prompt.concat(Prompt.make("what is the gold price?"), history),
          Prompt.make("thanks")
        )

        yield* LanguageModel.generateText({
          prompt,
          toolkit: Toolkit.make(AnthropicTool.WebSearch_20250305({})),
          disableToolCallResolution: true
        }).pipe(
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(layer)
        )

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

        const body = yield* getRequestBody(capturedRequest)
        const assistantMessage = body.messages.find((message: any) => message.role === "assistant")
        assert.isDefined(assistantMessage)

        const serverToolUse = assistantMessage.content.find((block: any) => block.type === "server_tool_use")
        assert.isDefined(serverToolUse)
        assert.strictEqual(serverToolUse.id, "srvtoolu_1")
        assert.strictEqual(serverToolUse.name, "web_search")

        const searchResult = assistantMessage.content.find((block: any) => block.type === "web_search_tool_result")
        assert.isDefined(searchResult)
        assert.strictEqual(searchResult.tool_use_id, "srvtoolu_1")

        const clientToolResults = body.messages.flatMap((message: any) =>
          Array.isArray(message.content)
            ? message.content.filter((block: any) => block.type === "tool_result")
            : []
        )
        assert.strictEqual(clientToolResults.length, 0)
      }))

    it.effect("encodes plaintext bytes as UTF-8 text", () =>
      Effect.gen(function*() {
        let body: any
        const client = AnthropicClient.layer({ apiKey: Redacted.make("test") }).pipe(
          Layer.provide(Layer.succeed(
            HttpClient.HttpClient,
            HttpClient.makeWith(
              Effect.fnUntraced(function*(requestEffect) {
                const request = yield* requestEffect
                body = JSON.parse(new TextDecoder().decode((request.body as any).body))
                return HttpClientResponse.fromWeb(
                  request,
                  new Response(
                    JSON.stringify({
                      id: "msg_1",
                      type: "message",
                      role: "assistant",
                      model: "claude-sonnet-4-20250514",
                      content: [{ type: "text", text: "ok" }],
                      stop_reason: "end_turn",
                      stop_sequence: null,
                      usage: {
                        cache_creation: null,
                        cache_creation_input_tokens: null,
                        cache_read_input_tokens: null,
                        inference_geo: null,
                        input_tokens: 1,
                        output_tokens: 1,
                        service_tier: null
                      }
                    }),
                    { status: 200 }
                  )
                )
              }),
              Effect.succeed as HttpClient.HttpClient.Preprocess<HttpClientError.HttpClientError, never>
            )
          ))
        )

        yield* LanguageModel.generateText({
          prompt: Prompt.make([{
            role: "user",
            content: [Prompt.filePart({ mediaType: "text/plain", data: new TextEncoder().encode("hello") })]
          }])
        }).pipe(
          Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
          Effect.provide(client)
        )

        assert.strictEqual(body.messages[0].content[0].source.data, "hello")
      }))
  })