@effect/ai-anthropic 0.23.0 → 4.0.0-beta.0

package/dist/AnthropicLanguageModel.js

@@ -0,0 +1,2107 @@
+/**
+ * @since 1.0.0
+ */
+/** @effect-diagnostics preferSchemaOverJson:skip-file */
+import * as Arr from "effect/Array";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Base64 from "effect/encoding/Base64";
+import { dual } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Redactable from "effect/Redactable";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import * as ServiceMap from "effect/ServiceMap";
+import * as Stream from "effect/Stream";
+import * as AiError from "effect/unstable/ai/AiError";
+import { toCodecAnthropic } from "effect/unstable/ai/AnthropicStructuredOutput";
+import * as IdGenerator from "effect/unstable/ai/IdGenerator";
+import * as LanguageModel from "effect/unstable/ai/LanguageModel";
+import * as AiModel from "effect/unstable/ai/Model";
+import * as Tool from "effect/unstable/ai/Tool";
+import { AnthropicClient } from "./AnthropicClient.js";
+import { addGenAIAnnotations } from "./AnthropicTelemetry.js";
+import * as InternalUtilities from "./internal/utilities.js";
+// =============================================================================
+// Configuration
+// =============================================================================
+/**
+ * Configuration options for the Anthropic language model.
+ *
+ * This service can be used to provide default configuration values or to
+ * override configuration on a per-request basis.
+ *
+ * @since 1.0.0
+ * @category configuration
+ */
+export class Config extends /*#__PURE__*/ServiceMap.Service()("@effect/ai-anthropic/AnthropicLanguageModel/Config") {}
+// =============================================================================
+// Language Model
+// =============================================================================
+/**
+ * Creates an Anthropic language model that can be used with `AiModel.provide`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export const model = (model, config) => AiModel.make("anthropic", layer({
+  model,
+  config
+}));
+/**
+ * Creates an Anthropic language model service.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make = /*#__PURE__*/Effect.fnUntraced(function* ({
+  model,
+  config: providerConfig
+}) {
+  const client = yield* AnthropicClient;
+  const makeConfig = Effect.gen(function* () {
+    const services = yield* Effect.services();
+    return {
+      model,
+      ...providerConfig,
+      ...services.mapUnsafe.get(Config.key)
+    };
+  });
+  const makeRequest = Effect.fnUntraced(function* ({
+    config,
+    options,
+    toolNameMapper
+  }) {
+    const betas = new Set();
+    const capabilities = getModelCapabilities(config.model);
+    const {
+      messages,
+      system
+    } = yield* prepareMessages({
+      betas,
+      options,
+      toolNameMapper
+    });
+    const outputFormat = yield* getOutputFormat({
+      capabilities,
+      options
+    });
+    const {
+      tools,
+      toolChoice
+    } = yield* prepareTools({
+      betas,
+      capabilities,
+      config,
+      options
+    });
+    const params = {};
+    if (betas.size > 0) {
+      params["anthropic-beta"] = Array.from(betas).join(",");
+    }
+    const {
+      disableParallelToolCalls: _,
+      output_config,
+      ...requestConfig
+    } = config;
+    const payload = {
+      ...requestConfig,
+      max_tokens: requestConfig.max_tokens ?? capabilities.maxOutputTokens,
+      messages,
+      ...(Predicate.isNotUndefined(system) ? {
+        system
+      } : undefined),
+      ...(Predicate.isNotUndefined(tools) ? {
+        tools
+      } : undefined),
+      ...(Predicate.isNotUndefined(toolChoice) ? {
+        tool_choice: toolChoice
+      } : undefined)
+    };
+    const outputConfig = {};
+    if (Predicate.isNotUndefined(outputFormat)) {
+      outputConfig.format = outputFormat;
+    }
+    if (Predicate.isNotUndefined(output_config?.effort)) {
+      outputConfig.effort = output_config.effort;
+    }
+    if (Object.keys(outputConfig).length > 0) {
+      payload.output_config = outputConfig;
+    }
+    return {
+      params,
+      payload
+    };
+  });
+  return yield* LanguageModel.make({
+    generateText: Effect.fnUntraced(function* (options) {
+      const config = yield* makeConfig;
+      const toolNameMapper = new Tool.NameMapper(options.tools);
+      const request = yield* makeRequest({
+        config,
+        options,
+        toolNameMapper
+      });
+      annotateRequest(options.span, request.payload);
+      const [rawResponse, response] = yield* client.createMessage(request);
+      annotateResponse(options.span, rawResponse);
+      return yield* makeResponse({
+        options,
+        rawResponse,
+        response,
+        toolNameMapper
+      });
+    }),
+    streamText: Effect.fnUntraced(function* (options) {
+      const config = yield* makeConfig;
+      const toolNameMapper = new Tool.NameMapper(options.tools);
+      const request = yield* makeRequest({
+        config,
+        options,
+        toolNameMapper
+      });
+      annotateRequest(options.span, request.payload);
+      const [response, stream] = yield* client.createMessageStream(request);
+      return yield* makeStreamResponse({
+        stream,
+        response,
+        options,
+        toolNameMapper
+      });
+    }, (effect, options) => effect.pipe(Stream.unwrap, Stream.map(response => {
+      annotateStreamResponse(options.span, response);
+      return response;
+    })))
+  }).pipe(Effect.provideService(LanguageModel.CurrentCodecTransformer, toCodecAnthropic));
+});
+/**
+ * Creates a layer for the Anthropic language model.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer = options => Layer.effect(LanguageModel.LanguageModel, make(options));
+/**
+ * Provides config overrides for Anthropic language model operations.
+ *
+ * @since 1.0.0
+ * @category configuration
+ */
+export const withConfigOverride = /*#__PURE__*/dual(2, (self, overrides) => Effect.flatMap(Effect.serviceOption(Config), config => Effect.provideService(self, Config, {
+  ...(config._tag === "Some" ? config.value : {}),
+  ...overrides
+})));
+// =============================================================================
+// Prompt Conversion
+// =============================================================================
+const prepareMessages = /*#__PURE__*/Effect.fnUntraced(function* ({
+  betas,
+  options,
+  toolNameMapper
+}) {
+  const groups = groupMessages(options.prompt);
+  let system = undefined;
+  const messages = [];
+  for (let i = 0; i < groups.length; i++) {
+    const group = groups[i];
+    const isLastGroup = i === groups.length - 1;
+    switch (group.type) {
+      case "system":
+        {
+          system = group.messages.map(message => ({
+            type: "text",
+            text: message.content,
+            cache_control: getCacheControl(message)
+          }));
+          break;
+        }
+      case "user":
+        {
+          const content = [];
+          for (const message of group.messages) {
+            switch (message.role) {
+              case "user":
+                {
+                  for (let j = 0; j < message.content.length; j++) {
+                    const part = message.content[j];
+                    const isLastPart = j === message.content.length - 1;
+                    // Attempt to get the cache control from the part first. If
+                    // the part does not have cache control defined and we are
+                    // evaluating the last part for this message, also check the
+                    // message for cache control.
+                    const cacheControl = getCacheControl(part) ?? (isLastPart ? getCacheControl(message) : null);
+                    switch (part.type) {
+                      case "text":
+                        {
+                          content.push({
+                            type: "text",
+                            text: part.text,
+                            cache_control: cacheControl
+                          });
+                          break;
+                        }
+                      case "file":
+                        {
+                          if (part.mediaType.startsWith("image/")) {
+                            const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                            const source = isUrlData(part.data) ? {
+                              type: "url",
+                              url: getUrlString(part.data)
+                            } : {
+                              type: "base64",
+                              media_type: mediaType,
+                              data: Base64.encode(part.data)
+                            };
+                            content.push({
+                              type: "image",
+                              source,
+                              cache_control: cacheControl
+                            });
+                          } else if (part.mediaType === "application/pdf" || part.mediaType === "text/plain") {
+                            betas.add("pdfs-2024-09-25");
+                            const enableCitations = areCitationsEnabled(part);
+                            const documentOptions = getDocumentMetadata(part);
+                            const source = isUrlData(part.data) ? {
+                              type: "url",
+                              url: getUrlString(part.data)
+                            } : part.mediaType === "application/pdf" ? {
+                              type: "base64",
+                              media_type: "application/pdf",
+                              data: typeof part.data === "string" ? part.data : Base64.encode(part.data)
+                            } : {
+                              type: "text",
+                              media_type: "text/plain",
+                              data: typeof part.data === "string" ? part.data : Base64.encode(part.data)
+                            };
+                            content.push({
+                              type: "document",
+                              source,
+                              title: documentOptions?.title ?? part.fileName ?? null,
+                              cache_control: cacheControl,
+                              ...(documentOptions?.context ? {
+                                context: documentOptions.context
+                              } : undefined),
+                              ...(enableCitations ? {
+                                citations: {
+                                  enabled: true
+                                }
+                              } : undefined)
+                            });
+                          } else {
+                            return yield* new AiError.AiError({
+                              module: "AnthropicLanguageModel",
+                              method: "prepareMessages",
+                              reason: new AiError.InvalidUserInputError({
+                                description: `Detected unsupported media type for file: '${part.mediaType}'`
+                              })
+                            });
+                          }
+                          break;
+                        }
+                    }
+                  }
+                  break;
+                }
+              case "tool":
+                {
+                  for (let j = 0; j < message.content.length; j++) {
+                    const part = message.content[j];
+                    // Skip evaluation of tool approval parts
+                    if (part.type === "tool-approval-response") {
+                      continue;
+                    }
+                    const isLastPart = j === message.content.length - 1;
+                    // Attempt to get the cache control from the part first. If
+                    // the part does not have cache control defined and we are
+                    // evaluating the last part for this message, also check the
+                    // message for cache control.
+                    const cacheControl = getCacheControl(part) ?? (isLastPart ? getCacheControl(message) : null);
+                    content.push({
+                      type: "tool_result",
+                      tool_use_id: part.id,
+                      content: JSON.stringify(part.result),
+                      is_error: part.isFailure,
+                      cache_control: cacheControl
+                    });
+                  }
+                }
+            }
+          }
+          messages.push({
+            role: "user",
+            content
+          });
+          break;
+        }
+      case "assistant":
+        {
+          const content = [];
+          const mcpToolIds = new Set();
+          for (let j = 0; j < group.messages.length; j++) {
+            const message = group.messages[j];
+            const isLastMessage = j === group.messages.length - 1;
+            for (let k = 0; k < message.content.length; k++) {
+              const part = message.content[k];
+              if (part.type === "file" || part.type === "tool-approval-request") {
+                continue;
+              }
+              const isLastPart = k === message.content.length - 1;
+              // Attempt to get the cache control from the part first. If
+              // the part does not have cache control defined and we are
+              // evaluating the last part for this message, also check the
+              // message for cache control.
+              const cacheControl = getCacheControl(part) ?? (isLastPart ? getCacheControl(message) : undefined);
+              // TODO: use cache_control in content blocks
+              void cacheControl;
+              switch (part.type) {
+                case "text":
+                  {
+                    content.push({
+                      type: "text",
+                      // Anthropic does not allow trailing whitespace in assistant
+                      // content blocks
+                      text: isLastGroup && isLastMessage && isLastPart ? part.text.trim() : part.text
+                    });
+                    break;
+                  }
+                case "reasoning":
+                  {
+                    // TODO: make sending reasoning configurable
+                    const info = part.options.anthropic?.info;
+                    if (Predicate.isNotNullish(info)) {
+                      if (info.type === "thinking") {
+                        content.push({
+                          type: "thinking",
+                          thinking: part.text,
+                          signature: info.signature
+                        });
+                      } else {
+                        content.push({
+                          type: "redacted_thinking",
+                          data: info.redactedData
+                        });
+                      }
+                    }
+                    break;
+                  }
+                case "tool-call":
+                  {
+                    if (part.providerExecuted) {
+                      const toolName = toolNameMapper.getProviderName(part.name);
+                      const isMcpTool = Predicate.isNotNullish(part.options.anthropic?.mcp_tool);
+                      if (isMcpTool) {
+                        const {
+                          server
+                        } = part.options.anthropic.mcp_tool;
+                        mcpToolIds.add(part.id);
+                        content.push({
+                          type: "mcp_tool_use",
+                          id: part.id,
+                          name: part.name,
+                          input: part.params,
+                          server_name: server
+                        });
+                      } else if (toolName === "code_execution" && Predicate.hasProperty(part.params, "type") && (part.params.type === "bash_code_execution" || part.params.type === "text_editor_code_execution")) {
+                        content.push({
+                          type: "server_tool_use",
+                          id: part.id,
+                          name: part.params.type,
+                          input: part.params
+                        });
+                      } else if (
+                      // code execution 20250825 programmatic tool calling:
+                      // Strip the fake 'programmatic-tool-call' type before sending to Anthropic
+                      toolName === "code_execution" && Predicate.hasProperty(part.params, "type") && part.params.type === "programmatic-tool-call") {
+                        const {
+                          type,
+                          ...params
+                        } = part.params;
+                        content.push({
+                          type: "server_tool_use",
+                          id: part.id,
+                          name: toolName,
+                          input: params
+                        });
+                      } else {
+                        if (
+                        // code execution 20250522
+                        toolName === "code_execution" || toolName === "tool_search_tool_regex" || toolName === "tool_search_tool_bm25" || toolName === "web_fetch" || toolName === "web_search") {
+                          content.push({
+                            type: "server_tool_use",
+                            id: part.id,
+                            name: toolName,
+                            input: part.params
+                          });
+                        }
+                      }
+                    } else {
+                      // Extract caller info from provider options for programmatic tool calling
+                      const options = part.options.anthropic;
+                      const caller = Predicate.isNotNullish(options?.caller) ? options.caller.type === "code_execution_20250825" && Predicate.isNotNullish(options.caller.toolId) ? {
+                        type: "code_execution_20250825",
+                        tool_id: options.caller.toolId
+                      } : options.caller.type === "direct" ? {
+                        type: "direct"
+                      } : undefined : undefined;
+                      content.push({
+                        type: "tool_use",
+                        id: part.id,
+                        name: part.name,
+                        input: part.params,
+                        ...(Predicate.isNotUndefined(caller) ? {
+                          caller
+                        } : undefined)
+                      });
+                    }
+                    break;
+                  }
+                case "tool-result":
+                  {
+                    const toolName = toolNameMapper.getProviderName(part.name);
+                    if (mcpToolIds.has(part.id)) {
+                      content.push({
+                        type: "mcp_tool_result",
+                        tool_use_id: part.id,
+                        is_error: part.isFailure,
+                        content: part.result
+                      });
+                      break;
+                    }
+                    if (toolName === "code_execution" && Predicate.hasProperty(part.result, "type")) {
+                      if (part.result.type === "code_execution_result") {
+                        content.push({
+                          type: "code_execution_tool_result",
+                          tool_use_id: part.id,
+                          content: part.result
+                        });
+                      } else if (part.result.type === "bash_code_execution_result" || part.result.type === "bash_code_execution_tool_result_error") {
+                        content.push({
+                          type: "bash_code_execution_tool_result",
+                          tool_use_id: part.id,
+                          content: part.result
+                        });
+                      } else if (part.result.type === "text_editor_code_execution_tool_result" || part.result.type === "text_editor_code_execution_tool_result_error") {
+                        content.push({
+                          type: "text_editor_code_execution_tool_result",
+                          tool_use_id: part.id,
+                          content: part.result
+                        });
+                      }
+                      break;
+                    }
+                    if (toolName === "web_fetch") {
+                      content.push({
+                        type: "web_fetch_tool_result",
+                        tool_use_id: part.id,
+                        content: part.result
+                      });
+                      break;
+                    }
+                    if (toolName === "web_search") {
+                      content.push({
+                        type: "web_search_tool_result",
+                        tool_use_id: part.id,
+                        content: part.result
+                      });
+                      break;
+                    }
+                    if (toolName === "tool_search_tool_regex" || toolName === "tool_search_tool_bm25") {
+                      content.push({
+                        type: "tool_search_tool_result",
+                        tool_use_id: part.id,
+                        content: part.result
+                      });
+                      break;
+                    }
+                    break;
+                  }
+              }
+            }
+          }
+          messages.push({
+            role: "assistant",
+            content
+          });
+          break;
+        }
+    }
+  }
+  return {
+    system,
+    messages
+  };
+});
+const prepareTools = /*#__PURE__*/Effect.fnUntraced(function* ({
+  betas,
+  capabilities,
+  config,
+  options
+}) {
+  if (options.tools.length === 0 || options.toolChoice === "none") {
+    return {
+      tools: undefined,
+      toolChoice: undefined
+    };
+  }
+  // Return a JSON response tool when using non-native structured outputs
+  if (options.responseFormat.type === "json" && !capabilities.supportsStructuredOutput) {
+    const input_schema = yield* tryJsonSchema(options.responseFormat.schema, "prepareTools");
+    const userDescription = SchemaAST.resolveDescription(options.responseFormat.schema.ast);
+    const description = Predicate.isNotUndefined(userDescription) ? `${userDescription} - ` : "";
+    return {
+      tools: [{
+        name: options.responseFormat.objectName,
+        description: `${description}You MUST respond with a JSON object.`,
+        input_schema: input_schema
+      }],
+      toolChoice: {
+        type: "tool",
+        name: options.responseFormat.objectName,
+        disable_parallel_tool_use: true
+      }
+    };
+  }
+  const userTools = [];
+  const providerTools = [];
+  for (const tool of options.tools) {
+    if (Tool.isUserDefined(tool)) {
+      const description = Tool.getDescription(tool);
+      const input_schema = yield* tryJsonSchema(tool.parametersSchema, "prepareTools");
+      const toolStrict = Tool.getStrictMode(tool);
+      const strict = capabilities.supportsStructuredOutput ? toolStrict ?? config.strictJsonSchema ?? true : undefined;
+      userTools.push({
+        name: tool.name,
+        input_schema: input_schema,
+        ...(Predicate.isNotUndefined(description) ? {
+          description
+        } : undefined),
+        ...(Predicate.isNotUndefined(strict) ? {
+          strict
+        } : undefined)
+      });
+      if (capabilities.supportsStructuredOutput === true) {
+        betas.add("structured-outputs-2025-11-13");
+      }
+    }
+    if (Tool.isProviderDefined(tool)) {
+      const providerTool = tool;
+      switch (providerTool.id) {
+        case "anthropic.bash_20241022":
+          {
+            betas.add("computer-use-2024-10-22");
+            providerTools.push({
+              name: "bash",
+              type: "bash_20241022"
+            });
+            break;
+          }
+        case "anthropic.bash_20250124":
+          {
+            betas.add("computer-use-2025-01-24");
+            providerTools.push({
+              name: "bash",
+              type: "bash_20250124"
+            });
+            break;
+          }
+        case "anthropic.code_execution_20250522":
+          {
+            betas.add("code-execution-2025-05-22");
+            providerTools.push({
+              name: "code_execution",
+              type: "code_execution_20250522"
+            });
+            break;
+          }
+        case "anthropic.code_execution_20250825":
+          {
+            betas.add("code-execution-2025-08-25");
+            providerTools.push({
+              name: "code_execution",
+              type: "code_execution_20250825"
+            });
+            break;
+          }
+        case "anthropic.computer_use_20241022":
+          {
+            betas.add("computer-use-2024-10-22");
+            providerTools.push({
+              name: "computer",
+              type: "computer_20241022",
+              display_height_px: providerTool.args.displayHeightPx,
+              display_width_px: providerTool.args.displayWidthPx,
+              display_number: providerTool.args.displayNumber ?? null
+            });
+            break;
+          }
+        case "anthropic.computer_20250124":
+          {
+            betas.add("computer-use-2025-01-24");
+            providerTools.push({
+              name: "computer",
+              type: "computer_20250124",
+              display_height_px: providerTool.args.displayHeightPx,
+              display_width_px: providerTool.args.displayWidthPx,
+              display_number: providerTool.args.displayNumber ?? null
+            });
+            break;
+          }
+        case "anthropic.computer_20251124":
+          {
+            betas.add("computer-use-2025-11-24");
+            providerTools.push({
+              name: "computer",
+              type: "computer_20251124",
+              display_height_px: providerTool.args.displayHeightPx,
+              display_width_px: providerTool.args.displayWidthPx,
+              display_number: providerTool.args.displayNumber ?? null,
+              enable_zoom: providerTool.args.enableZoom ?? false
+            });
+            break;
+          }
+        case "anthropic.memory_20250818":
+          {
+            betas.add("context-management-2025-06-27");
+            providerTools.push({
+              name: "memory",
+              type: "memory_20250818"
+            });
+            break;
+          }
+        case "anthropic.text_editor_20241022":
+          {
+            betas.add("computer-use-2024-10-22");
+            providerTools.push({
+              name: "str_replace_editor",
+              type: "text_editor_20241022"
+            });
+            break;
+          }
+        case "anthropic.text_editor_20250124":
+          {
+            betas.add("computer-use-2025-01-24");
+            providerTools.push({
+              name: "str_replace_editor",
+              type: "text_editor_20250124"
+            });
+            break;
+          }
+        case "anthropic.text_editor_20250429":
+          {
+            betas.add("computer-use-2025-01-24");
+            providerTools.push({
+              name: "str_replace_based_edit_tool",
+              type: "text_editor_20250429"
+            });
+            break;
+          }
+        case "anthropic.text_editor_20250728":
+          {
+            providerTools.push({
+              name: "str_replace_based_edit_tool",
+              type: "text_editor_20250728",
+              max_characters: providerTool.args.max_characters ?? null
+            });
+            break;
+          }
+        case "anthropic.tool_search_tool_bm25_20251119":
+          {
+            betas.add("advanced-tool-use-2025-11-20");
+            providerTools.push({
+              name: "tool_search_tool_bm25",
+              type: "tool_search_tool_bm25_20251119"
+            });
+            break;
+          }
+        case "anthropic.tool_search_tool_regex_20251119":
+          {
+            providerTools.push({
+              name: "tool_search_tool_regex",
+              type: "tool_search_tool_regex_20251119"
+            });
+            break;
+          }
+        case "anthropic.web_search_20250305":
+          {
+            providerTools.push({
+              name: "web_search",
+              type: "web_search_20250305",
+              max_uses: providerTool.args.maxUses ?? null,
+              allowed_domains: providerTool.args.allowedDomains ?? null,
+              blocked_domains: providerTool.args.blockedDomains ?? null,
+              user_location: Predicate.isNotUndefined(providerTool.args.userLocation) ? {
+                type: providerTool.args.userLocation.type,
+                region: providerTool.args.userLocation.region ?? null,
+                city: providerTool.args.userLocation.city ?? null,
+                country: providerTool.args.userLocation.country ?? null,
+                timezone: providerTool.args.userLocation.timezone ?? null
+              } : null
+            });
+            break;
+          }
+        case "anthropic.web_fetch_20250910":
+          {
+            betas.add("web-fetch-2025-09-10");
+            providerTools.push({
+              name: "web_fetch",
+              type: "web_fetch_20250910",
+              max_uses: providerTool.args.maxUses ?? null,
+              allowed_domains: providerTool.args.allowedDomains ?? null,
+              blocked_domains: providerTool.args.blockedDomains ?? null,
+              citations: providerTool.args.citations ?? null,
+              max_content_tokens: providerTool.args.maxContentTokens ?? null
+            });
+            break;
+          }
+        default:
+          {
+            return yield* AiError.make({
+              module: "AnthropicLanguageModel",
+              method: "prepareTools",
+              reason: new AiError.InvalidUserInputError({
+                description: `Received request to call unknown provider-defined tool '${tool.name}'`
+              })
+            });
+          }
+      }
+    }
+  }
+  let tools = [...userTools, ...providerTools];
+  let toolChoice = undefined;
+  if (options.toolChoice === "auto") {
+    toolChoice = {
+      type: "auto"
+    };
+  } else if (options.toolChoice === "required") {
+    toolChoice = {
+      type: "any"
+    };
+  } else if ("tool" in options.toolChoice) {
+    toolChoice = {
+      type: "tool",
+      name: options.toolChoice.tool
+    };
+  } else {
+    const allowedTools = new Set(options.toolChoice.oneOf);
+    tools = tools.filter(tool => allowedTools.has(tool.name));
+    toolChoice = {
+      type: options.toolChoice.mode === "required" ? "any" : "auto"
+    };
+  }
+  if (Predicate.isNotUndefined(config.disableParallelToolCalls) && Predicate.isNotUndefined(toolChoice) && toolChoice.type !== "none") {
+    toolChoice.disable_parallel_tool_use = config.disableParallelToolCalls;
+  }
+  return {
+    tools,
+    toolChoice
+  };
+});
+// =============================================================================
+// HTTP Details
+// =============================================================================
+const buildHttpRequestDetails = request => ({
+  method: request.method,
+  url: request.url,
+  urlParams: Array.from(request.urlParams),
+  hash: request.hash,
+  headers: Redactable.redact(request.headers)
+});
+const buildHttpResponseDetails = response => ({
+  status: response.status,
+  headers: Redactable.redact(response.headers)
+});
+// =============================================================================
+// Response Conversion
+// =============================================================================
+const makeResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
+  options,
+  rawResponse,
+  response,
+  toolNameMapper
+}) {
+  const parts = [];
+  const mcpToolCalls = new Map();
+  const serverToolCalls = new Map();
+  const citableDocuments = extractCitableDocuments(options.prompt);
+  parts.push({
+    type: "response-metadata",
+    id: rawResponse.id,
+    modelId: rawResponse.model,
+    timestamp: DateTime.formatIso(yield* DateTime.now),
+    request: buildHttpRequestDetails(response.request)
+  });
+  for (const part of rawResponse.content) {
+    switch (part.type) {
+      case "text":
+        {
+          // Text parts are added for both text and json response formats.
+          // For native structured output (json_schema), the JSON comes directly
+          // in a text content block. For tool-based structured output, text may
+          // also be present alongside the tool_use.
+          parts.push({
+            type: "text",
+            text: part.text
+          });
+          if (Predicate.isNotNullish(part.citations)) {
+            for (const citation of part.citations) {
+              const source = yield* processCitation(citation, citableDocuments);
+              if (Predicate.isNotUndefined(source)) {
+                parts.push(source);
+              }
+            }
+          }
+          break;
+        }
+      case "thinking":
+        {
+          const metadata = {
+            info: {
+              type: "thinking",
+              signature: part.signature
+            }
+          };
+          parts.push({
+            type: "reasoning",
+            text: part.thinking,
+            metadata: {
+              anthropic: metadata
+            }
+          });
+          break;
+        }
+      case "redacted_thinking":
+        {
+          const metadata = {
+            info: {
+              type: "redacted_thinking",
+              redactedData: part.data
+            }
+          };
+          parts.push({
+            type: "reasoning",
+            text: "",
+            metadata: {
+              anthropic: metadata
+            }
+          });
+          break;
+        }
+      case "tool_use":
+        {
+          // When the `"json"` response format is requested, the JSON we need
+          // is returned by a tool call injected into the request
+          if (options.responseFormat.type === "json") {
+            parts.push({
+              type: "text",
+              text: JSON.stringify(part.input)
+            });
+          } else {
+            // Extract caller info if present
+            const caller = part.caller;
+            const callerInfo = Predicate.isNotNullish(caller) ? {
+              type: caller.type,
+              toolId: "tool_id" in caller ? caller.tool_id : undefined
+            } : undefined;
+            const params = yield* transformToolCallParams(options.tools, part.name, part.input);
+            parts.push({
+              type: "tool-call",
+              id: part.id,
+              name: part.name,
+              params,
+              ...(Predicate.isNotUndefined(callerInfo) ? {
+                metadata: {
+                  anthropic: {
+                    caller: callerInfo
+                  }
+                }
+              } : undefined)
+            });
+          }
+          break;
+        }
+      case "server_tool_use":
+        {
+          const toolName = toolNameMapper.getCustomName(part.name);
+          if (part.name === "bash_code_execution" || part.name === "text_editor_code_execution") {
+            parts.push({
+              type: "tool-call",
+              id: part.id,
+              name: toolName,
+              params: {
+                type: part.name,
+                ...part.input
+              },
+              providerExecuted: true
+            });
+          } else if (part.name === "code_execution" || part.name === "web_fetch" || part.name === "web_search") {
+            const toolParams = {
+              ...part.input
+            };
+            // Inject `type: "programmatic-tool-call"` when the input parameters
+            // has the format `{ code: ... }`
+            if (part.name === "code_execution" && Predicate.hasProperty(part.input, "code") && !Predicate.hasProperty(part.input, "type")) {
+              toolParams.type = "programmatic-tool-call";
+            }
+            parts.push({
+              type: "tool-call",
+              id: part.id,
+              name: toolName,
+              params: toolParams,
+              providerExecuted: true
+            });
+          } else if (part.name === "tool_search_tool_bm25" || part.name === "tool_search_tool_regex") {
+            serverToolCalls.set(part.id, part.name);
+            parts.push({
+              type: "tool-call",
+              id: part.id,
+              name: toolName,
+              params: part.input,
+              providerExecuted: true
+            });
+          }
+          break;
+        }
+      case "mcp_tool_use":
+        {
+          const toolCall = {
+            type: "tool-call",
+            id: part.id,
+            name: part.name,
+            params: part.input,
+            providerExecuted: true,
+            metadata: {
+              anthropic: {
+                mcp_tool: {
+                  server: part.server_name
+                }
+              }
+            }
+          };
+          mcpToolCalls.set(part.id, toolCall);
+          parts.push(toolCall);
+          break;
+        }
+      case "mcp_tool_result":
+        {
+          const toolCall = mcpToolCalls.get(part.tool_use_id);
+          const mcpMetadata = toolCall?.metadata?.anthropic?.mcp_tool;
+          if (Predicate.isNotUndefined(toolCall)) {
+            parts.push({
+              type: "tool-result",
+              id: part.tool_use_id,
+              name: toolCall.name,
+              isFailure: part.is_error,
+              result: part.content,
+              metadata: {
+                anthropic: {
+                  ...(Predicate.isNotNullish(mcpMetadata) ? {
+                    mcp_tool: mcpMetadata
+                  } : undefined)
+                }
+              }
+            });
+          }
+          break;
+        }
+      // Code Execution 20250522
+      case "code_execution_tool_result":
+        {
+          const toolName = toolNameMapper.getCustomName("code_execution");
+          if (part.content.type === "code_execution_result") {
+            parts.push({
+              type: "tool-result",
+              id: part.tool_use_id,
+              name: toolName,
+              isFailure: false,
+              result: part.content
+            });
+          } else {
+            parts.push({
+              type: "tool-result",
+              id: part.tool_use_id,
+              name: toolName,
+              isFailure: true,
+              result: part.content
+            });
+          }
+          break;
+        }
+      // Code Execution 20250825
+      case "bash_code_execution_tool_result":
+      case "text_editor_code_execution_tool_result":
+        {
+          const toolName = toolNameMapper.getCustomName("code_execution");
+          if (part.content.type === "bash_code_execution_tool_result_error" || part.content.type === "text_editor_code_execution_tool_result_error") {
+            parts.push({
+              type: "tool-result",
+              id: part.tool_use_id,
+              name: toolName,
+              isFailure: true,
+              result: part.content
+            });
+          } else {
+            parts.push({
+              type: "tool-result",
+              id: part.tool_use_id,
+              name: toolName,
+              isFailure: false,
+              result: part.content
+            });
+          }
+          break;
+        }
+      case "tool_search_tool_result":
+        {
+          let providerName = serverToolCalls.get(part.tool_use_id);
+          if (Predicate.isUndefined(providerName)) {
+            const bm25Name = toolNameMapper.getCustomName("tool_search_tool_bm25");
+            const regexName = toolNameMapper.getCustomName("tool_search_tool_regex");
+            if (bm25Name !== "tool_search_tool_bm25") {
+              providerName = "tool_search_tool_bm25";
+            } else if (regexName !== "tool_search_tool_regex") {
+              providerName = "tool_search_tool_regex";
+            }
+          }
+          const toolName = toolNameMapper.getCustomName(providerName);
+          if (part.content.type === "tool_search_tool_search_result") {
+            parts.push({
+              type: "tool-result",
+              id: part.tool_use_id,
+              name: toolName,
+              isFailure: false,
+              result: part.content.tool_references
+            });
+          } else {
+            parts.push({
+              type: "tool-result",
+              id: part.tool_use_id,
+              name: toolName,
+              isFailure: true,
+              result: part.content
+            });
+          }
+          break;
+        }
+      case "web_fetch_tool_result":
+        {
+          const toolName = toolNameMapper.getCustomName("web_fetch");
+          if (part.content.type === "web_fetch_result") {
+            citableDocuments.push({
+              title: part.content.content.title ?? part.content.url,
+              mediaType: part.content.content.source.media_type
+            });
+            parts.push({
+              type: "tool-result",
+              id: part.tool_use_id,
+              name: toolName,
+              isFailure: false,
+              result: part.content
+            });
+          } else {
+            parts.push({
+              type: "tool-result",
+              id: part.tool_use_id,
+              name: toolName,
+              isFailure: true,
+              result: part.content
+            });
+          }
+          break;
+        }
+      case "web_search_tool_result":
+        {
+          const toolName = toolNameMapper.getCustomName("web_search");
+          if (Predicate.hasProperty(part.content, "type")) {
+            parts.push({
+              type: "tool-result",
+              id: part.tool_use_id,
+              name: toolName,
+              isFailure: true,
+              result: part.content
+            });
+          } else {
+            const idGenerator = yield* IdGenerator.IdGenerator;
+            parts.push({
+              type: "tool-result",
+              id: part.tool_use_id,
+              name: toolName,
+              isFailure: false,
+              result: part.content
+            });
+            const content = part.content;
+            for (const result of content) {
+              const id = yield* idGenerator.generateId();
+              parts.push({
+                type: "source",
+                sourceType: "url",
+                id,
+                url: result.url,
+                title: result.title,
+                metadata: {
+                  anthropic: {
+                    source: "web",
+                    pageAge: result.page_age
+                  }
+                }
+              });
+            }
+          }
+          break;
+        }
+    }
+  }
+  // Anthropic always returns a non-null `stop_reason` for non-streaming responses
+  const finishReason = InternalUtilities.resolveFinishReason(rawResponse.stop_reason, options.responseFormat.type === "json");
+  const inputTokens = rawResponse.usage.input_tokens;
+  const outputTokens = rawResponse.usage.output_tokens;
+  const cacheWriteTokens = rawResponse.usage.cache_creation_input_tokens ?? 0;
+  const cacheReadTokens = rawResponse.usage.cache_read_input_tokens ?? 0;
+  parts.push({
+    type: "finish",
+    reason: finishReason,
+    usage: {
+      inputTokens: {
+        uncached: inputTokens,
+        total: inputTokens + cacheWriteTokens + cacheReadTokens,
+        cacheRead: cacheReadTokens,
+        cacheWrite: cacheWriteTokens
+      },
+      outputTokens: {
+        total: outputTokens,
+        text: undefined,
+        reasoning: undefined
+      }
+    },
+    response: buildHttpResponseDetails(response),
+    metadata: {
+      anthropic: {
+        container: rawResponse.container ?? null,
+        contextManagement: rawResponse.context_management ?? null,
+        usage: rawResponse.usage,
+        stopSequence: rawResponse.stop_sequence
+      }
+    }
+  });
+  return parts;
+});
+const makeStreamResponse = /*#__PURE__*/Effect.fnUntraced(function* ({
+  stream,
+  response,
+  options,
+  toolNameMapper
+}) {
+  const citableDocuments = extractCitableDocuments(options.prompt);
+  let container = null;
+  let contextManagement = null;
+  let finishReason = "unknown";
+  let stopSequence = null;
+  let rawUsage = null;
+  const mcpToolCalls = new Map();
+  const serverToolCalls = new Map();
+  const contentBlocks = new Map();
+  const usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheWriteInputTokens: 0
+  };
+  let blockType = undefined;
+  return stream.pipe(Stream.mapEffect(Effect.fnUntraced(function* (event) {
+    const parts = [];
+    switch (event.type) {
+      case "message_start":
+        {
+          rawUsage = {
+            ...event.message.usage
+          };
+          usage.inputTokens = event.message.usage.input_tokens;
+          usage.cacheReadInputTokens = event.message.usage.cache_read_input_tokens ?? 0;
+          usage.cacheWriteInputTokens = event.message.usage.cache_creation_input_tokens ?? 0;
+          if (Predicate.isNotNullish(event.message.container)) {
+            container = event.message.container;
+          }
+          if (Predicate.isNotNull(event.message.stop_sequence)) {
+            stopSequence = event.message.stop_sequence;
+          }
+          if (Predicate.isNotNull(event.message.stop_reason)) {
+            finishReason = InternalUtilities.resolveFinishReason(event.message.stop_reason);
+          }
+          parts.push({
+            type: "response-metadata",
+            id: event.message.id,
+            modelId: event.message.model,
+            timestamp: DateTime.formatIso(yield* DateTime.now),
+            request: buildHttpRequestDetails(response.request)
+          });
+          // Process pre-populated content blocks
+          if (Predicate.isNotNullish(event.message.content) && event.message.content.length > 0) {
+            for (let i = 0; i < event.message.content.length; i++) {
+              const part = event.message.content[i];
+              if (part.type === "tool_use") {
+                const callerInfo = Predicate.isNotUndefined(part.caller) ? {
+                  type: part.caller.type,
+                  toolId: "tool_id" in part.caller ? part.caller.tool_id : null
+                } : undefined;
+                parts.push({
+                  type: "tool-params-start",
+                  id: part.id,
+                  name: part.name
+                });
+                parts.push({
+                  type: "tool-params-delta",
+                  id: part.id,
+                  delta: JSON.stringify(part.input ?? {})
+                });
+                parts.push({
+                  type: "tool-params-end",
+                  id: part.id
+                });
+                const params = yield* transformToolCallParams(options.tools, part.name, part.input);
+                parts.push({
+                  type: "tool-call",
+                  id: part.id,
+                  name: part.name,
+                  params,
+                  ...(Predicate.isNotUndefined(callerInfo) ? {
+                    metadata: {
+                      anthropic: {
+                        caller: callerInfo
+                      }
+                    }
+                  } : undefined)
+                });
+              }
+            }
+          }
+          break;
+        }
+      case "message_delta":
+        {
+          rawUsage = {
+            ...rawUsage,
+            ...event.usage
+          };
+          if (Predicate.isNotNull(event.usage.input_tokens) && usage.inputTokens !== event.usage.input_tokens) {
+            usage.inputTokens = event.usage.input_tokens;
+          }
+          usage.outputTokens = event.usage.output_tokens;
+          if (Predicate.isNotNull(event.usage.cache_read_input_tokens) && usage.cacheReadInputTokens !== event.usage.cache_read_input_tokens) {
+            usage.cacheReadInputTokens = event.usage.cache_read_input_tokens;
+          }
+          if (Predicate.isNotNull(event.usage.cache_creation_input_tokens) && usage.cacheWriteInputTokens !== event.usage.cache_creation_input_tokens) {
+            usage.cacheWriteInputTokens = event.usage.cache_creation_input_tokens;
+          }
+          if (Predicate.isNotNullish(event.delta.container)) {
+            container = event.delta.container;
+          }
+          if (Predicate.isNotNullish(event.context_management)) {
+            contextManagement = event.context_management;
+          }
+          if (Predicate.isNotNull(event.delta.stop_reason)) {
+            finishReason = InternalUtilities.resolveFinishReason(event.delta.stop_reason);
+          }
+          if (Predicate.isNotNull(event.delta.stop_sequence)) {
+            stopSequence = event.delta.stop_sequence;
+          }
+          break;
+        }
+      case "message_stop":
+        {
+          const metadata = {
+            anthropic: {
+              container,
+              contextManagement,
+              stopSequence,
+              usage: rawUsage
+            }
+          };
+          parts.push({
+            type: "finish",
+            reason: finishReason,
+            usage: {
+              inputTokens: {
+                uncached: usage.inputTokens,
+                total: usage.inputTokens + usage.cacheWriteInputTokens + usage.cacheReadInputTokens,
+                cacheRead: usage.cacheReadInputTokens,
+                cacheWrite: usage.cacheWriteInputTokens
+              },
+              outputTokens: {
+                total: usage.outputTokens,
+                text: undefined,
+                reasoning: undefined
+              }
+            },
+            response: buildHttpResponseDetails(response),
+            metadata
+          });
+          break;
+        }
+      case "content_block_start":
+        {
+          blockType = event.content_block.type;
+          switch (event.content_block.type) {
+            case "text":
+              {
+                contentBlocks.set(event.index, {
+                  type: "text"
+                });
+                parts.push({
+                  type: "text-start",
+                  id: event.index.toString()
+                });
+                break;
+              }
+            case "thinking":
+              {
+                contentBlocks.set(event.index, {
+                  type: "reasoning"
+                });
+                parts.push({
+                  type: "reasoning-start",
+                  id: event.index.toString()
+                });
+                break;
+              }
+            case "redacted_thinking":
+              {
+                contentBlocks.set(event.index, {
+                  type: "reasoning"
+                });
+                const metadata = {
+                  anthropic: {
+                    info: {
+                      type: "redacted_thinking",
+                      redactedData: event.content_block.data
+                    }
+                  }
+                };
+                parts.push({
+                  type: "reasoning-start",
+                  id: event.index.toString(),
+                  metadata
+                });
+                break;
+              }
+            case "tool_use":
+              {
+                const part = event.content_block;
+                const caller = Predicate.isNotUndefined(part.caller) ? {
+                  type: part.caller.type,
+                  toolId: "tool_id" in part.caller ? part.caller.tool_id : null
+                } : undefined;
+                const hasParams = Object.keys(part.input).length > 0;
+                const initialParams = hasParams ? JSON.stringify(part.input) : "";
+                contentBlocks.set(event.index, {
+                  type: "tool-call",
+                  id: part.id,
+                  name: part.name,
+                  params: initialParams,
+                  firstDelta: initialParams.length > 0,
+                  ...(Predicate.isNotUndefined(caller) ? {
+                    caller
+                  } : undefined)
+                });
+                parts.push({
+                  type: "tool-params-start",
+                  id: part.id,
+                  name: part.name
+                });
+                break;
+              }
+            case "server_tool_use":
+              {
+                const part = event.content_block;
+                if (part.name === "code_execution" || part.name === "bash_code_execution" || part.name === "text_editor_code_execution" || part.name === "web_fetch" || part.name === "web_search") {
+                  const toolName = toolNameMapper.getCustomName(part.name === "bash_code_execution" || part.name === "text_editor_code_execution" ? "code_execution" : part.name);
+                  contentBlocks.set(event.index, {
+                    type: "tool-call",
+                    id: part.id,
+                    name: toolName,
+                    params: "",
+                    firstDelta: true,
+                    providerName: part.name,
+                    providerExecuted: true
+                  });
+                  parts.push({
+                    type: "tool-params-start",
+                    id: part.id,
+                    name: toolName,
+                    providerExecuted: true
+                  });
+                } else if (part.name === "tool_search_tool_bm25" || part.name === "tool_search_tool_regex") {
+                  serverToolCalls.set(part.id, part.name);
+                  const toolName = toolNameMapper.getCustomName(part.name);
+                  contentBlocks.set(event.index, {
+                    type: "tool-call",
+                    id: part.id,
+                    name: toolName,
+                    params: "",
+                    firstDelta: true,
+                    providerName: part.name,
+                    providerExecuted: true
+                  });
+                  parts.push({
+                    type: "tool-params-start",
+                    id: part.id,
+                    name: toolName,
+                    providerExecuted: true
+                  });
+                }
+                break;
+              }
+            case "web_fetch_tool_result":
+              {
+                const part = event.content_block;
+                const toolName = toolNameMapper.getCustomName("web_fetch");
+                if (part.content.type === "web_fetch_result") {
+                  citableDocuments.push({
+                    title: part.content.content.title ?? part.content.url,
+                    mediaType: part.content.content.source.media_type
+                  });
+                  parts.push({
+                    type: "tool-result",
+                    id: part.tool_use_id,
+                    name: toolName,
+                    isFailure: false,
+                    result: part.content
+                  });
+                } else {
+                  parts.push({
+                    type: "tool-result",
+                    id: part.tool_use_id,
+                    name: toolName,
+                    isFailure: true,
+                    result: part.content
+                  });
+                }
+                break;
+              }
+            case "web_search_tool_result":
+              {
+                const part = event.content_block;
+                const toolName = toolNameMapper.getCustomName("web_search");
+                if (Predicate.hasProperty(part.content, "type")) {
+                  parts.push({
+                    type: "tool-result",
+                    id: part.tool_use_id,
+                    name: toolName,
+                    isFailure: true,
+                    result: part.content
+                  });
+                } else {
+                  const idGenerator = yield* IdGenerator.IdGenerator;
+                  parts.push({
+                    type: "tool-result",
+                    id: part.tool_use_id,
+                    name: toolName,
+                    isFailure: false,
+                    result: part.content
+                  });
+                  const content = part.content;
+                  for (const result of content) {
+                    const id = yield* idGenerator.generateId();
+                    parts.push({
+                      type: "source",
+                      sourceType: "url",
+                      id,
+                      url: result.url,
+                      title: result.title,
+                      metadata: {
+                        anthropic: {
+                          source: "web",
+                          pageAge: result.page_age
+                        }
+                      }
+                    });
+                  }
+                }
+                break;
+              }
+            case "code_execution_tool_result":
+              {
+                const part = event.content_block;
+                const toolName = toolNameMapper.getCustomName("code_execution");
+                if (part.content.type === "code_execution_result") {
+                  parts.push({
+                    type: "tool-result",
+                    id: part.tool_use_id,
+                    name: toolName,
+                    isFailure: false,
+                    result: part.content
+                  });
+                } else {
+                  parts.push({
+                    type: "tool-result",
+                    id: part.tool_use_id,
+                    name: toolName,
+                    isFailure: true,
+                    result: part.content
+                  });
+                }
+                break;
+              }
+            case "bash_code_execution_tool_result":
+            case "text_editor_code_execution_tool_result":
+              {
+                const part = event.content_block;
+                const toolName = toolNameMapper.getCustomName("code_execution");
+                if (part.content.type === "bash_code_execution_tool_result_error" || part.content.type === "text_editor_code_execution_tool_result_error") {
+                  parts.push({
+                    type: "tool-result",
+                    id: part.tool_use_id,
+                    name: toolName,
+                    isFailure: true,
+                    result: part.content
+                  });
+                } else {
+                  parts.push({
+                    type: "tool-result",
+                    id: part.tool_use_id,
+                    name: toolName,
+                    isFailure: false,
+                    result: part.content
+                  });
+                }
+                break;
+              }
+            case "tool_search_tool_result":
+              {
+                const part = event.content_block;
+                let providerName = serverToolCalls.get(part.tool_use_id);
+                if (Predicate.isUndefined(providerName)) {
+                  const bm25Name = toolNameMapper.getCustomName("tool_search_tool_bm25");
+                  const regexName = toolNameMapper.getCustomName("tool_search_tool_regex");
+                  if (bm25Name !== "tool_search_tool_bm25") {
+                    providerName = "tool_search_tool_bm25";
+                  } else if (regexName !== "tool_search_tool_regex") {
+                    providerName = "tool_search_tool_regex";
+                  }
+                }
+                const toolName = toolNameMapper.getCustomName(providerName);
+                if (part.content.type === "tool_search_tool_search_result") {
+                  parts.push({
+                    type: "tool-result",
+                    id: part.tool_use_id,
+                    name: toolName,
+                    isFailure: false,
+                    result: part.content.tool_references
+                  });
+                } else {
+                  parts.push({
+                    type: "tool-result",
+                    id: part.tool_use_id,
+                    name: toolName,
+                    isFailure: true,
+                    result: part.content
+                  });
+                }
+                break;
+              }
+            case "mcp_tool_use":
+              {
+                const part = event.content_block;
+                const toolCall = {
+                  type: "tool-call",
+                  id: part.id,
+                  name: part.name,
+                  params: part.input,
+                  providerExecuted: true,
+                  metadata: {
+                    anthropic: {
+                      mcp_tool: {
+                        server: part.server_name
+                      }
+                    }
+                  }
+                };
+                mcpToolCalls.set(part.id, toolCall);
+                parts.push(toolCall);
+                break;
+              }
+            case "mcp_tool_result":
+              {
+                const part = event.content_block;
+                const toolCall = mcpToolCalls.get(part.tool_use_id);
+                const mcpMetadata = toolCall?.metadata?.anthropic?.mcp_tool;
+                if (Predicate.isNotUndefined(toolCall)) {
+                  parts.push({
+                    type: "tool-result",
+                    id: part.tool_use_id,
+                    name: toolCall.name,
+                    isFailure: part.is_error,
+                    result: part.content,
+                    metadata: {
+                      anthropic: {
+                        ...(Predicate.isNotNullish(mcpMetadata) ? {
+                          mcp_tool: mcpMetadata
+                        } : undefined)
+                      }
+                    }
+                  });
+                }
+                break;
+              }
+          }
+          break;
+        }
+      case "content_block_delta":
+        {
+          const part = event.delta;
+          switch (part.type) {
+            case "text_delta":
+              {
+                parts.push({
+                  type: "text-delta",
+                  id: event.index.toString(),
+                  delta: part.text
+                });
+                break;
+              }
+            case "thinking_delta":
+              {
+                parts.push({
+                  type: "reasoning-delta",
+                  id: event.index.toString(),
+                  delta: part.thinking
+                });
+                break;
+              }
+            case "signature_delta":
+              {
+                if (blockType === "thinking") {
+                  parts.push({
+                    type: "reasoning-delta",
+                    id: event.index.toString(),
+                    delta: "",
+                    metadata: {
+                      anthropic: {
+                        info: {
+                          type: "thinking",
+                          signature: part.signature
+                        }
+                      }
+                    }
+                  });
+                }
+                break;
+              }
+            case "input_json_delta":
+              {
+                let delta = part.partial_json;
+                // Skip empty deltas
+                if (delta.length === 0) {
+                  break;
+                }
+                const contentBlock = contentBlocks.get(event.index);
+                // Skip invalid deltas
+                if (Predicate.isUndefined(contentBlock)) {
+                  break;
+                }
+                // Skip non-tool-call deltas
+                if (contentBlock.type !== "tool-call") {
+                  break;
+                }
+                if (contentBlock.firstDelta && (contentBlock.providerName === "bash_code_execution" || contentBlock.providerName === "text_editor_code_execution")) {
+                  delta = `{"type":${contentBlock.providerName},${delta.substring(1)}}`;
+                }
+                parts.push({
+                  type: "tool-params-delta",
+                  id: contentBlock.id,
+                  delta
+                });
+                contentBlock.params += delta;
+                contentBlock.firstDelta = false;
+                break;
+              }
+            case "citations_delta":
+              {
+                const source = yield* processCitation(part.citation, citableDocuments);
+                if (Predicate.isNotUndefined(source)) {
+                  parts.push(source);
+                }
+                break;
+              }
+          }
+          break;
+        }
+      case "content_block_stop":
+        {
+          const contentBlock = contentBlocks.get(event.index);
+          if (Predicate.isNotUndefined(contentBlock)) {
+            switch (contentBlock.type) {
+              case "text":
+                {
+                  parts.push({
+                    type: "text-end",
+                    id: event.index.toString()
+                  });
+                  break;
+                }
+              case "reasoning":
+                {
+                  parts.push({
+                    type: "reasoning-end",
+                    id: event.index.toString()
+                  });
+                  break;
+                }
+              case "tool-call":
+                {
+                  parts.push({
+                    type: "tool-params-end",
+                    id: contentBlock.id
+                  });
+                  // For code execution, inject the `programmatic-tool-call` type
+                  // when the input format is `{ code }`
+                  let finalParams = contentBlock.params.length === 0 ? "{}" : contentBlock.params;
+                  if (contentBlock.providerName === "code_execution") {
+                    // @effect-diagnostics-next-line tryCatchInEffectGen:off
+                    try {
+                      const params = Tool.unsafeSecureJsonParse(finalParams);
+                      if (Predicate.hasProperty(params, "code") && !Predicate.hasProperty(params, "type")) {
+                        finalParams = JSON.stringify({
+                          type: "programmatic-tool-call",
+                          ...params
+                        });
+                      }
+                    } catch {
+                      // Ignore errors and use original tool call parameters
+                    }
+                  }
+                  const params = contentBlock.providerExecuted === true ? finalParams : transformToolCallParams(options.tools, contentBlock.name, finalParams);
+                  parts.push({
+                    type: "tool-call",
+                    id: contentBlock.id,
+                    name: contentBlock.name,
+                    params,
+                    providerExecuted: contentBlock.providerExecuted,
+                    ...(Predicate.isNotUndefined(contentBlock.caller) ? {
+                      metadata: {
+                        anthropic: {
+                          caller: contentBlock.caller
+                        }
+                      }
+                    } : undefined)
+                  });
+                }
+            }
+            contentBlocks.delete(event.index);
+          }
+          blockType = undefined;
+          break;
+        }
+      case "error":
+        {
+          parts.push({
+            type: "error",
+            error: event.error,
+            metadata: {
+              anthropic: {
+                requestId: event.request_id
+              }
+            }
+          });
+          break;
+        }
+    }
+    return parts;
+  })), Stream.flattenIterable);
+});
+// =============================================================================
+// Telemetry
+// =============================================================================
+const annotateRequest = (span, request) => {
+  addGenAIAnnotations(span, {
+    system: "anthropic",
+    operation: {
+      name: "chat"
+    },
+    request: {
+      model: request.model,
+      temperature: request.temperature,
+      topK: request.top_k,
+      topP: request.top_p,
+      maxTokens: request.max_tokens,
+      stopSequences: Arr.ensure(request.stop_sequences).filter(Predicate.isNotNullish)
+    }
+  });
+};
+const annotateResponse = (span, response) => {
+  addGenAIAnnotations(span, {
+    response: {
+      id: response.id,
+      model: response.model,
+      finishReasons: response.stop_reason ? [response.stop_reason] : undefined
+    },
+    usage: {
+      inputTokens: response.usage.input_tokens,
+      outputTokens: response.usage.output_tokens
+    }
+  });
+};
+const annotateStreamResponse = (span, part) => {
+  if (part.type === "response-metadata") {
+    addGenAIAnnotations(span, {
+      response: {
+        id: part.id,
+        model: part.modelId
+      }
+    });
+  }
+  if (part.type === "finish") {
+    addGenAIAnnotations(span, {
+      response: {
+        finishReasons: [part.reason]
+      },
+      usage: {
+        inputTokens: part.usage.inputTokens.uncached,
+        outputTokens: part.usage.outputTokens.total
+      }
+    });
+  }
+};
+const groupMessages = prompt => {
+  const messages = [];
+  let current = undefined;
+  for (const message of prompt.content) {
+    switch (message.role) {
+      case "system":
+        {
+          if (current?.type !== "system") {
+            current = {
+              type: "system",
+              messages: []
+            };
+            messages.push(current);
+          }
+          current.messages.push(message);
+          break;
+        }
+      case "assistant":
+        {
+          if (current?.type !== "assistant") {
+            current = {
+              type: "assistant",
+              messages: []
+            };
+            messages.push(current);
+          }
+          current.messages.push(message);
+          break;
+        }
+      case "tool":
+      case "user":
+        {
+          if (current?.type !== "user") {
+            current = {
+              type: "user",
+              messages: []
+            };
+            messages.push(current);
+          }
+          current.messages.push(message);
+          break;
+        }
+    }
+  }
+  return messages;
+};
+/**
+ * Checks if data is a URL (either a URL object or a URL string).
+ */
+const isUrlData = data => data instanceof URL || isUrlString(data);
+const isUrlString = data => typeof data === "string" && /^https?:\/\//i.test(data);
+const getUrlString = data => data instanceof URL ? data.toString() : data;
+const getCacheControl = part => part.options.anthropic?.cacheControl ?? null;
+const getDocumentMetadata = part => {
+  const options = part.options.anthropic;
+  if (Predicate.isNotUndefined(options)) {
+    return {
+      title: options?.documentTitle ?? null,
+      context: options?.documentContext ?? null
+    };
+  }
+  return null;
+};
+const areCitationsEnabled = part => part.options.anthropic?.citations?.enabled ?? false;
+const isCitationPart = part => part.type === "file" && (part.mediaType === "application/pdf" || part.mediaType === "text/plain") ? areCitationsEnabled(part) : false;
+const extractCitableDocuments = prompt => {
+  const citableDocuments = [];
+  for (const message of prompt.content) {
+    if (message.role === "user") {
+      for (const part of message.content) {
+        if (isCitationPart(part)) {
+          citableDocuments.push({
+            title: part.fileName ?? "Untitled Document",
+            fileName: part.fileName,
+            mediaType: part.mediaType
+          });
+        }
+      }
+    }
+  }
+  return citableDocuments;
+};
+const processCitation = /*#__PURE__*/Effect.fnUntraced(function* (citation, citableDocuments) {
+  const idGenerator = yield* IdGenerator.IdGenerator;
+  if (citation.type === "page_location" || citation.type === "char_location") {
+    const citedDocument = citableDocuments[citation.document_index];
+    if (Predicate.isNotUndefined(citedDocument)) {
+      const id = yield* idGenerator.generateId();
+      const metadata = citation.type === "char_location" ? {
+        source: "document",
+        type: citation.type,
+        citedText: citation.cited_text,
+        startCharIndex: citation.start_char_index,
+        endCharIndex: citation.end_char_index
+      } : {
+        source: "document",
+        type: citation.type,
+        citedText: citation.cited_text,
+        startPageNumber: citation.start_page_number,
+        endPageNumber: citation.end_page_number
+      };
+      return {
+        type: "source",
+        sourceType: "document",
+        id,
+        mediaType: citedDocument.mediaType,
+        title: citation.document_title ?? citedDocument.title,
+        ...(Predicate.isNotUndefined(citedDocument.fileName) ? {
+          fileName: citedDocument.fileName
+        } : undefined),
+        metadata: {
+          anthropic: metadata
+        }
+      };
+    }
+  }
+  if (citation.type === "web_search_result_location") {
+    const id = yield* idGenerator.generateId();
+    const metadata = {
+      source: "url",
+      citedText: citation.cited_text,
+      encryptedIndex: citation.encrypted_index
+    };
+    return {
+      type: "source",
+      sourceType: "url",
+      id,
+      url: citation.url,
+      title: citation.title ?? "Untitled",
+      metadata: {
+        anthropic: metadata
+      }
+    };
+  }
+  return undefined;
+});
+/**
+ * Returns the capabilities of a Claude model that are used for defaults and feature selection.
+ *
+ * @see https://docs.claude.com/en/docs/about-claude/models/overview#model-comparison-table
+ * @see https://platform.claude.com/docs/en/build-with-claude/structured-outputs
+ */
+const getModelCapabilities = modelId => {
+  if (modelId.includes("claude-sonnet-4-5") || modelId.includes("claude-opus-4-5") || modelId.includes("claude-haiku-4-5")) {
+    return {
+      maxOutputTokens: 64000,
+      supportsStructuredOutput: true,
+      isKnownModel: true
+    };
+  } else if (modelId.includes("claude-opus-4-1")) {
+    return {
+      maxOutputTokens: 32000,
+      supportsStructuredOutput: true,
+      isKnownModel: true
+    };
+  } else if (modelId.includes("claude-sonnet-4-") || modelId.includes("claude-3-7-sonnet")) {
+    return {
+      maxOutputTokens: 64000,
+      supportsStructuredOutput: false,
+      isKnownModel: true
+    };
+  } else if (modelId.includes("claude-opus-4-")) {
+    return {
+      maxOutputTokens: 32000,
+      supportsStructuredOutput: false,
+      isKnownModel: true
+    };
+  } else if (modelId.includes("claude-3-5-haiku")) {
+    return {
+      maxOutputTokens: 8192,
+      supportsStructuredOutput: false,
+      isKnownModel: true
+    };
+  } else if (modelId.includes("claude-3-haiku")) {
+    return {
+      maxOutputTokens: 4096,
+      supportsStructuredOutput: false,
+      isKnownModel: true
+    };
+  } else {
+    return {
+      maxOutputTokens: 4096,
+      supportsStructuredOutput: false,
+      isKnownModel: false
+    };
+  }
+};
+const unsupportedSchemaError = (error, method) => AiError.make({
+  module: "AnthropicLanguageModel",
+  method,
+  reason: new AiError.UnsupportedSchemaError({
+    description: error instanceof Error ? error.message : String(error)
+  })
+});
+const tryCodecTransform = (schema, method) => Effect.try({
+  try: () => toCodecAnthropic(schema),
+  catch: error => unsupportedSchemaError(error, method)
+});
+const tryJsonSchema = (schema, method) => Effect.try({
+  try: () => Tool.getJsonSchemaFromSchema(schema, {
+    transformer: toCodecAnthropic
+  }),
+  catch: error => unsupportedSchemaError(error, method)
+});
+const getOutputFormat = /*#__PURE__*/Effect.fnUntraced(function* ({
+  capabilities,
+  options
+}) {
+  if (options.responseFormat.type === "json" && capabilities.supportsStructuredOutput) {
+    const jsonSchema = yield* tryJsonSchema(options.responseFormat.schema, "getOutputFormat");
+    return {
+      type: "json_schema",
+      schema: jsonSchema
+    };
+  }
+  return undefined;
+});
+const transformToolCallParams = /*#__PURE__*/Effect.fnUntraced(function* (tools, toolName, toolParams) {
+  const tool = tools.find(tool => tool.name === toolName);
+  if (Predicate.isUndefined(tool)) {
+    return yield* AiError.make({
+      module: "AnthropicLanguageModel",
+      method: "makeResponse",
+      reason: new AiError.ToolNotFoundError({
+        toolName,
+        availableTools: tools.map(tool => tool.name)
+      })
+    });
+  }
+  const {
+    codec
+  } = yield* tryCodecTransform(tool.parametersSchema, "makeResponse");
+  const transform = Schema.decodeEffect(codec);
+  return yield* transform(toolParams).pipe(Effect.mapError(error => AiError.make({
+    module: "AnthropicLanguageModel",
+    method: "makeResponse",
+    reason: new AiError.ToolParameterValidationError({
+      toolName,
+      toolParams,
+      description: error.issue.toString()
+    })
+  })));
+});
+//# sourceMappingURL=AnthropicLanguageModel.js.map