The best way to control Claude Code, Codex and more from any computer or phone

main
ts 2,639 lines 99.1 KB
Raw
1 import { AnthropicClient, AnthropicLanguageModel, AnthropicTool } from "@effect/ai-anthropic"
2 import { assert, describe, it } from "@effect/vitest"
3 import { assertDefined } from "@effect/vitest/utils"
4 import { Cause, Effect, Exit, Layer, Option, Redacted, Schema, Stream, Tracer } from "effect"
5 import {
6 type AiError,
7 AnthropicStructuredOutput,
8 LanguageModel,
9 Prompt,
10 Response as AiResponse,
11 Tool,
12 Toolkit
13 } from "effect/ai"
14 import { HttpClient, type HttpClientError, type HttpClientRequest, HttpClientResponse } from "effect/http"
15
16 describe("AnthropicLanguageModel", () => {
17 describe("streamText", () => {
18 it.effect("reports total input tokens and cache usage on the span", () =>
19 Effect.gen(function*() {
20 const spans: Array<Tracer.NativeSpan> = []
21 const tracer = Tracer.make({
22 span(options) {
23 const span = new Tracer.NativeSpan(options)
24 spans.push(span)
25 return span
26 }
27 })
28 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
29 Layer.provide(Layer.succeed(
30 HttpClient.HttpClient,
31 makeHttpClient((request) =>
32 Effect.succeed(sseResponse(request, [
33 {
34 type: "message_start",
35 message: {
36 id: "msg_test_1",
37 type: "message",
38 role: "assistant",
39 model: "claude-sonnet-4-20250514",
40 content: [],
41 stop_reason: null,
42 stop_sequence: null,
43 usage: {
44 cache_creation: null,
45 cache_creation_input_tokens: 20,
46 cache_read_input_tokens: 30,
47 input_tokens: 10,
48 output_tokens: 0,
49 service_tier: null
50 }
51 }
52 },
53 {
54 type: "message_delta",
55 delta: { stop_reason: "end_turn", stop_sequence: null },
56 usage: {
57 cache_creation_input_tokens: null,
58 cache_read_input_tokens: null,
59 input_tokens: null,
60 output_tokens: 5
61 }
62 },
63 { type: "message_stop" }
64 ]))
65 )
66 ))
67 )
68
69 const parts = yield* LanguageModel.streamText({ prompt: "Hello" }).pipe(
70 Stream.runCollect,
71 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
72 Effect.provide(layer),
73 Effect.withTracer(tracer)
74 )
75 const finish = parts.find((part) => part.type === "finish")
76 assertDefined(finish)
77 assert.deepStrictEqual(finish.usage.inputTokens, { uncached: 10, total: 60, cacheRead: 30, cacheWrite: 20 })
78 const span = spans.find((span) => span.name === "LanguageModel.streamText")
79 assertDefined(span)
80 assert.strictEqual(span.attributes.get("gen_ai.usage.input_tokens"), 60)
81 assert.strictEqual(span.attributes.get("gen_ai.usage.cache_read.input_tokens"), 30)
82 assert.strictEqual(span.attributes.get("gen_ai.usage.cache_write.input_tokens"), 20)
83 assert.strictEqual(span.attributes.get("gen_ai.usage.output_tokens"), 5)
84 }))
85
86 it.effect("accepts minimal usage and preserves input and cache tokens omitted from message_delta", () =>
87 Effect.gen(function*() {
88 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
89 Layer.provide(Layer.succeed(
90 HttpClient.HttpClient,
91 makeHttpClient((request) =>
92 Effect.succeed(sseResponse(request, [
93 {
94 type: "message_start",
95 message: {
96 id: "msg_test_1",
97 type: "message",
98 role: "assistant",
99 model: "claude-sonnet-4-20250514",
100 content: [],
101 stop_reason: null,
102 stop_sequence: null,
103 usage: {
104 cache_creation_input_tokens: 20,
105 cache_read_input_tokens: 30,
106 input_tokens: 10,
107 output_tokens: 1
108 }
109 }
110 },
111 {
112 type: "message_delta",
113 delta: { stop_reason: "end_turn", stop_sequence: null },
114 usage: { output_tokens: 5 }
115 },
116 { type: "message_stop" }
117 ]))
118 )
119 ))
120 )
121
122 const parts = yield* LanguageModel.streamText({ prompt: "Hello" }).pipe(
123 Stream.runCollect,
124 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
125 Effect.provide(layer)
126 )
127 const finish = parts.find((part) => part.type === "finish")
128 assertDefined(finish)
129 assert.deepStrictEqual(finish.usage.inputTokens, { uncached: 10, total: 60, cacheRead: 30, cacheWrite: 20 })
130 assert.strictEqual(finish.usage.outputTokens.total, 5)
131 }))
132
133 for (
134 const [label, geo] of [
135 ["missing", {}],
136 ["null", { inference_geo: null }],
137 ["string", { inference_geo: "us" }]
138 ] as const
139 ) {
140 it.effect(`accepts ${label} usage.inference_geo in message_start`, () =>
141 Effect.gen(function*() {
142 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
143 Layer.provide(Layer.succeed(
144 HttpClient.HttpClient,
145 makeHttpClient((request) =>
146 Effect.succeed(sseResponse(request, [
147 {
148 type: "message_start",
149 message: {
150 id: "msg_test_1",
151 type: "message",
152 role: "assistant",
153 model: "claude-sonnet-4-20250514",
154 content: [],
155 stop_reason: null,
156 stop_sequence: null,
157 usage: {
158 cache_creation: null,
159 cache_creation_input_tokens: null,
160 cache_read_input_tokens: null,
161 ...geo,
162 input_tokens: 10,
163 output_tokens: 0,
164 service_tier: null
165 }
166 }
167 },
168 { type: "content_block_start", index: 0, content_block: { type: "text", text: "Hello" } },
169 { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Hello" } },
170 { type: "content_block_stop", index: 0 },
171 {
172 type: "message_delta",
173 delta: { stop_reason: "end_turn", stop_sequence: null },
174 usage: {
175 cache_creation_input_tokens: null,
176 cache_read_input_tokens: null,
177 input_tokens: null,
178 output_tokens: 5
179 }
180 },
181 { type: "message_stop" }
182 ]))
183 )
184 ))
185 )
186
187 const parts = yield* LanguageModel.streamText({ prompt: "Hello" }).pipe(
188 Stream.runCollect,
189 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
190 Effect.provide(layer)
191 )
192 assert.isTrue(
193 globalThis.Array.from(parts).some((part) => part.type === "text-delta" && part.delta === "Hello")
194 )
195 }))
196 }
197
198 it.effect("decodes thinking deltas without the beta token estimate", () =>
199 Effect.gen(function*() {
200 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
201 Layer.provide(Layer.succeed(
202 HttpClient.HttpClient,
203 makeHttpClient((request) =>
204 Effect.succeed(sseResponse(request, [
205 {
206 type: "message_start",
207 message: {
208 id: "msg_test_1",
209 type: "message",
210 role: "assistant",
211 model: "claude-sonnet-4-20250514",
212 content: [],
213 stop_reason: null,
214 stop_sequence: null,
215 usage: {
216 cache_creation: null,
217 cache_creation_input_tokens: null,
218 cache_read_input_tokens: null,
219 input_tokens: 10,
220 output_tokens: 0,
221 service_tier: null
222 }
223 }
224 },
225 {
226 type: "content_block_start",
227 index: 0,
228 content_block: { type: "thinking", thinking: "", signature: "" }
229 },
230 // The documented thinking delta, without `estimated_tokens` from the token-count beta
231 { type: "content_block_delta", index: 0, delta: { type: "thinking_delta", thinking: "Thinking..." } },
232 { type: "content_block_stop", index: 0 },
233 {
234 type: "message_delta",
235 delta: { stop_reason: "end_turn", stop_sequence: null },
236 usage: {
237 cache_creation_input_tokens: null,
238 cache_read_input_tokens: null,
239 input_tokens: null,
240 output_tokens: 5
241 }
242 },
243 { type: "message_stop" }
244 ]))
245 )
246 ))
247 )
248
249 const parts = yield* LanguageModel.streamText({ prompt: "Hello" }).pipe(
250 Stream.runCollect,
251 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
252 Effect.provide(layer)
253 )
254 assert.isTrue(
255 globalThis.Array.from(parts).some((part) => part.type === "reasoning-delta" && part.delta === "Thinking...")
256 )
257 }))
258
259 it.effect("decodes tool call params in content_block_stop", () =>
260 Effect.gen(function*() {
261 const toolParams = { pattern: "*.ts" }
262
263 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
264 Layer.provide(Layer.succeed(
265 HttpClient.HttpClient,
266 makeHttpClient((request) =>
267 Effect.succeed(sseResponse(request, [
268 {
269 type: "message_start",
270 message: {
271 id: "msg_test_1",
272 type: "message",
273 role: "assistant",
274 model: "claude-sonnet-4-20250514",
275 content: [],
276 stop_reason: null,
277 stop_sequence: null,
278 usage: {
279 cache_creation: null,
280 cache_creation_input_tokens: null,
281 cache_read_input_tokens: null,
282 inference_geo: null,
283 input_tokens: 10,
284 output_tokens: 0,
285 service_tier: null
286 }
287 }
288 },
289 {
290 type: "content_block_start",
291 index: 0,
292 content_block: {
293 type: "tool_use",
294 id: "toolu_test_1",
295 name: "GlobTool",
296 input: {}
297 }
298 },
299 {
300 type: "content_block_delta",
301 index: 0,
302 delta: {
303 type: "input_json_delta",
304 partial_json: JSON.stringify(toolParams)
305 }
306 },
307 {
308 type: "content_block_stop",
309 index: 0
310 },
311 {
312 type: "message_delta",
313 delta: {
314 stop_reason: "tool_use",
315 stop_sequence: null
316 },
317 usage: {
318 cache_creation_input_tokens: null,
319 cache_read_input_tokens: null,
320 input_tokens: null,
321 output_tokens: 5
322 }
323 },
324 {
325 type: "message_stop"
326 }
327 ]))
328 )
329 ))
330 )
331
332 const GlobTool = Tool.make("GlobTool", {
333 description: "Search for files",
334 parameters: Schema.Struct({ pattern: Schema.String }),
335 success: Schema.String
336 })
337
338 const toolkit = Toolkit.make(GlobTool)
339 const toolkitLayer = toolkit.toLayer({
340 GlobTool: () => Effect.succeed("found.ts")
341 })
342
343 const partsChunk = yield* LanguageModel.streamText({
344 prompt: "find ts files",
345 toolkit,
346 disableToolCallResolution: true
347 }).pipe(
348 Stream.runCollect,
349 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
350 Effect.provide(toolkitLayer),
351 Effect.provide(layer)
352 )
353
354 const parts = globalThis.Array.from(partsChunk)
355 const toolCall = parts.find((part) => part.type === "tool-call")
356 assert.isDefined(toolCall)
357 if (toolCall?.type !== "tool-call") {
358 return
359 }
360
361 assert.strictEqual(toolCall.name, "GlobTool")
362 assert.deepStrictEqual(toolCall.params, toolParams)
363 }))
364
365 it.effect("streams undeclared tool calls when tool call validation is deferred", () =>
366 Effect.gen(function*() {
367 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
368 Layer.provide(Layer.succeed(
369 HttpClient.HttpClient,
370 makeHttpClient((request) =>
371 Effect.succeed(sseResponse(request, [
372 {
373 type: "message_start",
374 message: {
375 id: "msg_test_1",
376 type: "message",
377 role: "assistant",
378 model: "claude-sonnet-4-20250514",
379 content: [],
380 stop_reason: null,
381 stop_sequence: null,
382 usage: {
383 cache_creation: null,
384 cache_creation_input_tokens: null,
385 cache_read_input_tokens: null,
386 inference_geo: null,
387 input_tokens: 10,
388 output_tokens: 0,
389 service_tier: null
390 }
391 }
392 },
393 {
394 type: "content_block_start",
395 index: 0,
396 content_block: { type: "tool_use", id: "toolu_test_1", name: "Write", input: {} }
397 },
398 {
399 type: "content_block_delta",
400 index: 0,
401 delta: { type: "input_json_delta", partial_json: JSON.stringify({ path: "a" }) }
402 },
403 { type: "content_block_stop", index: 0 },
404 {
405 type: "message_delta",
406 delta: { stop_reason: "tool_use", stop_sequence: null },
407 usage: {
408 cache_creation_input_tokens: null,
409 cache_read_input_tokens: null,
410 input_tokens: null,
411 output_tokens: 5
412 }
413 },
414 { type: "message_stop" }
415 ]))
416 )
417 ))
418 )
419 const Read = Tool.make("Read", {
420 parameters: Schema.Struct({ path: Schema.String }),
421 success: Schema.String
422 })
423 const toolkit = Toolkit.make(Read)
424
425 const parts = yield* LanguageModel.streamText({
426 prompt: "use the tools",
427 toolkit,
428 disableToolCallResolution: true,
429 toolCallValidation: "deferred"
430 }).pipe(
431 Stream.runCollect,
432 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
433 Effect.provide(toolkit.toLayer({ Read: () => Effect.succeed("") })),
434 Effect.provide(layer)
435 )
436
437 assert.deepStrictEqual(
438 parts.filter((part) => part.type === "tool-call").map(({ name, params }) => ({ name, params })),
439 [{ name: "Write", params: { path: "a" } }]
440 )
441 }))
442
443 for (const blockType of ["tool_use", "server_tool_use"] as const) {
444 it.effect(`fails with AiError for malformed streamed ${blockType} JSON`, () =>
445 Effect.gen(function*() {
446 const toolName = blockType === "tool_use" ? "GlobTool" : "web_search"
447 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
448 Layer.provide(Layer.succeed(
449 HttpClient.HttpClient,
450 makeHttpClient((request) =>
451 Effect.succeed(sseResponse(request, [
452 {
453 type: "message_start",
454 message: {
455 id: "msg_test_1",
456 type: "message",
457 role: "assistant",
458 model: "claude-sonnet-4-20250514",
459 content: [],
460 stop_reason: null,
461 stop_sequence: null,
462 usage: {
463 cache_creation: null,
464 cache_creation_input_tokens: null,
465 cache_read_input_tokens: null,
466 inference_geo: null,
467 input_tokens: 10,
468 output_tokens: 0,
469 service_tier: null
470 }
471 }
472 },
473 {
474 type: "content_block_start",
475 index: 0,
476 content_block: {
477 type: blockType,
478 id: blockType === "tool_use" ? "toolu_test_1" : "srvtoolu_test_1",
479 name: toolName,
480 input: {}
481 }
482 },
483 {
484 type: "content_block_delta",
485 index: 0,
486 delta: { type: "input_json_delta", partial_json: "{\"pattern\":" }
487 },
488 {
489 type: "content_block_delta",
490 index: 0,
491 delta: { type: "input_json_delta", partial_json: "\"*.ts" }
492 },
493 { type: "content_block_stop", index: 0 },
494 {
495 type: "message_delta",
496 delta: { stop_reason: "max_tokens", stop_sequence: null },
497 usage: {
498 cache_creation_input_tokens: null,
499 cache_read_input_tokens: null,
500 input_tokens: null,
501 output_tokens: 5
502 }
503 },
504 { type: "message_stop" }
505 ]))
506 )
507 ))
508 )
509 const toolkit = Toolkit.make(
510 Tool.make("GlobTool", { parameters: Schema.Struct({ pattern: Schema.String }) }),
511 AnthropicTool.WebSearch_20250305({})
512 )
513 const exit = yield* LanguageModel.streamText({
514 prompt: "find ts files",
515 toolkit,
516 disableToolCallResolution: true
517 }).pipe(
518 Stream.runCollect,
519 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
520 Effect.provide(layer),
521 Effect.exit
522 )
523
524 assert.isTrue(Exit.isFailure(exit))
525 if (!Exit.isFailure(exit)) {
526 return yield* Effect.die(new Error("Expected malformed tool JSON to fail"))
527 }
528 assert.isFalse(Cause.hasDies(exit.cause))
529 const error = Option.getOrThrow(Cause.findErrorOption(exit.cause))
530 assert.strictEqual(error._tag, "AiError")
531 assert.strictEqual(error.reason._tag, "ToolParameterValidationError")
532 }))
533 }
534
535 it.effect("routes invalid tool call params through failureMode: return without failing the stream", () =>
536 Effect.gen(function*() {
537 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
538 Layer.provide(Layer.succeed(
539 HttpClient.HttpClient,
540 makeHttpClient((request) =>
541 Effect.succeed(sseResponse(request, [
542 {
543 type: "message_start",
544 message: {
545 id: "msg_test_1",
546 type: "message",
547 role: "assistant",
548 model: "claude-sonnet-4-20250514",
549 content: [],
550 stop_reason: null,
551 stop_sequence: null,
552 usage: {
553 cache_creation: null,
554 cache_creation_input_tokens: null,
555 cache_read_input_tokens: null,
556 inference_geo: null,
557 input_tokens: 10,
558 output_tokens: 0,
559 service_tier: null
560 }
561 }
562 },
563 {
564 type: "content_block_start",
565 index: 0,
566 content_block: {
567 type: "tool_use",
568 id: "toolu_test_1",
569 name: "GlobTool",
570 input: {}
571 }
572 },
573 {
574 type: "content_block_delta",
575 index: 0,
576 delta: {
577 type: "input_json_delta",
578 partial_json: JSON.stringify({ pattern: 123 })
579 }
580 },
581 {
582 type: "content_block_stop",
583 index: 0
584 },
585 {
586 type: "message_delta",
587 delta: {
588 stop_reason: "tool_use",
589 stop_sequence: null
590 },
591 usage: {
592 cache_creation_input_tokens: null,
593 cache_read_input_tokens: null,
594 input_tokens: null,
595 output_tokens: 5
596 }
597 },
598 {
599 type: "message_stop"
600 }
601 ]))
602 )
603 ))
604 )
605
606 const GlobTool = Tool.make("GlobTool", {
607 description: "Search for files",
608 failureMode: "return",
609 parameters: Schema.Struct({ pattern: Schema.String }),
610 success: Schema.String,
611 failure: Schema.String
612 })
613
614 const toolkit = Toolkit.make(GlobTool)
615 const toolkitLayer = toolkit.toLayer({
616 GlobTool: () => Effect.succeed("found.ts")
617 })
618
619 const partsChunk = yield* LanguageModel.streamText({
620 prompt: "find ts files",
621 toolkit
622 }).pipe(
623 Stream.runCollect,
624 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
625 Effect.provide(toolkitLayer),
626 Effect.provide(layer)
627 )
628
629 const parts = globalThis.Array.from(partsChunk)
630 const toolResult = parts.find((part) => part.type === "tool-result")
631 assert.isDefined(toolResult)
632 if (toolResult?.type !== "tool-result") {
633 return
634 }
635
636 assert.strictEqual(toolResult.isFailure, true)
637 const failure = toolResult.result as AiError.AiError
638 assert.strictEqual(failure._tag, "AiError")
639 assert.strictEqual(failure.reason._tag, "ToolParameterValidationError")
640 }))
641
642 const codeExecutionCases = [
643 {
644 providerName: "bash_code_execution",
645 toolParams: { command: "pwd" },
646 expectedParams: { type: "bash_code_execution", command: "pwd" }
647 },
648 {
649 providerName: "text_editor_code_execution",
650 toolParams: { command: "view", path: "/tmp/example.txt" },
651 expectedParams: {
652 type: "text_editor_code_execution",
653 command: "view",
654 path: "/tmp/example.txt"
655 }
656 }
657 ] as const
658
659 for (const { expectedParams, providerName, toolParams } of codeExecutionCases) {
660 it.effect(`emits valid JSON for streamed ${providerName} parameters`, () =>
661 Effect.gen(function*() {
662 const toolkit = Toolkit.make(AnthropicTool.CodeExecution_20250522())
663 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
664 Layer.provide(Layer.succeed(
665 HttpClient.HttpClient,
666 makeHttpClient((request) =>
667 Effect.succeed(sseResponse(request, [
668 {
669 type: "message_start",
670 message: {
671 id: "msg_test_1",
672 type: "message",
673 role: "assistant",
674 model: "claude-sonnet-4-20250514",
675 content: [],
676 stop_reason: null,
677 stop_sequence: null,
678 usage: {
679 cache_creation: null,
680 cache_creation_input_tokens: null,
681 cache_read_input_tokens: null,
682 inference_geo: null,
683 input_tokens: 1,
684 output_tokens: 0,
685 service_tier: null
686 }
687 }
688 },
689 {
690 type: "content_block_start",
691 index: 0,
692 content_block: {
693 type: "server_tool_use",
694 id: "srvtoolu_test_1",
695 name: providerName,
696 input: {}
697 }
698 },
699 {
700 type: "content_block_delta",
701 index: 0,
702 delta: {
703 type: "input_json_delta",
704 partial_json: JSON.stringify(toolParams)
705 }
706 },
707 {
708 type: "content_block_stop",
709 index: 0
710 },
711 {
712 type: "message_delta",
713 delta: {
714 stop_reason: "tool_use",
715 stop_sequence: null
716 },
717 usage: {
718 cache_creation_input_tokens: null,
719 cache_read_input_tokens: null,
720 input_tokens: null,
721 output_tokens: 1
722 }
723 },
724 {
725 type: "message_stop"
726 }
727 ]))
728 )
729 ))
730 )
731
732 const partsChunk = yield* LanguageModel.streamText({
733 prompt: "run pwd",
734 toolkit,
735 disableToolCallResolution: true
736 }).pipe(
737 Stream.runCollect,
738 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
739 Effect.provide(layer)
740 )
741
742 const parts = globalThis.Array.from(partsChunk)
743
744 const delta = parts.find((part) => part.type === "tool-params-delta")
745 assert.isDefined(delta)
746 if (delta?.type === "tool-params-delta") {
747 assert.deepStrictEqual(JSON.parse(delta.delta), expectedParams)
748 }
749
750 const toolCall = parts.find((part) => part.type === "tool-call")
751 assert.isDefined(toolCall)
752 if (toolCall?.type === "tool-call") {
753 assert.deepStrictEqual(toolCall.params, expectedParams)
754 }
755 }))
756 }
757
758 // `Model` is an open enum in Anthropic's spec (`anyOf: [{ type: string }, ...consts]`), and it is
759 // $ref'd by response schemas. Responses must therefore decode for model ids that are newer than the
760 // generated literals, and the id must survive decoding unchanged.
761 it.effect("decodes responses for a model id that is not a known literal", () =>
762 Effect.gen(function*() {
763 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
764 Layer.provide(Layer.succeed(
765 HttpClient.HttpClient,
766 makeHttpClient((request) =>
767 Effect.succeed(sseResponse(request, [
768 {
769 type: "message_start",
770 message: {
771 id: "msg_test_1",
772 type: "message",
773 role: "assistant",
774 model: "claude-not-a-known-model-id",
775 content: [],
776 stop_reason: null,
777 stop_sequence: null,
778 usage: {
779 cache_creation: null,
780 cache_creation_input_tokens: null,
781 cache_read_input_tokens: null,
782 inference_geo: null,
783 input_tokens: 10,
784 output_tokens: 0,
785 service_tier: null
786 }
787 }
788 },
789 {
790 type: "content_block_start",
791 index: 0,
792 content_block: { type: "text", text: "" }
793 },
794 {
795 type: "content_block_delta",
796 index: 0,
797 delta: { type: "text_delta", text: "Hello" }
798 },
799 {
800 type: "content_block_stop",
801 index: 0
802 },
803 {
804 type: "message_delta",
805 delta: {
806 stop_reason: "end_turn",
807 stop_sequence: null
808 },
809 usage: {
810 cache_creation_input_tokens: null,
811 cache_read_input_tokens: null,
812 input_tokens: null,
813 output_tokens: 5
814 }
815 },
816 {
817 type: "message_stop"
818 }
819 ]))
820 )
821 ))
822 )
823
824 const partsChunk = yield* LanguageModel.streamText({
825 prompt: "say hello"
826 }).pipe(
827 Stream.runCollect,
828 Effect.provide(AnthropicLanguageModel.model("claude-not-a-known-model-id")),
829 Effect.provide(layer)
830 )
831
832 const parts = globalThis.Array.from(partsChunk)
833 const metadata = parts.find((part) => part.type === "response-metadata")
834 assert.isDefined(metadata)
835 if (metadata?.type !== "response-metadata") {
836 return
837 }
838
839 assert.strictEqual(metadata.modelId, "claude-not-a-known-model-id")
840
841 const text = parts.find((part) => part.type === "text-delta")
842 assert.isDefined(text)
843 if (text?.type !== "text-delta") {
844 return
845 }
846
847 assert.strictEqual(text.delta, "Hello")
848 }))
849
850 it.effect("emits response metadata for a fallback block", () =>
851 Effect.gen(function*() {
852 const fallback = {
853 type: "fallback",
854 from: { model: "claude-opus-5-5" },
855 to: { model: "claude-opus-4-8" },
856 trigger: { type: "refusal", category: "cyber" }
857 } as const
858 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
859 Layer.provide(Layer.succeed(
860 HttpClient.HttpClient,
861 makeHttpClient((request) =>
862 Effect.succeed(sseResponse(request, [
863 {
864 type: "message_start",
865 message: {
866 id: "msg_test_1",
867 type: "message",
868 role: "assistant",
869 model: "claude-opus-4-8",
870 content: [],
871 stop_reason: null,
872 stop_sequence: null,
873 usage: {
874 cache_creation: null,
875 cache_creation_input_tokens: null,
876 cache_read_input_tokens: null,
877 input_tokens: 10,
878 output_tokens: 0,
879 service_tier: null
880 }
881 }
882 },
883 { type: "content_block_start", index: 0, content_block: fallback },
884 { type: "content_block_stop", index: 0 },
885 {
886 type: "message_delta",
887 delta: { stop_reason: "end_turn", stop_sequence: null },
888 usage: {
889 cache_creation_input_tokens: null,
890 cache_read_input_tokens: null,
891 input_tokens: null,
892 output_tokens: 5
893 }
894 },
895 { type: "message_stop" }
896 ]))
897 )
898 ))
899 )
900
901 const parts = yield* LanguageModel.streamText({ prompt: "Hello" }).pipe(
902 Stream.runCollect,
903 Effect.provide(AnthropicLanguageModel.model("claude-opus-5-5")),
904 Effect.provide(layer)
905 )
906 const metadata = globalThis.Array.from(parts).find((part) =>
907 part.type === "response-metadata" && part.metadata.anthropic?.fallback !== undefined
908 )
909 assert.strictEqual(metadata?.type === "response-metadata" ? metadata.modelId : undefined, "claude-opus-4-8")
910 assert.deepStrictEqual(
911 metadata?.type === "response-metadata" ? metadata.metadata.anthropic?.fallback : undefined,
912 fallback
913 )
914 }))
915 })
916
917 describe("generateText", () => {
918 for (
919 const [label, geo] of [
920 ["missing", {}],
921 ["null", { inference_geo: null }],
922 ["string", { inference_geo: "us" }]
923 ] as const
924 ) {
925 it.effect(`accepts ${label} usage.inference_geo in a message response`, () =>
926 Effect.gen(function*() {
927 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
928 Layer.provide(Layer.succeed(
929 HttpClient.HttpClient,
930 makeHttpClient((request) =>
931 Effect.succeed(jsonResponse(request, {
932 id: "msg_test_1",
933 type: "message",
934 role: "assistant",
935 model: "claude-sonnet-4-20250514",
936 content: [{ type: "text", text: "Hello" }],
937 stop_reason: "end_turn",
938 stop_sequence: null,
939 usage: {
940 cache_creation: null,
941 cache_creation_input_tokens: null,
942 cache_read_input_tokens: null,
943 ...geo,
944 input_tokens: 10,
945 output_tokens: 5,
946 service_tier: null
947 }
948 }))
949 )
950 ))
951 )
952
953 const response = yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
954 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
955 Effect.provide(layer)
956 )
957 assert.isTrue(response.content.some((part) => part.type === "text" && part.text === "Hello"))
958 }))
959 }
960
961 it.effect("accepts minimal usage in a message response", () =>
962 Effect.gen(function*() {
963 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
964 Layer.provide(Layer.succeed(
965 HttpClient.HttpClient,
966 makeHttpClient((request) =>
967 Effect.succeed(jsonResponse(request, {
968 id: "msg_test_1",
969 type: "message",
970 role: "assistant",
971 model: "claude-sonnet-4-20250514",
972 content: [{ type: "text", text: "Hello" }],
973 stop_reason: "end_turn",
974 stop_sequence: null,
975 usage: { input_tokens: 3, output_tokens: 1 }
976 }))
977 )
978 ))
979 )
980
981 const response = yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
982 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
983 Effect.provide(layer)
984 )
985 assert.deepStrictEqual(response.usage.inputTokens, { uncached: 3, total: 3, cacheRead: 0, cacheWrite: 0 })
986 }))
987
988 it.effect("emits response metadata for a fallback block and keeps fallback usage iterations", () =>
989 Effect.gen(function*() {
990 const fallback = {
991 type: "fallback",
992 from: { model: "claude-opus-5-5" },
993 to: { model: "claude-opus-4-8" },
994 trigger: { type: "refusal", category: "cyber" }
995 } as const
996 const iterations = [
997 {
998 type: "message",
999 model: "claude-opus-5-5",
1000 cache_creation: null,
1001 cache_creation_input_tokens: 0,
1002 cache_read_input_tokens: 0,
1003 input_tokens: 10,
1004 output_tokens: 0
1005 },
1006 {
1007 type: "fallback_message",
1008 model: "claude-opus-4-8",
1009 cache_creation: null,
1010 cache_creation_input_tokens: 0,
1011 cache_read_input_tokens: 0,
1012 input_tokens: 10,
1013 output_tokens: 5
1014 }
1015 ] as const
1016 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1017 Layer.provide(Layer.succeed(
1018 HttpClient.HttpClient,
1019 makeHttpClient((request) =>
1020 Effect.succeed(jsonResponse(request, {
1021 id: "msg_test_1",
1022 type: "message",
1023 role: "assistant",
1024 model: "claude-opus-4-8",
1025 content: [fallback, { type: "text", text: "Hello" }],
1026 stop_reason: "end_turn",
1027 stop_sequence: null,
1028 usage: {
1029 cache_creation: null,
1030 cache_creation_input_tokens: null,
1031 cache_read_input_tokens: null,
1032 input_tokens: 10,
1033 output_tokens: 5,
1034 service_tier: null,
1035 iterations
1036 }
1037 }))
1038 )
1039 ))
1040 )
1041
1042 const response = yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
1043 Effect.provide(AnthropicLanguageModel.model("claude-opus-5-5")),
1044 Effect.provide(layer)
1045 )
1046 const metadata = response.content.find((part) =>
1047 part.type === "response-metadata" && part.metadata.anthropic?.fallback !== undefined
1048 )
1049 assert.strictEqual(metadata?.type === "response-metadata" ? metadata.modelId : undefined, "claude-opus-4-8")
1050 assert.deepStrictEqual(
1051 metadata?.type === "response-metadata" ? metadata.metadata.anthropic?.fallback : undefined,
1052 fallback
1053 )
1054 const finish = response.content.find((part) => part.type === "finish")
1055 assert.deepStrictEqual(
1056 finish?.type === "finish" ? finish.metadata.anthropic?.usage?.iterations : undefined,
1057 iterations
1058 )
1059 }))
1060
1061 it.effect("reports length when the model context window is exceeded", () =>
1062 Effect.gen(function*() {
1063 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1064 Layer.provide(Layer.succeed(
1065 HttpClient.HttpClient,
1066 makeHttpClient((request) =>
1067 Effect.succeed(jsonResponse(request, {
1068 id: "msg_test_1",
1069 type: "message",
1070 role: "assistant",
1071 model: "claude-sonnet-4-20250514",
1072 content: [{ type: "text", text: "Hello" }],
1073 stop_reason: "model_context_window_exceeded",
1074 stop_sequence: null,
1075 usage: {
1076 cache_creation: null,
1077 cache_creation_input_tokens: null,
1078 cache_read_input_tokens: null,
1079 input_tokens: 10,
1080 output_tokens: 5,
1081 service_tier: null
1082 }
1083 }))
1084 )
1085 ))
1086 )
1087
1088 const response = yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
1089 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
1090 Effect.provide(layer)
1091 )
1092 assert.strictEqual(response.finishReason, "length")
1093 }))
1094
1095 it.effect("reports total input tokens and cache usage on the span", () =>
1096 Effect.gen(function*() {
1097 const spans: Array<Tracer.NativeSpan> = []
1098 const tracer = Tracer.make({
1099 span(options) {
1100 const span = new Tracer.NativeSpan(options)
1101 spans.push(span)
1102 return span
1103 }
1104 })
1105 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1106 Layer.provide(Layer.succeed(
1107 HttpClient.HttpClient,
1108 makeHttpClient((request) =>
1109 Effect.succeed(jsonResponse(request, {
1110 id: "msg_test_1",
1111 type: "message",
1112 role: "assistant",
1113 model: "claude-sonnet-4-20250514",
1114 content: [{ type: "text", text: "Hello" }],
1115 stop_reason: "end_turn",
1116 stop_sequence: null,
1117 usage: {
1118 cache_creation: null,
1119 cache_creation_input_tokens: 20,
1120 cache_read_input_tokens: 30,
1121 input_tokens: 10,
1122 output_tokens: 5,
1123 service_tier: null
1124 }
1125 }))
1126 )
1127 ))
1128 )
1129
1130 yield* LanguageModel.generateText({ prompt: "Hello" }).pipe(
1131 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
1132 Effect.provide(layer),
1133 Effect.withTracer(tracer)
1134 )
1135 const span = spans.find((span) => span.name === "LanguageModel.generateText")
1136 assertDefined(span)
1137 const attributes = span.attributes
1138 assert.strictEqual(attributes.get("gen_ai.provider.name"), "anthropic")
1139 assert.strictEqual(attributes.get("gen_ai.usage.input_tokens"), 60)
1140 assert.strictEqual(attributes.get("gen_ai.usage.cache_read.input_tokens"), 30)
1141 assert.strictEqual(attributes.get("gen_ai.usage.cache_write.input_tokens"), 20)
1142 assert.strictEqual(attributes.get("gen_ai.usage.output_tokens"), 5)
1143 }))
1144
1145 it.effect("omits strictJsonSchema from the request while preserving tool strictness", () =>
1146 Effect.gen(function*() {
1147 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
1148 const model = "claude-sonnet-4-5"
1149 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1150 Layer.provide(Layer.succeed(
1151 HttpClient.HttpClient,
1152 makeHttpClient((request) => {
1153 capturedRequest = request
1154 return Effect.succeed(jsonResponse(request, {
1155 id: "msg_test_1",
1156 type: "message",
1157 role: "assistant",
1158 model,
1159 content: [{ type: "text", text: "Hello" }],
1160 stop_reason: "end_turn",
1161 stop_sequence: null,
1162 usage: {
1163 cache_creation: null,
1164 cache_creation_input_tokens: null,
1165 cache_read_input_tokens: null,
1166 inference_geo: null,
1167 input_tokens: 1,
1168 output_tokens: 1,
1169 service_tier: null
1170 }
1171 }))
1172 })
1173 ))
1174 )
1175
1176 yield* LanguageModel.generateText({
1177 prompt: "Hello",
1178 toolkit: Toolkit.make(Tool.make("Search", {
1179 parameters: Schema.Struct({ query: Schema.String }),
1180 success: Schema.String
1181 })),
1182 disableToolCallResolution: true
1183 }).pipe(
1184 Effect.provide(AnthropicLanguageModel.model(model, { strictJsonSchema: false })),
1185 Effect.provide(layer)
1186 )
1187
1188 assert.isDefined(capturedRequest)
1189 const body = yield* getRequestBody(capturedRequest)
1190 assert.strictEqual(body.model, model)
1191 assert.strictEqual(body.tools[0].name, "Search")
1192 assert.strictEqual(body.tools[0].strict, false)
1193 assert.notProperty(body, "strictJsonSchema")
1194 }))
1195
1196 it.effect("preserves string tool results", () =>
1197 Effect.gen(function*() {
1198 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
1199 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1200 Layer.provide(Layer.succeed(
1201 HttpClient.HttpClient,
1202 makeHttpClient((request) => {
1203 capturedRequest = request
1204 return Effect.succeed(jsonResponse(request, {
1205 id: "msg_test_1",
1206 type: "message",
1207 role: "assistant",
1208 model: "claude-sonnet-4-20250514",
1209 content: [{ type: "text", text: "Done" }],
1210 stop_reason: "end_turn",
1211 stop_sequence: null,
1212 usage: {
1213 cache_creation: null,
1214 cache_creation_input_tokens: null,
1215 cache_read_input_tokens: null,
1216 inference_geo: null,
1217 input_tokens: 10,
1218 output_tokens: 5,
1219 service_tier: null
1220 }
1221 }))
1222 })
1223 ))
1224 )
1225
1226 yield* LanguageModel.generateText({
1227 prompt: Prompt.make([
1228 { role: "user", content: "Use the tool" },
1229 {
1230 role: "assistant",
1231 content: [Prompt.toolCallPart({
1232 id: "call_text",
1233 name: "text_tool",
1234 params: {},
1235 providerExecuted: false
1236 })]
1237 },
1238 {
1239 role: "tool",
1240 content: [Prompt.toolResultPart({
1241 id: "call_text",
1242 name: "text_tool",
1243 result: "PLAIN_TEXT_SENTINEL\n",
1244 isFailure: false,
1245 providerExecuted: false
1246 })]
1247 }
1248 ]),
1249 disableToolCallResolution: true
1250 }).pipe(
1251 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
1252 Effect.provide(layer)
1253 )
1254
1255 assert.isDefined(capturedRequest)
1256 if (capturedRequest === undefined) {
1257 return
1258 }
1259
1260 const body = yield* getRequestBody(capturedRequest)
1261 const toolResult = body.messages
1262 .flatMap((message: any) => Array.isArray(message.content) ? message.content : [])
1263 .find((block: any) => block.type === "tool_result")
1264
1265 assert.isDefined(toolResult)
1266 assert.strictEqual(toolResult.content, "PLAIN_TEXT_SENTINEL\n")
1267 }))
1268
1269 const png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVR4nGP4DwQACfsD/fteaysAAAAASUVORK5CYII="
1270 const pdf = "JVBERi0xLjcK"
1271 const modelOutputCases = [
1272 {
1273 label: "as native content blocks",
1274 modelOutput: [
1275 Prompt.textPart({ text: "Screenshot of /home" }),
1276 Prompt.filePart({ mediaType: "image/png", data: png }),
1277 Prompt.filePart({ mediaType: "application/pdf", data: `data:application/pdf;base64,${pdf}` })
1278 ],
1279 content: [
1280 { type: "text", text: "Screenshot of /home" },
1281 { type: "image", source: { type: "base64", media_type: "image/png", data: png } },
1282 { type: "document", source: { type: "base64", media_type: "application/pdf", data: pdf }, title: null }
1283 ]
1284 },
1285 { label: "without the result when it is empty", modelOutput: [], content: "" }
1286 ]
1287
1288 for (const { content, label, modelOutput } of modelOutputCases) {
1289 it.effect(`sends tool result model output ${label}`, () =>
1290 Effect.gen(function*() {
1291 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
1292 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1293 Layer.provide(Layer.succeed(
1294 HttpClient.HttpClient,
1295 makeHttpClient((request) => {
1296 capturedRequest = request
1297 return Effect.succeed(jsonResponse(request, {
1298 id: "msg_test_1",
1299 type: "message",
1300 role: "assistant",
1301 model: "claude-sonnet-4-20250514",
1302 content: [{ type: "text", text: "Done" }],
1303 stop_reason: "end_turn",
1304 stop_sequence: null,
1305 usage: {
1306 cache_creation: null,
1307 cache_creation_input_tokens: null,
1308 cache_read_input_tokens: null,
1309 inference_geo: null,
1310 input_tokens: 1,
1311 output_tokens: 1,
1312 service_tier: null
1313 }
1314 }))
1315 })
1316 ))
1317 )
1318
1319 yield* LanguageModel.generateText({
1320 prompt: Prompt.make([
1321 { role: "user", content: "Take a screenshot" },
1322 {
1323 role: "assistant",
1324 content: [Prompt.toolCallPart({
1325 id: "call_screenshot",
1326 name: "screenshot",
1327 params: {},
1328 providerExecuted: false
1329 })]
1330 },
1331 {
1332 role: "tool",
1333 content: [Prompt.toolResultPart({
1334 id: "call_screenshot",
1335 name: "screenshot",
1336 result: { path: "/home", png },
1337 modelOutput,
1338 isFailure: false,
1339 providerExecuted: false
1340 })]
1341 }
1342 ]),
1343 disableToolCallResolution: true
1344 }).pipe(
1345 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
1346 Effect.provide(layer)
1347 )
1348
1349 assert.isDefined(capturedRequest)
1350 const body = yield* getRequestBody(capturedRequest)
1351 const toolResult = body.messages
1352 .flatMap((message: any) => Array.isArray(message.content) ? message.content : [])
1353 .find((block: any) => block.type === "tool_result")
1354
1355 assert.strictEqual(toolResult.tool_use_id, "call_screenshot")
1356 assert.deepStrictEqual(
1357 Array.isArray(toolResult.content)
1358 ? toolResult.content.map(({ cache_control: _, ...block }: any) => block)
1359 : toolResult.content,
1360 content
1361 )
1362 }))
1363 }
1364
1365 it.effect("preserves base64 image string payloads", () =>
1366 Effect.gen(function*() {
1367 const base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVR4nGP4DwQACfsD/fteaysAAAAASUVORK5CYII="
1368 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
1369 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1370 Layer.provide(Layer.succeed(
1371 HttpClient.HttpClient,
1372 makeHttpClient((request) => {
1373 capturedRequest = request
1374 return Effect.succeed(jsonResponse(request, {
1375 id: "msg_test_1",
1376 type: "message",
1377 role: "assistant",
1378 model: "claude-sonnet-4-20250514",
1379 content: [{ type: "text", text: "Done" }],
1380 stop_reason: "end_turn",
1381 stop_sequence: null,
1382 usage: {
1383 cache_creation: null,
1384 cache_creation_input_tokens: null,
1385 cache_read_input_tokens: null,
1386 inference_geo: null,
1387 input_tokens: 1,
1388 output_tokens: 1,
1389 service_tier: null
1390 }
1391 }))
1392 })
1393 ))
1394 )
1395
1396 yield* LanguageModel.generateText({
1397 prompt: Prompt.make([Prompt.userMessage({
1398 content: [Prompt.filePart({ mediaType: "image/png", data: base64 })]
1399 })])
1400 }).pipe(
1401 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
1402 Effect.provide(layer)
1403 )
1404
1405 assert.isDefined(capturedRequest)
1406 const body = yield* getRequestBody(capturedRequest)
1407 assert.strictEqual(body.messages[0].content[0].source.data, base64)
1408 }))
1409
1410 it.effect("encodes dynamic tools", () =>
1411 Effect.gen(function*() {
1412 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
1413 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1414 Layer.provide(Layer.succeed(
1415 HttpClient.HttpClient,
1416 makeHttpClient((request) => {
1417 capturedRequest = request
1418 return Effect.succeed(jsonResponse(request, {
1419 id: "msg_test_1",
1420 type: "message",
1421 role: "assistant",
1422 model: "claude-sonnet-4-20250514",
1423 content: [{ type: "text", text: "Done" }],
1424 stop_reason: "end_turn",
1425 stop_sequence: null,
1426 usage: {
1427 cache_creation: null,
1428 cache_creation_input_tokens: null,
1429 cache_read_input_tokens: null,
1430 inference_geo: null,
1431 input_tokens: 10,
1432 output_tokens: 5,
1433 service_tier: null
1434 }
1435 }))
1436 })
1437 ))
1438 )
1439
1440 const inputSchema = {
1441 properties: {
1442 query: { type: "string" }
1443 }
1444 } as const
1445
1446 const DynamicTool = Tool.dynamic("DynamicTool", {
1447 description: "A dynamic tool",
1448 parameters: inputSchema
1449 })
1450
1451 yield* LanguageModel.generateText({
1452 prompt: "Use the dynamic tool",
1453 toolkit: Toolkit.make(DynamicTool),
1454 disableToolCallResolution: true
1455 }).pipe(
1456 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
1457 Effect.provide(layer)
1458 )
1459
1460 assert.isDefined(capturedRequest)
1461 if (capturedRequest === undefined) {
1462 return
1463 }
1464
1465 const body = yield* getRequestBody(capturedRequest)
1466 const dynamicTool = body.tools.find((tool: any) => tool.name === "DynamicTool")
1467
1468 assert.isDefined(dynamicTool)
1469 if (dynamicTool === undefined) {
1470 return
1471 }
1472
1473 assert.strictEqual(dynamicTool.description, "A dynamic tool")
1474 assert.deepStrictEqual(dynamicTool.input_schema, inputSchema)
1475 }))
1476
1477 it.effect("names the tool when its parameters are not an object schema", () =>
1478 Effect.gen(function*() {
1479 const error = yield* LanguageModel.generateText({
1480 prompt: "Use the tool",
1481 toolkit: Toolkit.make(Tool.make("NoParams", { parameters: Schema.Struct({}) })),
1482 disableToolCallResolution: true
1483 }).pipe(
1484 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
1485 Effect.provide(AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") })),
1486 Effect.provideService(HttpClient.HttpClient, makeHttpClient(() => Effect.die("unexpected request"))),
1487 Effect.flip
1488 )
1489
1490 assert.strictEqual(error.reason._tag, "UnsupportedSchemaError")
1491 assert.include(error.message, `"NoParams"`)
1492 assert.include(error.message, "Tool.EmptyParams")
1493 }))
1494
1495 it.effect("sends recursive parameters for a non-strict tool and returns nested tool call params", () =>
1496 Effect.gen(function*() {
1497 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
1498 const model = "claude-sonnet-4-5"
1499 const params = { filter: { name: null, OR: [{ name: "Anna" }, { name: "Ben" }] } }
1500 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1501 Layer.provide(Layer.succeed(
1502 HttpClient.HttpClient,
1503 makeHttpClient((request) => {
1504 capturedRequest = request
1505 return Effect.succeed(jsonResponse(request, {
1506 id: "msg_test_1",
1507 type: "message",
1508 role: "assistant",
1509 model,
1510 content: [{ type: "tool_use", id: "toolu_test_1", name: "ListContacts", input: params }],
1511 stop_reason: "tool_use",
1512 stop_sequence: null,
1513 usage: {
1514 cache_creation: null,
1515 cache_creation_input_tokens: null,
1516 cache_read_input_tokens: null,
1517 inference_geo: null,
1518 input_tokens: 1,
1519 output_tokens: 1,
1520 service_tier: null
1521 }
1522 }))
1523 })
1524 ))
1525 )
1526
1527 const response = yield* LanguageModel.generateText({
1528 prompt: "Find the contacts named Anna or Ben",
1529 toolkit: Toolkit.make(RecursiveFilterTool),
1530 disableToolCallResolution: true
1531 }).pipe(
1532 Effect.provide(AnthropicLanguageModel.model(model, { strictJsonSchema: false })),
1533 Effect.provide(layer)
1534 )
1535
1536 assert.isDefined(capturedRequest)
1537 const body = yield* getRequestBody(capturedRequest)
1538 assert.strictEqual(body.tools[0].strict, false)
1539 const inputSchema = body.tools[0].input_schema
1540 assert.strictEqual(inputSchema.type, "object")
1541 assert.deepStrictEqual(inputSchema.properties.filter, { $ref: "#/$defs/Filter" })
1542 assert.deepStrictEqual(inputSchema.$defs.Filter.properties.OR.items, { $ref: "#/$defs/Filter" })
1543 assert.strictEqual(response.toolCalls.length, 1)
1544 const { filter } = response.toolCalls[0].params
1545 assert.isUndefined(filter.name)
1546 assert.deepStrictEqual(filter.OR, [{ name: "Anna" }, { name: "Ben" }])
1547 }))
1548
1549 it.effect("rejects recursive parameters for a strict tool", () =>
1550 Effect.gen(function*() {
1551 const error = yield* LanguageModel.generateText({
1552 prompt: "Find the contacts named Anna or Ben",
1553 toolkit: Toolkit.make(RecursiveFilterTool),
1554 disableToolCallResolution: true
1555 }).pipe(
1556 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-5")),
1557 Effect.provide(AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") })),
1558 Effect.provideService(HttpClient.HttpClient, makeHttpClient(() => Effect.die("unexpected request"))),
1559 Effect.flip
1560 )
1561
1562 assert.strictEqual(error.reason._tag, "UnsupportedSchemaError")
1563 assert.include(error.message, "Recursive schemas are not supported")
1564 }))
1565
1566 it.effect("serializes provider-executed web_search parts from the assistant message", () =>
1567 Effect.gen(function*() {
1568 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
1569 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1570 Layer.provide(Layer.succeed(
1571 HttpClient.HttpClient,
1572 makeHttpClient((request) => {
1573 capturedRequest = request
1574 return Effect.succeed(jsonResponse(request, {
1575 id: "msg_test_2",
1576 type: "message",
1577 role: "assistant",
1578 model: "claude-sonnet-4-20250514",
1579 content: [{ type: "text", text: "You're welcome" }],
1580 stop_reason: "end_turn",
1581 stop_sequence: null,
1582 usage: {
1583 cache_creation: null,
1584 cache_creation_input_tokens: null,
1585 cache_read_input_tokens: null,
1586 inference_geo: null,
1587 input_tokens: 10,
1588 output_tokens: 5,
1589 service_tier: null
1590 }
1591 }))
1592 })
1593 ))
1594 )
1595
1596 const searchResults = [{
1597 type: "web_search_result",
1598 url: "https://example.com/gold",
1599 title: "Gold price",
1600 encrypted_content: "encrypted",
1601 page_age: null
1602 }]
1603
1604 const history = Prompt.fromResponseParts([
1605 AiResponse.makePart("tool-call", {
1606 id: "srvtoolu_1",
1607 name: "AnthropicWebSearch",
1608 params: { query: "gold price today" },
1609 providerExecuted: true
1610 }),
1611 AiResponse.makePart("tool-result", {
1612 id: "srvtoolu_1",
1613 name: "AnthropicWebSearch",
1614 isFailure: false,
1615 result: searchResults,
1616 encodedResult: searchResults,
1617 preliminary: false,
1618 providerExecuted: true
1619 }),
1620 AiResponse.makePart("text", { text: "Gold is around $4,000." })
1621 ])
1622
1623 const prompt = Prompt.concat(
1624 Prompt.concat(Prompt.make("what is the gold price?"), history),
1625 Prompt.make("thanks")
1626 )
1627
1628 yield* LanguageModel.generateText({
1629 prompt,
1630 toolkit: Toolkit.make(AnthropicTool.WebSearch_20250305({})),
1631 disableToolCallResolution: true
1632 }).pipe(
1633 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
1634 Effect.provide(layer)
1635 )
1636
1637 assert.isDefined(capturedRequest)
1638 if (capturedRequest === undefined) {
1639 return
1640 }
1641
1642 const body = yield* getRequestBody(capturedRequest)
1643 const assistantMessage = body.messages.find((message: any) => message.role === "assistant")
1644 assert.isDefined(assistantMessage)
1645
1646 const serverToolUse = assistantMessage.content.find((block: any) => block.type === "server_tool_use")
1647 assert.isDefined(serverToolUse)
1648 assert.strictEqual(serverToolUse.id, "srvtoolu_1")
1649 assert.strictEqual(serverToolUse.name, "web_search")
1650
1651 const searchResult = assistantMessage.content.find((block: any) => block.type === "web_search_tool_result")
1652 assert.isDefined(searchResult)
1653 assert.strictEqual(searchResult.tool_use_id, "srvtoolu_1")
1654
1655 const clientToolResults = body.messages.flatMap((message: any) =>
1656 Array.isArray(message.content)
1657 ? message.content.filter((block: any) => block.type === "tool_result")
1658 : []
1659 )
1660 assert.strictEqual(clientToolResults.length, 0)
1661 }))
1662
1663 it.effect("encodes plaintext bytes as UTF-8 text", () =>
1664 Effect.gen(function*() {
1665 let body: any
1666 const client = AnthropicClient.layer({ apiKey: Redacted.make("test") }).pipe(
1667 Layer.provide(Layer.succeed(
1668 HttpClient.HttpClient,
1669 HttpClient.makeWith(
1670 Effect.fnUntraced(function*(requestEffect) {
1671 const request = yield* requestEffect
1672 body = JSON.parse(new TextDecoder().decode((request.body as any).body))
1673 return HttpClientResponse.fromWeb(
1674 request,
1675 new Response(
1676 JSON.stringify({
1677 id: "msg_1",
1678 type: "message",
1679 role: "assistant",
1680 model: "claude-sonnet-4-20250514",
1681 content: [{ type: "text", text: "ok" }],
1682 stop_reason: "end_turn",
1683 stop_sequence: null,
1684 usage: {
1685 cache_creation: null,
1686 cache_creation_input_tokens: null,
1687 cache_read_input_tokens: null,
1688 inference_geo: null,
1689 input_tokens: 1,
1690 output_tokens: 1,
1691 service_tier: null
1692 }
1693 }),
1694 { status: 200 }
1695 )
1696 )
1697 }),
1698 Effect.succeed as HttpClient.HttpClient.Preprocess<HttpClientError.HttpClientError, never>
1699 )
1700 ))
1701 )
1702
1703 yield* LanguageModel.generateText({
1704 prompt: Prompt.make([{
1705 role: "user",
1706 content: [Prompt.filePart({ mediaType: "text/plain", data: new TextEncoder().encode("hello") })]
1707 }])
1708 }).pipe(
1709 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
1710 Effect.provide(client)
1711 )
1712
1713 assert.strictEqual(body.messages[0].content[0].source.data, "hello")
1714 }))
1715 })
1716
1717 describe("generateObject", () => {
1718 const getRequest = Effect.fnUntraced(function*(
1719 model: string,
1720 config?: { readonly structuredOutputs?: boolean | undefined }
1721 ) {
1722 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
1723 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1724 Layer.provide(Layer.succeed(
1725 HttpClient.HttpClient,
1726 makeHttpClient((request) => {
1727 capturedRequest = request
1728 return Effect.succeed(jsonResponse(request, {
1729 id: "msg_test_1",
1730 type: "message",
1731 role: "assistant",
1732 model,
1733 content: [{ type: "text", text: JSON.stringify({ name: "John", age: 30 }) }],
1734 stop_reason: "end_turn",
1735 stop_sequence: null,
1736 usage: {
1737 cache_creation: null,
1738 cache_creation_input_tokens: null,
1739 cache_read_input_tokens: null,
1740 inference_geo: null,
1741 input_tokens: 10,
1742 output_tokens: 5,
1743 service_tier: null
1744 }
1745 }))
1746 })
1747 ))
1748 )
1749
1750 // Assert the request shape; the response outcome is irrelevant here.
1751 yield* LanguageModel.generateObject({
1752 prompt: "Give me a person",
1753 schema: Schema.Struct({ name: Schema.String, age: Schema.Number })
1754 }).pipe(
1755 Effect.provide(AnthropicLanguageModel.model(model, config)),
1756 Effect.provide(layer),
1757 Effect.ignore
1758 )
1759
1760 assert.isDefined(capturedRequest)
1761 if (capturedRequest === undefined) {
1762 return yield* Effect.die(new Error("Expected a captured request"))
1763 }
1764
1765 return yield* getRequestBody(capturedRequest)
1766 })
1767
1768 it.effect("uses native structured output and 128K for Claude 4.6", () =>
1769 Effect.gen(function*() {
1770 const body = yield* getRequest("claude-opus-4-6")
1771
1772 assert.strictEqual(body.max_tokens, 128000)
1773 assert.strictEqual(body.output_config?.format?.type, "json_schema")
1774 }))
1775
1776 it.effect("uses optimistic modern defaults for an unknown future model", () =>
1777 Effect.gen(function*() {
1778 const body = yield* getRequest("claude-sonnet-6-0")
1779
1780 assert.strictEqual(body.max_tokens, 128000)
1781 assert.strictEqual(body.output_config?.format?.type, "json_schema")
1782 }))
1783
1784 it.effect("preserves frozen legacy model exceptions", () =>
1785 Effect.gen(function*() {
1786 const body = yield* getRequest("claude-sonnet-4-20250514")
1787
1788 assert.strictEqual(body.max_tokens, 64000)
1789 assert.isUndefined(body.output_config)
1790 }))
1791
1792 it.effect("can disable structured outputs for a modern model", () =>
1793 Effect.gen(function*() {
1794 const body = yield* getRequest("claude-sonnet-6-0", { structuredOutputs: false })
1795
1796 assert.strictEqual(body.max_tokens, 128000)
1797 assert.isUndefined(body.output_config)
1798 assert.notProperty(body, "structuredOutputs")
1799 }))
1800
1801 it.effect("can enable structured outputs for a legacy model", () =>
1802 Effect.gen(function*() {
1803 const body = yield* getRequest("claude-sonnet-4-20250514", { structuredOutputs: true })
1804
1805 assert.strictEqual(body.max_tokens, 64000)
1806 assert.strictEqual(body.output_config?.format?.type, "json_schema")
1807 assert.notProperty(body, "structuredOutputs")
1808 }))
1809
1810 const summaryResponse = (request: HttpClientRequest.HttpClientRequest, content: ReadonlyArray<unknown>) =>
1811 jsonResponse(request, {
1812 id: "msg_summary",
1813 type: "message",
1814 role: "assistant",
1815 model: "claude-sonnet-4-6",
1816 content,
1817 stop_reason: "tool_use",
1818 stop_sequence: null,
1819 usage: {
1820 cache_creation: null,
1821 cache_creation_input_tokens: null,
1822 cache_read_input_tokens: null,
1823 inference_geo: null,
1824 input_tokens: 1,
1825 output_tokens: 1,
1826 service_tier: null
1827 }
1828 })
1829
1830 it.effect("forces the fallback response tool and decodes its input alongside prose", () =>
1831 Effect.gen(function*() {
1832 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1833 Layer.provide(Layer.succeed(
1834 HttpClient.HttpClient,
1835 makeHttpClient((request) =>
1836 Effect.gen(function*() {
1837 const body = yield* getRequestBody(request)
1838 assert.deepStrictEqual(body.tools?.map((tool: { name: string }) => tool.name), ["summary"])
1839 assert.deepStrictEqual(body.tool_choice, {
1840 type: "tool",
1841 name: "summary",
1842 disable_parallel_tool_use: true
1843 })
1844 return summaryResponse(request, [
1845 { type: "text", text: "Here is the summary." },
1846 { type: "tool_use", id: "toolu_summary", name: "summary", input: { title: "Rain" } }
1847 ])
1848 })
1849 )
1850 ))
1851 )
1852
1853 const response = yield* LanguageModel.generateObject({
1854 prompt: "Give a title for a story about rain.",
1855 objectName: "summary",
1856 schema: Schema.Struct({ title: Schema.String })
1857 }).pipe(
1858 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-6", { structuredOutputs: false })),
1859 Effect.provide(layer)
1860 )
1861
1862 assert.deepStrictEqual(response.value, { title: "Rain" })
1863 }))
1864
1865 it.effect("decodes native JSON alongside an ordinary tool call", () =>
1866 Effect.gen(function*() {
1867 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1868 Layer.provide(Layer.succeed(
1869 HttpClient.HttpClient,
1870 makeHttpClient((request) =>
1871 Effect.succeed(summaryResponse(request, [
1872 { type: "text", text: JSON.stringify({ title: "Rain" }) },
1873 { type: "tool_use", id: "toolu_weather", name: "Weather", input: { city: "SF" } }
1874 ]))
1875 )
1876 ))
1877 )
1878 const toolkit = Toolkit.make(Tool.make("Weather", {
1879 parameters: Schema.Struct({ city: Schema.String }),
1880 success: Schema.String
1881 }))
1882
1883 const response = yield* LanguageModel.generateObject({
1884 prompt: "Give a title for a story about rain.",
1885 objectName: "summary",
1886 schema: Schema.Struct({ title: Schema.String }),
1887 toolkit
1888 }).pipe(
1889 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-6")),
1890 Effect.provide(toolkit.toLayer({ Weather: () => Effect.succeed("Rain") })),
1891 Effect.provide(layer)
1892 )
1893
1894 assert.deepStrictEqual(response.value, { title: "Rain" })
1895 assert.strictEqual(response.toolCalls[0]?.name, "Weather")
1896 }))
1897 })
1898
1899 describe("system messages", () => {
1900 const getRequest = Effect.fnUntraced(function*(
1901 model: string,
1902 prompt: Prompt.RawInput,
1903 config?: { readonly midConversationSystemMessages?: boolean | undefined }
1904 ) {
1905 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
1906 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
1907 Layer.provide(Layer.succeed(
1908 HttpClient.HttpClient,
1909 makeHttpClient((request) => {
1910 capturedRequest = request
1911 return Effect.succeed(jsonResponse(request, {
1912 id: "msg_test_1",
1913 type: "message",
1914 role: "assistant",
1915 model,
1916 content: [{ type: "text", text: "Done" }],
1917 stop_reason: "end_turn",
1918 stop_sequence: null,
1919 usage: {
1920 cache_creation: null,
1921 cache_creation_input_tokens: null,
1922 cache_read_input_tokens: null,
1923 inference_geo: null,
1924 input_tokens: 1,
1925 output_tokens: 1,
1926 service_tier: null
1927 }
1928 }))
1929 })
1930 ))
1931 )
1932
1933 yield* LanguageModel.generateText({ prompt, disableToolCallResolution: true }).pipe(
1934 Effect.provide(AnthropicLanguageModel.model(model, config)),
1935 Effect.provide(layer)
1936 )
1937
1938 if (capturedRequest === undefined) {
1939 return yield* Effect.die(new Error("Expected a captured request"))
1940 }
1941 return yield* getRequestBody(capturedRequest)
1942 })
1943
1944 const conversation = Prompt.make([
1945 { role: "system", content: "A" },
1946 { role: "user", content: "Question 1" },
1947 { role: "assistant", content: "Answer 1" },
1948 { role: "system", content: "B" },
1949 { role: "user", content: "Question 2" }
1950 ])
1951
1952 it.effect("sends later system messages after the next user turn", () =>
1953 Effect.gen(function*() {
1954 const body = yield* getRequest("claude-sonnet-5-5", conversation)
1955
1956 assert.deepStrictEqual(body.system.map((block: any) => block.text), ["A"])
1957 assert.deepStrictEqual(body.messages.map((message: any) => message.role), [
1958 "user",
1959 "assistant",
1960 "user",
1961 "system"
1962 ])
1963 assert.deepStrictEqual(body.messages.at(-1), {
1964 role: "system",
1965 content: [{ type: "text", text: "B", cache_control: null }]
1966 })
1967 }))
1968
1969 it.effect("sends every system message top-level when disabled", () =>
1970 Effect.gen(function*() {
1971 const body = yield* getRequest("claude-sonnet-5-5", conversation, { midConversationSystemMessages: false })
1972
1973 assert.deepStrictEqual(body.system.map((block: any) => block.text), ["A", "B"])
1974 assert.deepStrictEqual(body.messages.map((message: any) => message.role), ["user", "assistant", "user"])
1975 assert.notProperty(body, "midConversationSystemMessages")
1976 }))
1977
1978 it.effect("sends every system message top-level in order when one cannot follow a user turn", () =>
1979 Effect.gen(function*() {
1980 const body = yield* getRequest(
1981 "claude-sonnet-5-5",
1982 Prompt.make([
1983 { role: "system", content: "A" },
1984 { role: "user", content: "Question" },
1985 { role: "system", content: "B" },
1986 { role: "assistant", content: "Answer" },
1987 { role: "system", content: "C" }
1988 ])
1989 )
1990
1991 assert.deepStrictEqual(body.system.map((block: any) => block.text), ["A", "B", "C"])
1992 assert.deepStrictEqual(body.messages.map((message: any) => message.role), ["user", "assistant"])
1993 }))
1994
1995 it.effect("reports support for the requested model", () =>
1996 Effect.gen(function*() {
1997 const model = yield* LanguageModel.LanguageModel
1998
1999 assert.isTrue(yield* model.supportsSystemMessagesInHistory!)
2000 assert.isFalse(
2001 yield* model.supportsSystemMessagesInHistory!.pipe(
2002 AnthropicLanguageModel.withConfigOverride({ model: "claude-sonnet-5" })
2003 )
2004 )
2005 }).pipe(
2006 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-5-5")),
2007 Effect.provide(AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") })),
2008 Effect.provide(Layer.succeed(HttpClient.HttpClient, makeHttpClient(() => Effect.die("unexpected request"))))
2009 ))
2010 })
2011
2012 describe("assistant cache control", () => {
2013 const ephemeral = { type: "ephemeral" } as const
2014 const cached = { anthropic: { cacheControl: ephemeral } }
2015
2016 const getAssistantContent = Effect.fnUntraced(function*(prompt: Prompt.RawInput) {
2017 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
2018 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
2019 Layer.provide(Layer.succeed(
2020 HttpClient.HttpClient,
2021 makeHttpClient((request) => {
2022 capturedRequest = request
2023 return Effect.succeed(jsonResponse(request, {
2024 id: "msg_test_1",
2025 type: "message",
2026 role: "assistant",
2027 model: "claude-sonnet-4-20250514",
2028 content: [{ type: "text", text: "Done" }],
2029 stop_reason: "end_turn",
2030 stop_sequence: null,
2031 usage: {
2032 cache_creation: null,
2033 cache_creation_input_tokens: null,
2034 cache_read_input_tokens: null,
2035 inference_geo: null,
2036 input_tokens: 1,
2037 output_tokens: 1,
2038 service_tier: null
2039 }
2040 }))
2041 })
2042 ))
2043 )
2044
2045 yield* LanguageModel.generateText({ prompt, disableToolCallResolution: true }).pipe(
2046 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
2047 Effect.provide(layer)
2048 )
2049
2050 if (capturedRequest === undefined) {
2051 return yield* Effect.die(new Error("Expected a captured request"))
2052 }
2053 const body = yield* getRequestBody(capturedRequest)
2054 return body.messages.find((message: any) => message.role === "assistant").content as Array<any>
2055 })
2056
2057 const thinking = {
2058 type: "reasoning",
2059 text: "Thinking",
2060 options: { anthropic: { info: { type: "thinking", signature: "sig" } } }
2061 } as const
2062
2063 const redactedThinking = {
2064 type: "reasoning",
2065 text: "",
2066 options: { anthropic: { info: { type: "redacted_thinking", redactedData: "hidden" } } }
2067 } as const
2068
2069 it.effect("places part and message breakpoints without overriding a part's TTL", () =>
2070 Effect.gen(function*() {
2071 const oneHour = { type: "ephemeral", ttl: "1h" } as const
2072 const content = yield* getAssistantContent([
2073 { role: "user", content: "Question" },
2074 {
2075 role: "assistant",
2076 content: [
2077 { type: "text", text: "Answer", options: { anthropic: { cacheControl: oneHour } } },
2078 { type: "tool-call", id: "toolu_1", name: "lookup", params: {} },
2079 {
2080 type: "tool-call",
2081 id: "toolu_2",
2082 name: "lookup",
2083 params: {},
2084 options: { anthropic: { cacheControl: oneHour } }
2085 }
2086 ],
2087 options: cached
2088 },
2089 {
2090 role: "assistant",
2091 content: [{ type: "tool-call", id: "toolu_3", name: "lookup", params: {} }],
2092 options: cached
2093 },
2094 { role: "user", content: "Thanks" }
2095 ])
2096
2097 assert.deepStrictEqual(content, [
2098 { type: "text", text: "Answer", cache_control: oneHour },
2099 { type: "tool_use", id: "toolu_1", name: "lookup", input: {} },
2100 { type: "tool_use", id: "toolu_2", name: "lookup", input: {}, cache_control: oneHour },
2101 { type: "tool_use", id: "toolu_3", name: "lookup", input: {}, cache_control: ephemeral }
2102 ])
2103 }))
2104
2105 it.effect("places a message breakpoint before trailing thinking and skipped parts", () =>
2106 Effect.gen(function*() {
2107 const content = yield* getAssistantContent([
2108 { role: "user", content: "Question" },
2109 {
2110 role: "assistant",
2111 content: [
2112 { type: "text", text: "Answer" },
2113 thinking,
2114 redactedThinking,
2115 { type: "file", mediaType: "image/png", data: "aGVsbG8=" }
2116 ],
2117 options: cached
2118 },
2119 { role: "user", content: "Thanks" }
2120 ])
2121
2122 assert.deepStrictEqual(content, [
2123 { type: "text", text: "Answer", cache_control: ephemeral },
2124 { type: "thinking", thinking: "Thinking", signature: "sig" },
2125 { type: "redacted_thinking", data: "hidden" }
2126 ])
2127 }))
2128
2129 it.effect("drops thinking-only breakpoints without marking other parts or messages", () =>
2130 Effect.gen(function*() {
2131 const content = yield* getAssistantContent([
2132 { role: "user", content: "Question" },
2133 { role: "assistant", content: "Unmarked" },
2134 {
2135 role: "assistant",
2136 content: [
2137 { type: "text", text: "Answer" },
2138 { ...thinking, options: { anthropic: { ...thinking.options.anthropic, ...cached.anthropic } } },
2139 {
2140 ...redactedThinking,
2141 options: { anthropic: { ...redactedThinking.options.anthropic, ...cached.anthropic } }
2142 }
2143 ]
2144 },
2145 { role: "assistant", content: [thinking, redactedThinking], options: cached },
2146 { role: "user", content: "Thanks" }
2147 ])
2148
2149 assert.deepStrictEqual(content, [
2150 { type: "text", text: "Unmarked" },
2151 { type: "text", text: "Answer" },
2152 { type: "thinking", thinking: "Thinking", signature: "sig" },
2153 { type: "redacted_thinking", data: "hidden" },
2154 { type: "thinking", thinking: "Thinking", signature: "sig" },
2155 { type: "redacted_thinking", data: "hidden" }
2156 ])
2157 }))
2158 })
2159
2160 // Anthropic tool search runs on the server: `server_tool_use` and its
2161 // `tool_search_tool_result` must replay in the assistant message as received,
2162 // while only client tool results belong in the following user message (#10268).
2163 describe("tool search", () => {
2164 const ListContacts = Tool.make("ListContacts", {
2165 parameters: Schema.Struct({ name: Schema.String }),
2166 success: Schema.Array(Schema.String)
2167 })
2168 const toolkit = Toolkit.make(
2169 ListContacts,
2170 AnthropicTool.ToolSearchRegex_20251119(),
2171 AnthropicTool.ToolSearchBM25_20251119(),
2172 AnthropicTool.WebSearch_20250305({})
2173 )
2174 const toolkitLayer = toolkit.toLayer({ ListContacts: () => Effect.succeed([]) })
2175
2176 const toolReferences = [{ type: "tool_reference", tool_name: "ListContacts" }]
2177 const content = [
2178 {
2179 type: "server_tool_use",
2180 id: "srvtoolu_1",
2181 name: "tool_search_tool_regex",
2182 input: { pattern: "contacts", limit: 5 }
2183 },
2184 {
2185 type: "tool_search_tool_result",
2186 tool_use_id: "srvtoolu_1",
2187 content: { type: "tool_search_tool_search_result", tool_references: toolReferences }
2188 },
2189 {
2190 type: "server_tool_use",
2191 id: "srvtoolu_2",
2192 name: "tool_search_tool_bm25",
2193 input: { query: "contacts", limit: 5 }
2194 },
2195 {
2196 type: "tool_search_tool_result",
2197 tool_use_id: "srvtoolu_2",
2198 content: { type: "tool_search_tool_result_error", error_code: "unavailable", error_message: null }
2199 },
2200 { type: "server_tool_use", id: "srvtoolu_3", name: "web_search", input: { query: "contacts" } },
2201 {
2202 type: "web_search_tool_result",
2203 tool_use_id: "srvtoolu_3",
2204 content: [{
2205 type: "web_search_result",
2206 url: "https://example.com/contacts",
2207 title: "Contacts",
2208 encrypted_content: "encrypted",
2209 page_age: null
2210 }]
2211 },
2212 { type: "tool_use", id: "toolu_1", name: "ListContacts", input: { name: "Anna" } }
2213 ]
2214
2215 const message = (content: ReadonlyArray<unknown>, stop_reason: string | null) => ({
2216 id: "msg_test_1",
2217 type: "message",
2218 role: "assistant",
2219 model: "claude-sonnet-4-20250514",
2220 content,
2221 stop_reason,
2222 stop_sequence: null,
2223 usage: {
2224 cache_creation: null,
2225 cache_creation_input_tokens: null,
2226 cache_read_input_tokens: null,
2227 inference_geo: null,
2228 input_tokens: 1,
2229 output_tokens: 1,
2230 service_tier: null
2231 }
2232 })
2233
2234 const streamEvents = (content: ReadonlyArray<any>) => [
2235 { type: "message_start", message: message([], null) },
2236 ...content.flatMap((block, index) =>
2237 "input" in block
2238 ? [
2239 { type: "content_block_start", index, content_block: { ...block, input: {} } },
2240 {
2241 type: "content_block_delta",
2242 index,
2243 delta: { type: "input_json_delta", partial_json: JSON.stringify(block.input) }
2244 },
2245 { type: "content_block_stop", index }
2246 ]
2247 : [{ type: "content_block_start", index, content_block: block }, { type: "content_block_stop", index }]
2248 ),
2249 { type: "message_delta", delta: { stop_reason: "tool_use", stop_sequence: null }, usage: { output_tokens: 1 } },
2250 { type: "message_stop" }
2251 ]
2252
2253 // Answers the first request with `first` and every later request with text.
2254 const makeLayer = (requests: Array<HttpClientRequest.HttpClientRequest>, first: ReadonlyArray<unknown>) =>
2255 AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
2256 Layer.provide(Layer.succeed(
2257 HttpClient.HttpClient,
2258 makeHttpClient(Effect.fnUntraced(function*(request) {
2259 requests.push(request)
2260 const body = yield* getRequestBody(request)
2261 if (requests.length > 1) {
2262 return jsonResponse(request, message([{ type: "text", text: "Done" }], "end_turn"))
2263 }
2264 return body.stream
2265 ? sseResponse(request, streamEvents(first))
2266 : jsonResponse(request, message(first, "tool_use"))
2267 }))
2268 ))
2269 )
2270
2271 for (const mode of ["generateText", "streamText"] as const) {
2272 it.effect(`replays provider-executed results in the assistant message (${mode})`, () => {
2273 const requests: Array<HttpClientRequest.HttpClientRequest> = []
2274 return Effect.gen(function*() {
2275 const prompt = Prompt.make("Which contacts are there?")
2276 const firstParts: ReadonlyArray<AiResponse.AnyPart> = mode === "generateText"
2277 ? (yield* LanguageModel.generateText({ prompt, toolkit })).content
2278 : globalThis.Array.from(yield* Stream.runCollect(LanguageModel.streamText({ prompt, toolkit })))
2279
2280 // The public success result stays the bare array of tool references
2281 const searchResult = firstParts
2282 .filter((part) => part.type === "tool-result")
2283 .find((part) => part.id === "srvtoolu_1")
2284 assertDefined(searchResult)
2285 assert.deepStrictEqual(searchResult.result, toolReferences)
2286
2287 yield* LanguageModel.generateText({
2288 prompt: Prompt.concat(prompt, Prompt.fromResponseParts(firstParts)),
2289 toolkit,
2290 disableToolCallResolution: true
2291 })
2292
2293 const body = yield* getRequestBody(requests[1])
2294 assert.deepStrictEqual(body.messages.map((message: any) => message.role), ["user", "assistant", "user"])
2295 assert.deepStrictEqual(body.messages[1].content, content)
2296 assert.deepStrictEqual(body.messages[2].content.map((block: any) => block.tool_use_id), ["toolu_1"])
2297 }).pipe(
2298 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
2299 Effect.provide(toolkitLayer),
2300 Effect.provide(makeLayer(requests, content))
2301 )
2302 })
2303 }
2304
2305 it.effect("sends defer_loading only for tools that opt in", () =>
2306 Effect.gen(function*() {
2307 const requests: Array<HttpClientRequest.HttpClientRequest> = []
2308 yield* LanguageModel.generateText({
2309 prompt: "Which contacts are there?",
2310 toolkit: Toolkit.make(
2311 ListContacts.annotate(AnthropicTool.DeferLoading, true),
2312 Tool.make("Ping", { parameters: Schema.Struct({ host: Schema.String }) }),
2313 AnthropicTool.ToolSearchRegex_20251119()
2314 ),
2315 disableToolCallResolution: true
2316 }).pipe(
2317 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
2318 Effect.provide(makeLayer(requests, [{ type: "text", text: "Done" }]))
2319 )
2320
2321 const body = yield* getRequestBody(requests[0])
2322 assert.deepStrictEqual(
2323 body.tools.map((tool: any) => [tool.name, tool.defer_loading]),
2324 [["ListContacts", true], ["Ping", undefined], ["tool_search_tool_regex", undefined]]
2325 )
2326 }))
2327 })
2328
2329 // The packaged `Memory_20250818` tool ships `customName: "AnthropicMemory"` /
2330 // `providerName: "memory"`, and is a client-executed provider tool. These
2331 // tests cover the round-trip that was broken on beta.98 (see #2615):
2332 // - the provider wire name ("memory") must resolve to the toolkit's custom
2333 // name ("AnthropicMemory"), otherwise `makeResponse` raises ToolNotFound
2334 // - `view_range` uses `Schema.optionalKey`, otherwise the Anthropic codec
2335 // rejects the tool schema with "Unsupported AST Undefined"
2336 // - `create` must carry `file_text`, otherwise the file body is dropped
2337 describe("Memory tool", () => {
2338 const memoryResponse = (request: HttpClientRequest.HttpClientRequest, input: unknown) =>
2339 jsonResponse(request, {
2340 id: "msg_test_1",
2341 type: "message",
2342 role: "assistant",
2343 model: "claude-sonnet-4-20250514",
2344 content: [{ type: "tool_use", id: "toolu_mem_1", name: "memory", input }],
2345 stop_reason: "tool_use",
2346 stop_sequence: null,
2347 usage: {
2348 cache_creation: null,
2349 cache_creation_input_tokens: null,
2350 cache_read_input_tokens: null,
2351 inference_geo: null,
2352 input_tokens: 10,
2353 output_tokens: 5,
2354 service_tier: null
2355 }
2356 })
2357
2358 it.effect("resolves the provider wire name to the tool's custom name (view)", () =>
2359 Effect.gen(function*() {
2360 let receivedParams: unknown = undefined
2361 const toolkit = Toolkit.make(AnthropicTool.Memory_20250818({}))
2362 const toolkitLayer = toolkit.toLayer({
2363 AnthropicMemory: (params) => {
2364 receivedParams = params
2365 return Effect.succeed("memory listing")
2366 }
2367 })
2368
2369 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
2370 Layer.provide(Layer.succeed(
2371 HttpClient.HttpClient,
2372 makeHttpClient((request) => Effect.succeed(memoryResponse(request, { command: "view", path: "/memories" })))
2373 ))
2374 )
2375
2376 const response = yield* LanguageModel.generateText({
2377 prompt: "check memory",
2378 toolkit
2379 }).pipe(
2380 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
2381 Effect.provide(toolkitLayer),
2382 Effect.provide(layer)
2383 )
2384
2385 // Handler was resolved under the custom name and received the decoded command
2386 assert.deepStrictEqual(receivedParams, { command: "view", path: "/memories" })
2387
2388 const toolResult = response.toolResults[0]
2389 assert.isDefined(toolResult)
2390 assert.strictEqual(toolResult.name, "AnthropicMemory")
2391 assert.strictEqual(toolResult.result, "memory listing")
2392 }))
2393
2394 it.effect("decodes the create command including file_text", () =>
2395 Effect.gen(function*() {
2396 let receivedParams: unknown = undefined
2397 const toolkit = Toolkit.make(AnthropicTool.Memory_20250818({}))
2398 const toolkitLayer = toolkit.toLayer({
2399 AnthropicMemory: (params) => {
2400 receivedParams = params
2401 return Effect.succeed("File created successfully at: /memories/notes.txt")
2402 }
2403 })
2404
2405 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
2406 Layer.provide(Layer.succeed(
2407 HttpClient.HttpClient,
2408 makeHttpClient((request) =>
2409 Effect.succeed(memoryResponse(request, {
2410 command: "create",
2411 path: "/memories/notes.txt",
2412 file_text: "hello world"
2413 }))
2414 )
2415 ))
2416 )
2417
2418 const response = yield* LanguageModel.generateText({
2419 prompt: "save a note",
2420 toolkit
2421 }).pipe(
2422 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
2423 Effect.provide(toolkitLayer),
2424 Effect.provide(layer)
2425 )
2426
2427 assert.deepStrictEqual(receivedParams, {
2428 command: "create",
2429 path: "/memories/notes.txt",
2430 file_text: "hello world"
2431 })
2432 assert.strictEqual(response.toolResults[0]?.name, "AnthropicMemory")
2433 }))
2434 })
2435
2436 describe("Text editor tool", () => {
2437 it("decodes insert_text for the insert command", () => {
2438 const input = { command: "insert", path: "notes.md", insert_line: 0, insert_text: "# Notes\n" } as const
2439 const tool = AnthropicTool.TextEditor_20250728({})
2440 assert.deepStrictEqual(Schema.decodeUnknownSync(tool.parametersSchema)(input), input)
2441 })
2442
2443 it("decodes new_str for the legacy insert command", () => {
2444 const input = { command: "insert", path: "notes.md", insert_line: 0, new_str: "# Notes\n" } as const
2445 const tool = AnthropicTool.TextEditor_20250124({})
2446 assert.deepStrictEqual(Schema.decodeUnknownSync(tool.parametersSchema)(input), input)
2447 assert.deepStrictEqual(Schema.decodeUnknownSync(AnthropicTool.TextEditorInsertCommand)(input), input)
2448 })
2449 })
2450
2451 describe("provider tool names", () => {
2452 const toolkit = Toolkit.make(
2453 AnthropicTool.Memory_20250818({}),
2454 AnthropicTool.ComputerUse_20241022({ displayWidthPx: 800, displayHeightPx: 600 })
2455 )
2456
2457 const generate = Effect.fnUntraced(function*(
2458 options: Omit<LanguageModel.GenerateTextOptions<typeof toolkit.tools>, "toolkit">,
2459 content: ReadonlyArray<unknown> = [{ type: "text", text: "Done" }]
2460 ) {
2461 let capturedRequest: HttpClientRequest.HttpClientRequest | undefined = undefined
2462 const layer = AnthropicClient.layer({ apiKey: Redacted.make("sk-test-key") }).pipe(
2463 Layer.provide(Layer.succeed(
2464 HttpClient.HttpClient,
2465 makeHttpClient((request) => {
2466 capturedRequest = request
2467 return Effect.succeed(jsonResponse(request, {
2468 id: "msg_test_1",
2469 type: "message",
2470 role: "assistant",
2471 model: "claude-sonnet-4-20250514",
2472 content,
2473 stop_reason: "end_turn",
2474 stop_sequence: null,
2475 usage: {
2476 cache_creation: null,
2477 cache_creation_input_tokens: null,
2478 cache_read_input_tokens: null,
2479 inference_geo: null,
2480 input_tokens: 1,
2481 output_tokens: 1,
2482 service_tier: null
2483 }
2484 }))
2485 })
2486 ))
2487 )
2488
2489 const response = yield* LanguageModel.generateText({
2490 ...options,
2491 toolkit,
2492 disableToolCallResolution: true
2493 }).pipe(
2494 Effect.provide(AnthropicLanguageModel.model("claude-sonnet-4-20250514")),
2495 Effect.provide(layer)
2496 )
2497
2498 assertDefined(capturedRequest)
2499 return { body: yield* getRequestBody(capturedRequest), response }
2500 })
2501
2502 it.effect("sends provider names for an explicit tool choice and replayed tool calls", () =>
2503 Effect.gen(function*() {
2504 const { body } = yield* generate({
2505 prompt: Prompt.make([
2506 { role: "user", content: "what do you remember?" },
2507 {
2508 role: "assistant",
2509 content: [{
2510 type: "tool-call",
2511 id: "toolu_mem_1",
2512 name: "AnthropicMemory",
2513 params: { command: "view", path: "/memories" },
2514 providerExecuted: false
2515 }]
2516 }
2517 ]),
2518 toolChoice: { tool: "AnthropicMemory" }
2519 })
2520
2521 assert.deepStrictEqual(body.tool_choice, { type: "tool", name: "memory" })
2522 assert.strictEqual(body.messages[1].content[0].name, "memory")
2523 }))
2524
2525 it.effect("keeps provider tools selected by a oneOf tool choice", () =>
2526 Effect.gen(function*() {
2527 const { body } = yield* generate({
2528 prompt: "remember this",
2529 toolChoice: { oneOf: ["AnthropicMemory"] }
2530 })
2531
2532 assert.deepStrictEqual(body.tools.map((tool: any) => tool.name), ["memory"])
2533 }))
2534
2535 it.effect("decodes ComputerUse_20241022 calls named computer", () =>
2536 Effect.gen(function*() {
2537 const { response } = yield* generate({ prompt: "take a screenshot" }, [
2538 { type: "tool_use", id: "toolu_cu_1", name: "computer", input: { action: "screenshot" } }
2539 ])
2540
2541 assert.strictEqual(response.toolCalls[0]?.name, "AnthropicComputerUse")
2542 }))
2543 })
2544
2545 // Client-executed (`requiresHandler`) provider tools have their `parameters`
2546 // decoded via `toCodecAnthropic` when the model calls them. Optional
2547 // parameters must use `Schema.optionalKey` (not `Schema.optional`), otherwise
2548 // the codec rejects the schema with "Unsupported AST Undefined" (see #2615).
2549 describe("client provider tool parameters compile with the Anthropic codec", () => {
2550 const displayArgs = { displayWidthPx: 800, displayHeightPx: 600 }
2551 const clientTools: ReadonlyArray<readonly [string, Tool.AnyProviderDefined]> = [
2552 ["Bash_20241022", AnthropicTool.Bash_20241022({})],
2553 ["Bash_20250124", AnthropicTool.Bash_20250124({})],
2554 ["ComputerUse_20241022", AnthropicTool.ComputerUse_20241022(displayArgs)],
2555 ["ComputerUse_20250124", AnthropicTool.ComputerUse_20250124(displayArgs)],
2556 ["ComputerUse_20251124", AnthropicTool.ComputerUse_20251124(displayArgs)],
2557 ["Memory_20250818", AnthropicTool.Memory_20250818({})],
2558 ["TextEditor_20241022", AnthropicTool.TextEditor_20241022({})],
2559 ["TextEditor_20250124", AnthropicTool.TextEditor_20250124({})],
2560 ["TextEditor_20250429", AnthropicTool.TextEditor_20250429({})],
2561 ["TextEditor_20250728", AnthropicTool.TextEditor_20250728({})]
2562 ]
2563
2564 for (const [name, tool] of clientTools) {
2565 it(name, () => {
2566 const codec = AnthropicStructuredOutput.toCodecAnthropic(tool.parametersSchema)
2567 assert.isDefined(codec)
2568 })
2569 }
2570 })
2571 })
2572
2573 interface Filter {
2574 readonly name?: string | undefined
2575 readonly OR?: ReadonlyArray<Filter>
2576 }
2577
2578 const Filter = Schema.Struct({
2579 name: Schema.optional(Schema.String),
2580 OR: Schema.optionalKey(Schema.Array(Schema.suspend((): Schema.Codec<Filter> => Filter)))
2581 }).annotate({ identifier: "Filter" })
2582
2583 const RecursiveFilterTool = Tool.make("ListContacts", {
2584 // An identified alias of an identified root produces a chain of root references
2585 parameters: Schema.suspend(() => Schema.Struct({ filter: Filter }).annotate({ identifier: "ListContactsParams" }))
2586 .annotate({ identifier: "Params" })
2587 })
2588
2589 const makeHttpClient = (
2590 handler: (
2591 request: HttpClientRequest.HttpClientRequest
2592 ) => Effect.Effect<HttpClientResponse.HttpClientResponse, HttpClientError.HttpClientError>
2593 ) =>
2594 HttpClient.makeWith(
2595 Effect.fnUntraced(function*(requestEffect) {
2596 const request = yield* requestEffect
2597 return yield* handler(request)
2598 }),
2599 Effect.succeed as HttpClient.HttpClient.Preprocess<HttpClientError.HttpClientError, never>
2600 )
2601
2602 const sseResponse = (
2603 request: HttpClientRequest.HttpClientRequest,
2604 events: ReadonlyArray<unknown>
2605 ): HttpClientResponse.HttpClientResponse =>
2606 HttpClientResponse.fromWeb(
2607 request,
2608 new Response(toSseBody(events), {
2609 status: 200,
2610 headers: {
2611 "content-type": "text/event-stream"
2612 }
2613 })
2614 )
2615
2616 const jsonResponse = (
2617 request: HttpClientRequest.HttpClientRequest,
2618 body: unknown
2619 ): HttpClientResponse.HttpClientResponse =>
2620 HttpClientResponse.fromWeb(
2621 request,
2622 new Response(JSON.stringify(body), {
2623 status: 200,
2624 headers: {
2625 "content-type": "application/json"
2626 }
2627 })
2628 )
2629
2630 const getRequestBody = Effect.fnUntraced(function*(request: HttpClientRequest.HttpClientRequest) {
2631 const body = request.body
2632 if (body._tag !== "Uint8Array") {
2633 return yield* Effect.die(new Error("Expected Uint8Array body"))
2634 }
2635 return JSON.parse(new TextDecoder().decode(body.body))
2636 })
2637
2638 const toSseBody = (events: ReadonlyArray<unknown>): string =>
2639 events.map((event) => `event: message_stream\ndata: ${JSON.stringify(event)}\n\n`).join("")