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")
}))
})