@warlock.js/ai-anthropic 4.1.1

package/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["AIError","ProviderTimeoutError","ProviderAuthError","QuotaExceededError","ProviderRateLimitError","ContextLengthExceededError","InvalidRequestError","ProviderError","APIError","APIConnectionTimeoutError","log","Anthropic"],"sources":["../../../../../@warlock.js/ai-anthropic/src/known-vision-models.ts","../../../../../@warlock.js/ai-anthropic/src/utils/map-stop-reason.ts","../../../../../@warlock.js/ai-anthropic/src/utils/to-anthropic-messages.ts","../../../../../@warlock.js/ai-anthropic/src/utils/to-anthropic-tools.ts","../../../../../@warlock.js/ai-anthropic/src/utils/wrap-anthropic-error.ts","../../../../../@warlock.js/ai-anthropic/src/model.ts","../../../../../@warlock.js/ai-anthropic/src/sdk.ts"],"sourcesContent":["/**\n * Model-name prefixes for Claude families that accept image input\n * (vision) on the Messages API.\n *\n * Every Claude 3, Claude 3.5/3.7, and Claude 4 family model is\n * multimodal, so the list covers both the dotted legacy naming\n * (`claude-3-haiku-...`, `claude-3-5-sonnet-...`) and the current\n * `claude-<tier>-4-*` naming (`claude-opus-4-7`, `claude-sonnet-4-6`,\n * `claude-haiku-4-5`). Pre-3 families (`claude-2`, `claude-instant`)\n * are text-only and intentionally absent.\n *\n * Matched as a prefix so dated variants (`claude-opus-4-20250514`) are\n * covered without listing every release tag. Devs can always override\n * per-model via `anthropic.model({ name, vision: true | false })` —\n * explicit config wins over inference in either direction.\n */\nconst VISION_CAPABLE_PREFIXES = [\n  \"claude-3\",\n  \"claude-4\",\n  \"claude-opus-4\",\n  \"claude-sonnet-4\",\n  \"claude-haiku-4\",\n];\n\n/**\n * Infer whether a given Claude model name supports vision based on the\n * known-prefix list. Unknown models default to `false` so that passing\n * an image attachment to an unsupported model surfaces a clear,\n * agent-side capability error instead of an opaque Anthropic 400.\n *\n * @example\n * inferVisionCapability(\"claude-sonnet-4-6\");      // → true\n * inferVisionCapability(\"claude-3-5-sonnet-latest\"); // → true\n * inferVisionCapability(\"claude-2.1\");             // → false\n * inferVisionCapability(\"custom-proxy-llm\");       // → false\n */\nexport function inferVisionCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return VISION_CAPABLE_PREFIXES.some((prefix) => normalized.startsWith(prefix));\n}\n","import type { FinishReason } from \"@warlock.js/ai\";\n\nconst stopReasonMap: Record<string, FinishReason> = {\n  end_turn: \"stop\",\n  stop_sequence: \"stop\",\n  max_tokens: \"length\",\n  tool_use: \"tool_calls\",\n};\n\n/**\n * Map Anthropic's `stop_reason` to the normalized `FinishReason` union.\n *\n * `end_turn` / `stop_sequence` are both natural stops. `max_tokens`\n * maps to `length`. `tool_use` maps to `tool_calls`. Everything else —\n * `refusal` (policy intervention), `pause_turn` (incomplete\n * long-running turn), `null`, or any value a future API version adds —\n * falls through to `\"error\"` so the agent treats the trip as a\n * non-clean terminal rather than silently accepting a partial result.\n *\n * @example\n * mapStopReason(\"end_turn\");  // \"stop\"\n * mapStopReason(\"tool_use\");  // \"tool_calls\"\n * mapStopReason(\"refusal\");   // \"error\"\n * mapStopReason(null);        // \"error\"\n */\nexport function mapStopReason(raw: string | null | undefined): FinishReason {\n  return stopReasonMap[raw ?? \"\"] ?? \"error\";\n}\n","import type { ContentPart, Message } from \"@warlock.js/ai\";\nimport type Anthropic from \"@anthropic-ai/sdk\";\n\n/**\n * Result of splitting a vendor-neutral `Message[]` for the Anthropic\n * Messages API: the system prompt is hoisted to a top-level `system`\n * string (Anthropic has no `\"system\"` role inside `messages`), and the\n * remaining turns are mapped to `MessageParam[]`.\n */\nexport type AnthropicMessages = {\n  system: string | undefined;\n  messages: Anthropic.MessageParam[];\n};\n\nconst ANTHROPIC_IMAGE_MEDIA_TYPES = [\"image/jpeg\", \"image/png\", \"image/gif\", \"image/webp\"] as const;\n\ntype AnthropicImageMediaType = (typeof ANTHROPIC_IMAGE_MEDIA_TYPES)[number];\n\n/**\n * Convert vendor-neutral `Message[]` into Anthropic's request shape.\n *\n * Anthropic differs from the OpenAI Chat protocol in three ways this\n * function absorbs:\n *\n * 1. **No `system` role.** System messages are concatenated (newline-\n *    separated) and returned separately as the top-level `system`\n *    parameter.\n * 2. **Tool results are `user` turns.** A neutral `tool` message becomes\n *    a `user` message whose content is a single `tool_result` block\n *    keyed by `tool_use_id`.\n * 3. **Tool calls are `tool_use` content blocks.** An assistant message\n *    carrying `toolCalls` becomes an `assistant` message whose content\n *    is an optional leading `text` block followed by one `tool_use`\n *    block per call.\n *\n * Consecutive same-role turns are left as-is — the Messages API merges\n * them server-side.\n *\n * @example\n * const { system, messages } = toAnthropicMessages([\n *   { role: \"system\", content: \"Be concise.\" },\n *   { role: \"user\", content: \"Hi\" },\n * ]);\n * // system === \"Be concise.\"\n * // messages === [{ role: \"user\", content: \"Hi\" }]\n */\nexport function toAnthropicMessages(messages: Message[]): AnthropicMessages {\n  const systemParts: string[] = [];\n  const mapped: Anthropic.MessageParam[] = [];\n\n  for (const message of messages) {\n    if (message.role === \"system\") {\n      systemParts.push(stringifyContent(message.content));\n\n      continue;\n    }\n\n    if (message.role === \"tool\") {\n      mapped.push({\n        role: \"user\",\n        content: [\n          {\n            type: \"tool_result\",\n            tool_use_id: message.toolCallId ?? \"\",\n            content: stringifyContent(message.content),\n          },\n        ],\n      });\n\n      continue;\n    }\n\n    if (message.role === \"assistant\" && message.toolCalls && message.toolCalls.length > 0) {\n      const blocks: Anthropic.ContentBlockParam[] = [];\n      const text = stringifyContent(message.content);\n\n      if (text) {\n        blocks.push({ type: \"text\", text });\n      }\n\n      for (const toolCall of message.toolCalls) {\n        blocks.push({\n          type: \"tool_use\",\n          id: toolCall.id,\n          name: toolCall.name,\n          input: toolCall.input ?? {},\n        });\n      }\n\n      mapped.push({ role: \"assistant\", content: blocks });\n\n      continue;\n    }\n\n    if (message.role === \"user\" && Array.isArray(message.content)) {\n      mapped.push({\n        role: \"user\",\n        content: message.content.map(toAnthropicContentBlock),\n      });\n\n      continue;\n    }\n\n    mapped.push({\n      role: message.role === \"assistant\" ? \"assistant\" : \"user\",\n      content: stringifyContent(message.content),\n    });\n  }\n\n  return {\n    system: systemParts.length > 0 ? systemParts.join(\"\\n\\n\") : undefined,\n    messages: mapped,\n  };\n}\n\n/**\n * Multipart content is only meaningful on user messages — for any other\n * role collapse a `ContentPart[]` to its concatenated text so the wire\n * format stays valid. Plain strings pass through unchanged.\n */\nfunction stringifyContent(content: string | ContentPart[]): string {\n  if (typeof content === \"string\") {\n    return content;\n  }\n\n  return content\n    .filter((part): part is { type: \"text\"; text: string } => part.type === \"text\")\n    .map((part) => part.text)\n    .join(\"\");\n}\n\n/**\n * Map a single resolved `ContentPart` to an Anthropic content block.\n * Text passes straight through; images become an `image` block with a\n * `url` source (remote) or a `base64` source (inlined bytes). The\n * agent has already resolved every attachment before it reaches here,\n * so this never reads files or fetches URLs.\n */\nfunction toAnthropicContentBlock(part: ContentPart): Anthropic.ContentBlockParam {\n  if (part.type === \"text\") {\n    return { type: \"text\", text: part.text };\n  }\n\n  if (\"url\" in part.source) {\n    return { type: \"image\", source: { type: \"url\", url: part.source.url } };\n  }\n\n  return {\n    type: \"image\",\n    source: {\n      type: \"base64\",\n      media_type: part.source.mediaType as AnthropicImageMediaType,\n      data: part.source.base64,\n    },\n  };\n}\n","import { extractJsonSchema, type ToolConfig } from \"@warlock.js/ai\";\nimport type Anthropic from \"@anthropic-ai/sdk\";\n\n/**\n * Convert vendor-neutral `ToolConfig[]` into Anthropic's `tools` array.\n * Uses the shared `extractJsonSchema` helper; Anthropic requires the\n * input schema to be a JSON-Schema object, so a non-object extraction\n * is coerced into an empty-object schema rather than rejected — the\n * tool still registers and the model simply sees no parameters.\n *\n * @example\n * const tools = toAnthropicTools([weatherTool, calculatorTool]);\n * await client.messages.create({ model, max_tokens, messages, tools });\n */\nexport function toAnthropicTools(\n  tools: ToolConfig<unknown, unknown>[] | undefined,\n): Anthropic.Tool[] | undefined {\n  if (!tools || tools.length === 0) {\n    return undefined;\n  }\n\n  return tools.map((tool) => ({\n    name: tool.name,\n    description: tool.description,\n    input_schema: toInputSchema(tool.input),\n  }));\n}\n\n/**\n * Coerce the extracted JSON Schema into Anthropic's `Tool.InputSchema`\n * shape (root must be `{ type: \"object\" }`). Anything that isn't an\n * object schema degrades to a parameterless object so registration\n * never fails on a malformed extractor result.\n */\nfunction toInputSchema(input: ToolConfig<unknown, unknown>[\"input\"]): Anthropic.Tool.InputSchema {\n  const schema = extractJsonSchema(input);\n\n  if (schema && schema.type === \"object\") {\n    return schema as Anthropic.Tool.InputSchema;\n  }\n\n  return { type: \"object\" };\n}\n","import {\n  AIError,\n  ContextLengthExceededError,\n  InvalidRequestError,\n  ProviderAuthError,\n  ProviderError,\n  ProviderRateLimitError,\n  ProviderTimeoutError,\n  QuotaExceededError,\n} from \"@warlock.js/ai\";\nimport { APIConnectionTimeoutError, APIError } from \"@anthropic-ai/sdk\";\n\n/**\n * Raw-error fields the wrapper reads off an Anthropic SDK error.\n *\n * `APIError` exposes `status`, `type` (the `error.type` from the\n * response body, e.g. `\"rate_limit_error\"`), `message`, `headers`, and\n * `requestID`. We duck-type because wrapped retries, proxied errors,\n * and custom subclasses sometimes lose the `instanceof` relationship.\n */\ntype AnthropicErrorShape = {\n  status?: number;\n  type?: string | null;\n  message?: string;\n  headers?: HeaderBag | undefined;\n  name?: string;\n  requestId?: string;\n};\n\n/** Either a fetch `Headers` instance or a plain record (duck-typed tests). */\ntype HeaderBag = Headers | Record<string, string>;\n\n/**\n * Wrap any thrown value caught inside the Anthropic adapter into the\n * appropriate `@warlock.js/ai` `AIError` subclass.\n *\n * **Dispatch strategy.** Anthropic has no per-error machine `code`; the\n * stable identifier is `error.type` on the response body (surfaced as\n * `APIError.type`). Dispatch prefers `type`, falls back to `status`\n * when the body was stripped (common with proxies). Name-based\n * detection catches transport-layer timeouts that never produced an\n * HTTP response. The `invalid_request_error` branch additionally\n * sniffs the message for Anthropic's \"prompt is too long\" phrasing,\n * which is the only signal that a 400 was a context-length overflow.\n *\n * `AIError` instances pass through unchanged so `catch/throw wrap(e)`\n * pipelines never double-wrap.\n *\n * @example\n * try {\n *   return await this.client.messages.create(...);\n * } catch (thrown) {\n *   throw wrapAnthropicError(thrown);\n * }\n */\nexport function wrapAnthropicError(thrown: unknown): AIError {\n  if (thrown instanceof AIError) {\n    return thrown;\n  }\n\n  const shape = toShape(thrown);\n  const context = buildContext(shape);\n  const message = shape.message ?? (thrown instanceof Error ? thrown.message : String(thrown));\n\n  if (isTimeout(thrown, shape)) {\n    return new ProviderTimeoutError(message, { cause: thrown, context });\n  }\n\n  if (shape.type === \"authentication_error\" || shape.type === \"permission_error\") {\n    return new ProviderAuthError(message, { cause: thrown, context });\n  }\n\n  if (shape.status === 401 || shape.status === 403) {\n    return new ProviderAuthError(message, { cause: thrown, context });\n  }\n\n  if (shape.type === \"billing_error\") {\n    return new QuotaExceededError(message, { cause: thrown, context });\n  }\n\n  if (shape.type === \"rate_limit_error\" || shape.status === 429) {\n    return new ProviderRateLimitError(message, {\n      cause: thrown,\n      context,\n      retryAfter: parseRetryAfter(shape.headers),\n    });\n  }\n\n  if (shape.type === \"invalid_request_error\" || isClientStatus(shape.status)) {\n    if (/prompt is too long/i.test(message)) {\n      return new ContextLengthExceededError(message, { cause: thrown, context });\n    }\n\n    return new InvalidRequestError(message, { cause: thrown, context });\n  }\n\n  return new ProviderError(message, { cause: thrown, context });\n}\n\n/**\n * Read the raw error shape without depending on `instanceof APIError`\n * — proxies and re-wrappers strip the prototype chain. Duck-typing on\n * the visible fields is resilient to both.\n */\nfunction toShape(thrown: unknown): AnthropicErrorShape {\n  if (thrown instanceof APIError) {\n    return {\n      status: typeof thrown.status === \"number\" ? thrown.status : undefined,\n      type: thrown.type,\n      message: thrown.message,\n      headers: thrown.headers,\n      name: thrown.name,\n      requestId: thrown.requestID ?? undefined,\n    };\n  }\n\n  if (typeof thrown === \"object\" && thrown !== null) {\n    const raw = thrown as Record<string, unknown>;\n\n    return {\n      status: typeof raw.status === \"number\" ? raw.status : undefined,\n      type: typeof raw.type === \"string\" ? raw.type : undefined,\n      message: typeof raw.message === \"string\" ? raw.message : undefined,\n      headers: isHeaderBag(raw.headers) ? raw.headers : undefined,\n      name: typeof raw.name === \"string\" ? raw.name : undefined,\n      requestId: readRequestId(raw),\n    };\n  }\n\n  return {};\n}\n\n/**\n * Decide whether the thrown value represents a timeout. The Anthropic\n * SDK throws `APIConnectionTimeoutError` for transport-level timeouts;\n * Node surfaces `ETIMEDOUT` / `ECONNABORTED` on the socket layer.\n * Either signal counts.\n */\nfunction isTimeout(thrown: unknown, shape: AnthropicErrorShape): boolean {\n  if (thrown instanceof APIConnectionTimeoutError) {\n    return true;\n  }\n\n  if (shape.name === \"APIConnectionTimeoutError\") {\n    return true;\n  }\n\n  if (typeof thrown === \"object\" && thrown !== null) {\n    const code = (thrown as Record<string, unknown>).code;\n\n    if (code === \"ETIMEDOUT\" || code === \"ECONNABORTED\") {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/** True for HTTP 4xx — a client-side request problem, not a server fault. */\nfunction isClientStatus(status: number | undefined): boolean {\n  return typeof status === \"number\" && status >= 400 && status < 500;\n}\n\n/**\n * Attach the raw diagnostic fields to `error.context` so consumers\n * have everything the provider surfaced without each subclass having\n * to redeclare them. Never includes `cause` — that lives on\n * `error.cause`.\n */\nfunction buildContext(shape: AnthropicErrorShape): Record<string, unknown> {\n  const context: Record<string, unknown> = {};\n\n  if (shape.status !== undefined) {\n    context.status = shape.status;\n  }\n\n  if (shape.type) {\n    context.type = shape.type;\n  }\n\n  if (shape.requestId) {\n    context.requestId = shape.requestId;\n  }\n\n  return context;\n}\n\n/** Anthropic exposes the request id as `requestID`; some proxies use `request_id`. */\nfunction readRequestId(raw: Record<string, unknown>): string | undefined {\n  if (typeof raw.requestID === \"string\") {\n    return raw.requestID;\n  }\n\n  if (typeof raw.request_id === \"string\") {\n    return raw.request_id;\n  }\n\n  return undefined;\n}\n\nfunction isHeaderBag(value: unknown): value is HeaderBag {\n  return typeof value === \"object\" && value !== null;\n}\n\n/** Read a header value from either a `Headers` instance or a plain record. */\nfunction readHeader(headers: HeaderBag, name: string): string | undefined {\n  if (typeof (headers as Headers).get === \"function\") {\n    return (headers as Headers).get(name) ?? undefined;\n  }\n\n  const record = headers as Record<string, string>;\n\n  return record[name] ?? record[name.toLowerCase()];\n}\n\n/**\n * Parse the `Retry-After` response header (seconds per HTTP spec) into\n * milliseconds so consumers can feed it straight to `setTimeout`.\n * Returns `undefined` when missing or unparseable.\n */\nfunction parseRetryAfter(headers: HeaderBag | undefined): number | undefined {\n  if (!headers) {\n    return undefined;\n  }\n\n  const raw = readHeader(headers, \"retry-after\") ?? readHeader(headers, \"Retry-After\");\n\n  if (!raw) {\n    return undefined;\n  }\n\n  const seconds = Number(raw);\n\n  if (!Number.isFinite(seconds) || seconds < 0) {\n    return undefined;\n  }\n\n  return Math.round(seconds * 1000);\n}\n","import {\n  safeJsonParse,\n  type Message,\n  type ModelCallOptions,\n  type ModelCapabilities,\n  type ModelContract,\n  type ModelPricing,\n  type ModelResponse,\n  type ModelStreamChunk,\n  type ModelToolCallRequest,\n  type Usage,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport type Anthropic from \"@anthropic-ai/sdk\";\nimport type { AnthropicModelConfig } from \"./config.type\";\nimport { inferVisionCapability } from \"./known-vision-models\";\nimport { mapStopReason, toAnthropicMessages, toAnthropicTools, wrapAnthropicError } from \"./utils\";\n\nconst LOG_MODULE = \"ai.anthropic\";\n\n/**\n * Anthropic requires `max_tokens` on every request (unlike OpenAI,\n * where it is optional). When neither the per-call option nor the\n * model config supplies one, fall back to a generous default so a\n * caller who never thought about token caps still gets a complete\n * answer instead of a 400.\n */\nconst DEFAULT_MAX_TOKENS = 4096;\n\n/**\n * Anthropic-backed implementation of `ModelContract`.\n *\n * **Role.** The provider-facing bridge between the vendor-neutral\n * `@warlock.js/ai` agent runtime and the official `@anthropic-ai/sdk`\n * Messages API. Agents, workflows, and supervisors never talk to\n * Anthropic directly — they hold a `ModelContract`, and this class is\n * what makes that contract concrete for Claude models.\n *\n * **Responsibility.**\n * - Owns: a long-lived `Anthropic` client + frozen `ModelConfig`\n *   (name, temperature, maxTokens) used as defaults for every call.\n * - Owns: translating vendor-neutral `Message[]` / `ToolConfig[]` into\n *   Anthropic wire shapes (system hoisting, `tool_use` / `tool_result`\n *   blocks) on the way out, and translating Anthropic's content-block\n *   response (text, tool calls, stop reason, usage) back into the\n *   neutral shapes on the way in.\n * - Does NOT own: dispatching tools, deciding whether to loop, tracking\n *   conversation history, or retrying on failure — those are agent\n *   concerns. The model is a stateless (per-call) protocol adapter.\n *\n * Because it holds a live client and shared defaults, it is modeled as\n * a class (see §4.2 of code-style.md — \"long-lived state across\n * calls\").\n *\n * @example\n * import Anthropic from \"@anthropic-ai/sdk\";\n * const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });\n * const model = new AnthropicModel(client, { name: \"claude-sonnet-4-6\" });\n *\n * const myAgent = agent({\n *   model,\n *   systemPrompt: \"You are a helpful assistant.\",\n *   tools: [searchTool],\n * });\n *\n * const result = await myAgent.execute(\"Summarize today's news.\");\n */\nexport class AnthropicModel implements ModelContract {\n  public readonly name: string;\n  public readonly provider: string;\n  public readonly capabilities: ModelCapabilities;\n  public readonly pricing?: ModelPricing;\n\n  private readonly client: Anthropic;\n  private readonly config: AnthropicModelConfig;\n  private readonly logger: Logger = log;\n\n  public constructor(\n    client: Anthropic,\n    config: AnthropicModelConfig,\n    provider: string = \"anthropic\",\n  ) {\n    this.client = client;\n    this.config = config;\n    this.name = config.name;\n    this.provider = provider;\n    this.pricing = config.pricing;\n    this.capabilities = {\n      structuredOutput: config.structuredOutput ?? true,\n      vision: config.vision ?? inferVisionCapability(config.name),\n    };\n  }\n\n  /**\n   * Single-shot completion. Sends the full message list to the Messages\n   * endpoint, waits for the terminal response, and reshapes it into a\n   * vendor-neutral `ModelResponse`. Per-call `options` override the\n   * instance's `ModelConfig` defaults for this call only.\n   */\n  public async complete(messages: Message[], options?: ModelCallOptions): Promise<ModelResponse> {\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting call to messages.create\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: false,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let response: Anthropic.Message;\n\n    try {\n      response = await this.client.messages.create(\n        { ...this.buildParams(messages, options), stream: false },\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    const finishReason = mapStopReason(response.stop_reason);\n    const usage = this.extractUsage(response.usage);\n    const toolCalls = this.extractToolCalls(response.content);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"call to messages.create succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    return {\n      content: this.extractText(response.content),\n      finishReason,\n      usage,\n      toolCalls,\n    };\n  }\n\n  /**\n   * Incremental streaming completion. Yields neutral `ModelStreamChunk`s\n   * — `delta` for text tokens, `tool-call` once a `tool_use` block's\n   * arguments have fully accumulated, and a terminal `done` carrying the\n   * final finish reason + usage totals. Callers consume it with\n   * `for await`.\n   */\n  public async *stream(\n    messages: Message[],\n    options?: ModelCallOptions,\n  ): AsyncIterable<ModelStreamChunk> {\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting streaming call to messages.create\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: true,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let stream: Awaited<ReturnType<Anthropic[\"messages\"][\"create\"]>>;\n\n    try {\n      stream = await this.client.messages.create(\n        { ...this.buildParams(messages, options), stream: true },\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    let rawStopReason: string | null = null;\n    const usage: Usage = { input: 0, output: 0, total: 0 };\n    const toolBlocks = new Map<number, { id: string; name: string; json: string }>();\n\n    try {\n      for await (const event of stream as AsyncIterable<Anthropic.RawMessageStreamEvent>) {\n        if (event.type === \"message_start\") {\n          usage.input = event.message.usage.input_tokens ?? 0;\n\n          const cached = event.message.usage.cache_read_input_tokens;\n\n          if (cached !== null && cached !== undefined && cached > 0) {\n            usage.cachedTokens = cached;\n          }\n\n          continue;\n        }\n\n        if (event.type === \"content_block_start\") {\n          const block = event.content_block;\n\n          if (block.type === \"tool_use\") {\n            toolBlocks.set(event.index, { id: block.id, name: block.name, json: \"\" });\n          }\n\n          continue;\n        }\n\n        if (event.type === \"content_block_delta\") {\n          if (event.delta.type === \"text_delta\") {\n            yield { type: \"delta\", content: event.delta.text };\n          } else if (event.delta.type === \"input_json_delta\") {\n            const accumulator = toolBlocks.get(event.index);\n\n            if (accumulator) {\n              accumulator.json += event.delta.partial_json;\n            }\n          }\n\n          continue;\n        }\n\n        if (event.type === \"content_block_stop\") {\n          const accumulator = toolBlocks.get(event.index);\n\n          if (accumulator) {\n            yield {\n              type: \"tool-call\",\n              id: accumulator.id,\n              name: accumulator.name,\n              input: safeJsonParse<Record<string, unknown>>(accumulator.json, {}),\n            };\n\n            toolBlocks.delete(event.index);\n          }\n\n          continue;\n        }\n\n        if (event.type === \"message_delta\") {\n          rawStopReason = event.delta.stop_reason ?? rawStopReason;\n          usage.output = event.usage.output_tokens ?? usage.output;\n        }\n      }\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    usage.total = usage.input + usage.output;\n\n    const finishReason = mapStopReason(rawStopReason);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"Streaming call to messages.create succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    yield { type: \"done\", finishReason, usage };\n  }\n\n  /**\n   * Assemble the Anthropic request body shared by `complete()` and\n   * `stream()` (each adds its own `stream` literal so the SDK's create\n   * overload resolves to the right return type). Hoists the system\n   * prompt out of `messages`, resolves `max_tokens` (required by\n   * Anthropic) with the documented default, and conditionally attaches\n   * temperature, tools, and native structured output.\n   */\n  private buildParams(\n    messages: Message[],\n    options: ModelCallOptions | undefined,\n  ): Omit<Anthropic.MessageCreateParamsNonStreaming, \"stream\"> {\n    const { system, messages: anthropicMessages } = toAnthropicMessages(messages);\n    const temperature = options?.temperature ?? this.config.temperature;\n\n    return {\n      model: this.name,\n      max_tokens: options?.maxTokens ?? this.config.maxTokens ?? DEFAULT_MAX_TOKENS,\n      messages: anthropicMessages,\n      ...(system ? { system } : {}),\n      ...(temperature !== undefined ? { temperature } : {}),\n      ...this.buildTools(options?.tools),\n      ...this.buildStructuredOutput(options?.responseSchema),\n    };\n  }\n\n  /**\n   * Spread-friendly tools fragment. Returns an empty object when no\n   * tools were supplied so the caller can unconditionally spread it.\n   */\n  private buildTools(tools: ModelCallOptions[\"tools\"]): { tools?: Anthropic.Tool[] } {\n    const mapped = toAnthropicTools(tools);\n\n    return mapped ? { tools: mapped } : {};\n  }\n\n  /**\n   * Translate the neutral `responseSchema` option into Anthropic's\n   * native `output_config.format` (JSON-schema structured outputs).\n   *\n   * Only emitted when the model declares the `structuredOutput`\n   * capability AND the schema is a proper root-object JSON Schema —\n   * Anthropic rejects non-object roots. When the capability is off\n   * (config override) or the schema is non-object, returns an empty\n   * object: the agent has already injected a soft schema hint into the\n   * system prompt as the fallback, and client-side `validate()` still\n   * enforces shape.\n   */\n  private buildStructuredOutput(responseSchema: Record<string, unknown> | undefined): {\n    output_config?: Anthropic.OutputConfig;\n  } {\n    if (!responseSchema || !this.capabilities.structuredOutput) {\n      return {};\n    }\n\n    if (responseSchema.type !== \"object\" || typeof responseSchema.properties !== \"object\") {\n      return {};\n    }\n\n    return {\n      output_config: {\n        format: { type: \"json_schema\", schema: responseSchema },\n      },\n    };\n  }\n\n  /**\n   * Concatenate every `text` content block into the single neutral\n   * `content` string. `tool_use` and other block types are ignored\n   * here — tool calls are surfaced separately via `extractToolCalls`.\n   */\n  private extractText(content: Anthropic.ContentBlock[]): string {\n    return content\n      .filter((block): block is Anthropic.TextBlock => block.type === \"text\")\n      .map((block) => block.text)\n      .join(\"\");\n  }\n\n  /**\n   * Reshape Anthropic's `tool_use` content blocks into the neutral\n   * `ModelToolCallRequest[]`. Returns `undefined` when the model\n   * requested no tools so callers can branch on presence.\n   */\n  private extractToolCalls(\n    content: Anthropic.ContentBlock[],\n  ): ModelToolCallRequest[] | undefined {\n    const toolUses = content.filter(\n      (block): block is Anthropic.ToolUseBlock => block.type === \"tool_use\",\n    );\n\n    if (toolUses.length === 0) {\n      return undefined;\n    }\n\n    return toolUses.map((block) => ({\n      id: block.id,\n      name: block.name,\n      input: (block.input ?? {}) as Record<string, unknown>,\n    }));\n  }\n\n  /**\n   * Normalize Anthropic's `usage` block into the neutral `Usage` shape.\n   * Anthropic reports `input_tokens` / `output_tokens` separately with\n   * no pre-summed total, so `total` is computed. Cache-read tokens are\n   * surfaced as `cachedTokens` only when non-zero.\n   */\n  private extractUsage(raw: Anthropic.Usage): Usage {\n    const input = raw.input_tokens ?? 0;\n    const output = raw.output_tokens ?? 0;\n    const cached = raw.cache_read_input_tokens;\n\n    return {\n      input,\n      output,\n      total: input + output,\n      ...(cached !== null && cached !== undefined && cached > 0 ? { cachedTokens: cached } : {}),\n    };\n  }\n\n  /**\n   * Wrap a thrown provider error into the typed `AIError` hierarchy and\n   * emit the standard error log line before it propagates. Shared by\n   * every catch site so the log shape stays identical.\n   */\n  private logAndWrap(thrown: unknown) {\n    const wrapped = wrapAnthropicError(thrown);\n\n    this.logger.error(LOG_MODULE, \"error\", wrapped.message, {\n      code: wrapped.code,\n      context: wrapped.context,\n    });\n\n    return wrapped;\n  }\n}\n","import Anthropic from \"@anthropic-ai/sdk\";\nimport type { ModelContract, ModelPricing, SDKAdapterContract } from \"@warlock.js/ai\";\nimport { approximateTokenCount } from \"@warlock.js/ai\";\nimport type { AnthropicModelConfig, AnthropicSDKConfig } from \"./config.type\";\nimport { AnthropicModel } from \"./model\";\n\n/**\n * Anthropic-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for Claude models via the official\n * `@anthropic-ai/sdk`. A single `AnthropicSDK` instance holds one live\n * `Anthropic` client, shared by every `ModelContract` it produces via\n * `model()`. Users construct one SDK per account and reuse it across\n * all agents, workflows, and supervisors that target Anthropic.\n *\n * **Responsibility.**\n * - Owns: a long-lived `Anthropic` client (authentication, base URL)\n *   and its lifetime scope. Factory for `AnthropicModel` instances —\n *   each model call gets a reference to the same client.\n * - Does NOT own: anything per-call (tool execution, message history,\n *   streaming loop) — those live in `AnthropicModel` and the agent\n *   runtime. Does NOT implement `embedder()`: Anthropic ships no\n *   first-party embeddings API (the contract marks it optional).\n *\n * Modeled as a class (see §4.2 of code-style.md — \"long-lived state\n * across many calls\"): the `Anthropic` client is heavy to construct\n * and designed to be reused; keeping it on `this` makes that reuse\n * explicit and aligns with the `new Anthropic(...)` upstream\n * convention.\n *\n * @example\n * const anthropic = new AnthropicSDK({ apiKey: process.env.ANTHROPIC_API_KEY! });\n * const model = anthropic.model({ name: \"claude-sonnet-4-6\", temperature: 0.7 });\n * const tokens = await anthropic.count(\"Hello world\");\n *\n * @example\n * // Compose into an `ai.anthropic` namespace for ergonomic agent wiring\n * const ai = { agent, tool, systemPrompt, anthropic: new AnthropicSDK({ apiKey }) };\n * const myAgent = ai.agent({ model: ai.anthropic.model({ name: \"claude-haiku-4-5\" }) });\n */\nexport class AnthropicSDK implements SDKAdapterContract {\n  private readonly client: Anthropic;\n  private readonly provider: string;\n  private readonly pricing?: Record<string, ModelPricing>;\n\n  public constructor(config: AnthropicSDKConfig) {\n    this.client = new Anthropic({\n      apiKey: config.apiKey,\n      baseURL: config.baseURL,\n    });\n    this.provider = config.provider ?? \"anthropic\";\n    this.pricing = config.pricing;\n  }\n\n  /**\n   * Build an `AnthropicModel` bound to this SDK's client. Each call\n   * returns a fresh model instance, but all instances share the\n   * underlying `Anthropic` client — connection pools, rate limits, and\n   * authentication stay unified across every model produced here. The\n   * SDK's `provider` label is forwarded so every model self-identifies\n   * as coming from the same upstream.\n   *\n   * Pricing resolution: per-model `config.pricing` wins; otherwise the\n   * SDK-level registry entry keyed by `config.name`; otherwise\n   * `undefined` (no cost computed).\n   */\n  public model(config: AnthropicModelConfig): ModelContract {\n    const resolvedPricing = config.pricing ?? this.pricing?.[config.name];\n    const resolvedConfig: AnthropicModelConfig =\n      resolvedPricing === config.pricing ? config : { ...config, pricing: resolvedPricing };\n\n    return new AnthropicModel(this.client, resolvedConfig, this.provider);\n  }\n\n  /**\n   * Rough token-count estimate for a given text. Uses the\n   * character-heuristic (`approximateTokenCount`) from the core package\n   * — good enough for budgeting and quota guards, not for billing.\n   * Anthropic does expose a `messages.countTokens` endpoint, but that\n   * is a network round-trip; `count()` is intentionally offline and\n   * synchronous-cost. The optional model id is reserved for future\n   * per-model tokenizer dispatch; currently ignored.\n   */\n  public async count(text: string, _model?: string): Promise<number> {\n    return approximateTokenCount(text);\n  }\n}\n"],"mappings":"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"}

package/esm/config.type.d.mts

@@ -0,0 +1,72 @@
+import { ClientOptions } from "@anthropic-ai/sdk";
+import { ModelConfig, ModelPricing } from "@warlock.js/ai";
+
+//#region ../../@warlock.js/ai-anthropic/src/config.type.d.ts
+/**
+ * Configuration for the Anthropic SDK adapter.
+ *
+ * `provider` labels the SDK with the upstream you're pointing at —
+ * useful when the same Anthropic-compatible client is wired to a
+ * gateway or proxy. The label flows through to `ModelContract.provider`
+ * and surfaces on `AgentReport.model`, logs, and any middleware that
+ * branches on provider identity. Defaults to `"anthropic"` when omitted.
+ *
+ * `pricing` is an optional SDK-level registry keyed by model name. One
+ * source of truth per provider; matches how providers publish pricing
+ * tables. Resolution at `model()` call time: per-model `pricing` (on
+ * `AnthropicModelConfig`) > this SDK registry > `undefined`. When
+ * neither is set, `Usage.cost` stays `undefined` on every report this
+ * SDK's models produce.
+ *
+ * @example
+ * new AnthropicSDK({ apiKey: process.env.ANTHROPIC_API_KEY! });
+ *
+ * @example
+ * // SDK-level pricing registry — pricing in USD per million tokens.
+ * new AnthropicSDK({
+ *   apiKey,
+ *   pricing: {
+ *     "claude-haiku-4-5":  { input: 1,  output: 5,  cachedInput: 0.1 },
+ *     "claude-sonnet-4-6": { input: 3,  output: 15, cachedInput: 0.3 },
+ *   },
+ * });
+ */
+type AnthropicSDKConfig = ClientOptions & {
+  provider?: string;
+  /**
+   * Per-model USD pricing registry, keyed by model name. Surfaced onto
+   * every `AnthropicModel` produced by `model()`; per-model
+   * `AnthropicModelConfig.pricing` still wins when both are set.
+   */
+  pricing?: Record<string, ModelPricing>;
+};
+/**
+ * Per-model configuration for `AnthropicSDK.model()`. Extends the
+ * neutral `ModelConfig` with Anthropic-specific capability overrides.
+ *
+ * @example
+ * anthropic.model({ name: "claude-sonnet-4-6" });               // vision auto-true
+ * anthropic.model({ name: "custom-proxy-model", vision: false }); // dev override
+ */
+type AnthropicModelConfig = ModelConfig & {
+  /**
+   * Override the auto-inferred vision capability. When omitted, the
+   * adapter checks the model name against the known Claude vision
+   * families (see `known-vision-models.ts`). Setting `true` or `false`
+   * explicitly always wins over inference — useful for proxied
+   * deployments or capability-degraded testing.
+   */
+  vision?: boolean;
+  /**
+   * Override the inferred `structuredOutput` capability. When omitted,
+   * the adapter treats the model as capable and forwards
+   * `responseSchema` via Anthropic's native `output_config.format`
+   * (JSON-schema structured outputs). Set to `false` for models or
+   * proxies that don't support native structured output — the agent
+   * then re-injects a soft schema hint into the system prompt instead.
+   */
+  structuredOutput?: boolean;
+};
+//#endregion
+export { AnthropicModelConfig, AnthropicSDKConfig };
+//# sourceMappingURL=config.type.d.mts.map

package/esm/config.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../@warlock.js/ai-anthropic/src/config.type.ts"],"mappings":";;;;;;AAgCA;;;;;;;;;;;;;;AAOuC;AAWvC;;;;;;;;AAiBkB;;;;KAnCN,kBAAA,GAAqB,aAAA;EAC/B,QAAA;;;;;;EAMA,OAAA,GAAU,MAAA,SAAe,YAAA;AAAA;;;;;;;;;KAWf,oBAAA,GAAuB,WAAW;;;;;;;;EAQ5C,MAAA;;;;;;;;;EASA,gBAAA;AAAA"}

package/esm/index.d.mts

@@ -0,0 +1,3 @@
+import { AnthropicModelConfig, AnthropicSDKConfig } from "./config.type.mjs";
+import { AnthropicSDK } from "./sdk.mjs";
+export { type AnthropicModelConfig, AnthropicSDK, type AnthropicSDKConfig };

package/esm/index.mjs

@@ -0,0 +1,3 @@
+import { AnthropicSDK } from "./sdk.mjs";
+
+export { AnthropicSDK };

package/esm/known-vision-models.mjs

@@ -0,0 +1,44 @@
+//#region ../../@warlock.js/ai-anthropic/src/known-vision-models.ts
+/**
+* Model-name prefixes for Claude families that accept image input
+* (vision) on the Messages API.
+*
+* Every Claude 3, Claude 3.5/3.7, and Claude 4 family model is
+* multimodal, so the list covers both the dotted legacy naming
+* (`claude-3-haiku-...`, `claude-3-5-sonnet-...`) and the current
+* `claude-<tier>-4-*` naming (`claude-opus-4-7`, `claude-sonnet-4-6`,
+* `claude-haiku-4-5`). Pre-3 families (`claude-2`, `claude-instant`)
+* are text-only and intentionally absent.
+*
+* Matched as a prefix so dated variants (`claude-opus-4-20250514`) are
+* covered without listing every release tag. Devs can always override
+* per-model via `anthropic.model({ name, vision: true | false })` —
+* explicit config wins over inference in either direction.
+*/
+const VISION_CAPABLE_PREFIXES = [
+	"claude-3",
+	"claude-4",
+	"claude-opus-4",
+	"claude-sonnet-4",
+	"claude-haiku-4"
+];
+/**
+* Infer whether a given Claude model name supports vision based on the
+* known-prefix list. Unknown models default to `false` so that passing
+* an image attachment to an unsupported model surfaces a clear,
+* agent-side capability error instead of an opaque Anthropic 400.
+*
+* @example
+* inferVisionCapability("claude-sonnet-4-6");      // → true
+* inferVisionCapability("claude-3-5-sonnet-latest"); // → true
+* inferVisionCapability("claude-2.1");             // → false
+* inferVisionCapability("custom-proxy-llm");       // → false
+*/
+function inferVisionCapability(modelName) {
+	const normalized = modelName.toLowerCase();
+	return VISION_CAPABLE_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+
+//#endregion
+export { inferVisionCapability };
+//# sourceMappingURL=known-vision-models.mjs.map

package/esm/known-vision-models.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-vision-models.mjs","names":[],"sources":["../../../../../@warlock.js/ai-anthropic/src/known-vision-models.ts"],"sourcesContent":["/**\n * Model-name prefixes for Claude families that accept image input\n * (vision) on the Messages API.\n *\n * Every Claude 3, Claude 3.5/3.7, and Claude 4 family model is\n * multimodal, so the list covers both the dotted legacy naming\n * (`claude-3-haiku-...`, `claude-3-5-sonnet-...`) and the current\n * `claude-<tier>-4-*` naming (`claude-opus-4-7`, `claude-sonnet-4-6`,\n * `claude-haiku-4-5`). Pre-3 families (`claude-2`, `claude-instant`)\n * are text-only and intentionally absent.\n *\n * Matched as a prefix so dated variants (`claude-opus-4-20250514`) are\n * covered without listing every release tag. Devs can always override\n * per-model via `anthropic.model({ name, vision: true | false })` —\n * explicit config wins over inference in either direction.\n */\nconst VISION_CAPABLE_PREFIXES = [\n  \"claude-3\",\n  \"claude-4\",\n  \"claude-opus-4\",\n  \"claude-sonnet-4\",\n  \"claude-haiku-4\",\n];\n\n/**\n * Infer whether a given Claude model name supports vision based on the\n * known-prefix list. Unknown models default to `false` so that passing\n * an image attachment to an unsupported model surfaces a clear,\n * agent-side capability error instead of an opaque Anthropic 400.\n *\n * @example\n * inferVisionCapability(\"claude-sonnet-4-6\");      // → true\n * inferVisionCapability(\"claude-3-5-sonnet-latest\"); // → true\n * inferVisionCapability(\"claude-2.1\");             // → false\n * inferVisionCapability(\"custom-proxy-llm\");       // → false\n */\nexport function inferVisionCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return VISION_CAPABLE_PREFIXES.some((prefix) => normalized.startsWith(prefix));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,MAAM,0BAA0B;CAC9B;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;AAcA,SAAgB,sBAAsB,WAA4B;CAChE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,wBAAwB,MAAM,WAAW,WAAW,WAAW,MAAM,CAAC;AAC/E"}

package/esm/model.mjs

@@ -0,0 +1,303 @@
+import { inferVisionCapability } from "./known-vision-models.mjs";
+import { mapStopReason } from "./utils/map-stop-reason.mjs";
+import { toAnthropicMessages } from "./utils/to-anthropic-messages.mjs";
+import { toAnthropicTools } from "./utils/to-anthropic-tools.mjs";
+import { wrapAnthropicError } from "./utils/wrap-anthropic-error.mjs";
+import "./utils/index.mjs";
+import { safeJsonParse } from "@warlock.js/ai";
+import { log } from "@warlock.js/logger";
+
+//#region ../../@warlock.js/ai-anthropic/src/model.ts
+const LOG_MODULE = "ai.anthropic";
+/**
+* Anthropic requires `max_tokens` on every request (unlike OpenAI,
+* where it is optional). When neither the per-call option nor the
+* model config supplies one, fall back to a generous default so a
+* caller who never thought about token caps still gets a complete
+* answer instead of a 400.
+*/
+const DEFAULT_MAX_TOKENS = 4096;
+/**
+* Anthropic-backed implementation of `ModelContract`.
+*
+* **Role.** The provider-facing bridge between the vendor-neutral
+* `@warlock.js/ai` agent runtime and the official `@anthropic-ai/sdk`
+* Messages API. Agents, workflows, and supervisors never talk to
+* Anthropic directly — they hold a `ModelContract`, and this class is
+* what makes that contract concrete for Claude models.
+*
+* **Responsibility.**
+* - Owns: a long-lived `Anthropic` client + frozen `ModelConfig`
+*   (name, temperature, maxTokens) used as defaults for every call.
+* - Owns: translating vendor-neutral `Message[]` / `ToolConfig[]` into
+*   Anthropic wire shapes (system hoisting, `tool_use` / `tool_result`
+*   blocks) on the way out, and translating Anthropic's content-block
+*   response (text, tool calls, stop reason, usage) back into the
+*   neutral shapes on the way in.
+* - Does NOT own: dispatching tools, deciding whether to loop, tracking
+*   conversation history, or retrying on failure — those are agent
+*   concerns. The model is a stateless (per-call) protocol adapter.
+*
+* Because it holds a live client and shared defaults, it is modeled as
+* a class (see §4.2 of code-style.md — "long-lived state across
+* calls").
+*
+* @example
+* import Anthropic from "@anthropic-ai/sdk";
+* const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+* const model = new AnthropicModel(client, { name: "claude-sonnet-4-6" });
+*
+* const myAgent = agent({
+*   model,
+*   systemPrompt: "You are a helpful assistant.",
+*   tools: [searchTool],
+* });
+*
+* const result = await myAgent.execute("Summarize today's news.");
+*/
+var AnthropicModel = class {
+	constructor(client, config, provider = "anthropic") {
+		this.logger = log;
+		this.client = client;
+		this.config = config;
+		this.name = config.name;
+		this.provider = provider;
+		this.pricing = config.pricing;
+		this.capabilities = {
+			structuredOutput: config.structuredOutput ?? true,
+			vision: config.vision ?? inferVisionCapability(config.name)
+		};
+	}
+	/**
+	* Single-shot completion. Sends the full message list to the Messages
+	* endpoint, waits for the terminal response, and reshapes it into a
+	* vendor-neutral `ModelResponse`. Per-call `options` override the
+	* instance's `ModelConfig` defaults for this call only.
+	*/
+	async complete(messages, options) {
+		this.logger.debug(LOG_MODULE, "request", "Starting call to messages.create", {
+			model: this.name,
+			messageCount: messages.length,
+			streaming: false,
+			toolCount: options?.tools?.length ?? 0
+		});
+		let response;
+		try {
+			response = await this.client.messages.create({
+				...this.buildParams(messages, options),
+				stream: false
+			}, options?.signal ? { signal: options.signal } : void 0);
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		const finishReason = mapStopReason(response.stop_reason);
+		const usage = this.extractUsage(response.usage);
+		const toolCalls = this.extractToolCalls(response.content);
+		this.logger.debug(LOG_MODULE, "response", "call to messages.create succeeded", {
+			finishReason,
+			usage
+		});
+		return {
+			content: this.extractText(response.content),
+			finishReason,
+			usage,
+			toolCalls
+		};
+	}
+	/**
+	* Incremental streaming completion. Yields neutral `ModelStreamChunk`s
+	* — `delta` for text tokens, `tool-call` once a `tool_use` block's
+	* arguments have fully accumulated, and a terminal `done` carrying the
+	* final finish reason + usage totals. Callers consume it with
+	* `for await`.
+	*/
+	async *stream(messages, options) {
+		this.logger.debug(LOG_MODULE, "request", "Starting streaming call to messages.create", {
+			model: this.name,
+			messageCount: messages.length,
+			streaming: true,
+			toolCount: options?.tools?.length ?? 0
+		});
+		let stream;
+		try {
+			stream = await this.client.messages.create({
+				...this.buildParams(messages, options),
+				stream: true
+			}, options?.signal ? { signal: options.signal } : void 0);
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		let rawStopReason = null;
+		const usage = {
+			input: 0,
+			output: 0,
+			total: 0
+		};
+		const toolBlocks = /* @__PURE__ */ new Map();
+		try {
+			for await (const event of stream) {
+				if (event.type === "message_start") {
+					usage.input = event.message.usage.input_tokens ?? 0;
+					const cached = event.message.usage.cache_read_input_tokens;
+					if (cached !== null && cached !== void 0 && cached > 0) usage.cachedTokens = cached;
+					continue;
+				}
+				if (event.type === "content_block_start") {
+					const block = event.content_block;
+					if (block.type === "tool_use") toolBlocks.set(event.index, {
+						id: block.id,
+						name: block.name,
+						json: ""
+					});
+					continue;
+				}
+				if (event.type === "content_block_delta") {
+					if (event.delta.type === "text_delta") yield {
+						type: "delta",
+						content: event.delta.text
+					};
+					else if (event.delta.type === "input_json_delta") {
+						const accumulator = toolBlocks.get(event.index);
+						if (accumulator) accumulator.json += event.delta.partial_json;
+					}
+					continue;
+				}
+				if (event.type === "content_block_stop") {
+					const accumulator = toolBlocks.get(event.index);
+					if (accumulator) {
+						yield {
+							type: "tool-call",
+							id: accumulator.id,
+							name: accumulator.name,
+							input: safeJsonParse(accumulator.json, {})
+						};
+						toolBlocks.delete(event.index);
+					}
+					continue;
+				}
+				if (event.type === "message_delta") {
+					rawStopReason = event.delta.stop_reason ?? rawStopReason;
+					usage.output = event.usage.output_tokens ?? usage.output;
+				}
+			}
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		usage.total = usage.input + usage.output;
+		const finishReason = mapStopReason(rawStopReason);
+		this.logger.debug(LOG_MODULE, "response", "Streaming call to messages.create succeeded", {
+			finishReason,
+			usage
+		});
+		yield {
+			type: "done",
+			finishReason,
+			usage
+		};
+	}
+	/**
+	* Assemble the Anthropic request body shared by `complete()` and
+	* `stream()` (each adds its own `stream` literal so the SDK's create
+	* overload resolves to the right return type). Hoists the system
+	* prompt out of `messages`, resolves `max_tokens` (required by
+	* Anthropic) with the documented default, and conditionally attaches
+	* temperature, tools, and native structured output.
+	*/
+	buildParams(messages, options) {
+		const { system, messages: anthropicMessages } = toAnthropicMessages(messages);
+		const temperature = options?.temperature ?? this.config.temperature;
+		return {
+			model: this.name,
+			max_tokens: options?.maxTokens ?? this.config.maxTokens ?? DEFAULT_MAX_TOKENS,
+			messages: anthropicMessages,
+			...system ? { system } : {},
+			...temperature !== void 0 ? { temperature } : {},
+			...this.buildTools(options?.tools),
+			...this.buildStructuredOutput(options?.responseSchema)
+		};
+	}
+	/**
+	* Spread-friendly tools fragment. Returns an empty object when no
+	* tools were supplied so the caller can unconditionally spread it.
+	*/
+	buildTools(tools) {
+		const mapped = toAnthropicTools(tools);
+		return mapped ? { tools: mapped } : {};
+	}
+	/**
+	* Translate the neutral `responseSchema` option into Anthropic's
+	* native `output_config.format` (JSON-schema structured outputs).
+	*
+	* Only emitted when the model declares the `structuredOutput`
+	* capability AND the schema is a proper root-object JSON Schema —
+	* Anthropic rejects non-object roots. When the capability is off
+	* (config override) or the schema is non-object, returns an empty
+	* object: the agent has already injected a soft schema hint into the
+	* system prompt as the fallback, and client-side `validate()` still
+	* enforces shape.
+	*/
+	buildStructuredOutput(responseSchema) {
+		if (!responseSchema || !this.capabilities.structuredOutput) return {};
+		if (responseSchema.type !== "object" || typeof responseSchema.properties !== "object") return {};
+		return { output_config: { format: {
+			type: "json_schema",
+			schema: responseSchema
+		} } };
+	}
+	/**
+	* Concatenate every `text` content block into the single neutral
+	* `content` string. `tool_use` and other block types are ignored
+	* here — tool calls are surfaced separately via `extractToolCalls`.
+	*/
+	extractText(content) {
+		return content.filter((block) => block.type === "text").map((block) => block.text).join("");
+	}
+	/**
+	* Reshape Anthropic's `tool_use` content blocks into the neutral
+	* `ModelToolCallRequest[]`. Returns `undefined` when the model
+	* requested no tools so callers can branch on presence.
+	*/
+	extractToolCalls(content) {
+		const toolUses = content.filter((block) => block.type === "tool_use");
+		if (toolUses.length === 0) return;
+		return toolUses.map((block) => ({
+			id: block.id,
+			name: block.name,
+			input: block.input ?? {}
+		}));
+	}
+	/**
+	* Normalize Anthropic's `usage` block into the neutral `Usage` shape.
+	* Anthropic reports `input_tokens` / `output_tokens` separately with
+	* no pre-summed total, so `total` is computed. Cache-read tokens are
+	* surfaced as `cachedTokens` only when non-zero.
+	*/
+	extractUsage(raw) {
+		const input = raw.input_tokens ?? 0;
+		const output = raw.output_tokens ?? 0;
+		const cached = raw.cache_read_input_tokens;
+		return {
+			input,
+			output,
+			total: input + output,
+			...cached !== null && cached !== void 0 && cached > 0 ? { cachedTokens: cached } : {}
+		};
+	}
+	/**
+	* Wrap a thrown provider error into the typed `AIError` hierarchy and
+	* emit the standard error log line before it propagates. Shared by
+	* every catch site so the log shape stays identical.
+	*/
+	logAndWrap(thrown) {
+		const wrapped = wrapAnthropicError(thrown);
+		this.logger.error(LOG_MODULE, "error", wrapped.message, {
+			code: wrapped.code,
+			context: wrapped.context
+		});
+		return wrapped;
+	}
+};
+
+//#endregion
+export { AnthropicModel };
+//# sourceMappingURL=model.mjs.map

package/esm/model.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.mjs","names":[],"sources":["../../../../../@warlock.js/ai-anthropic/src/model.ts"],"sourcesContent":["import {\n  safeJsonParse,\n  type Message,\n  type ModelCallOptions,\n  type ModelCapabilities,\n  type ModelContract,\n  type ModelPricing,\n  type ModelResponse,\n  type ModelStreamChunk,\n  type ModelToolCallRequest,\n  type Usage,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport type Anthropic from \"@anthropic-ai/sdk\";\nimport type { AnthropicModelConfig } from \"./config.type\";\nimport { inferVisionCapability } from \"./known-vision-models\";\nimport { mapStopReason, toAnthropicMessages, toAnthropicTools, wrapAnthropicError } from \"./utils\";\n\nconst LOG_MODULE = \"ai.anthropic\";\n\n/**\n * Anthropic requires `max_tokens` on every request (unlike OpenAI,\n * where it is optional). When neither the per-call option nor the\n * model config supplies one, fall back to a generous default so a\n * caller who never thought about token caps still gets a complete\n * answer instead of a 400.\n */\nconst DEFAULT_MAX_TOKENS = 4096;\n\n/**\n * Anthropic-backed implementation of `ModelContract`.\n *\n * **Role.** The provider-facing bridge between the vendor-neutral\n * `@warlock.js/ai` agent runtime and the official `@anthropic-ai/sdk`\n * Messages API. Agents, workflows, and supervisors never talk to\n * Anthropic directly — they hold a `ModelContract`, and this class is\n * what makes that contract concrete for Claude models.\n *\n * **Responsibility.**\n * - Owns: a long-lived `Anthropic` client + frozen `ModelConfig`\n *   (name, temperature, maxTokens) used as defaults for every call.\n * - Owns: translating vendor-neutral `Message[]` / `ToolConfig[]` into\n *   Anthropic wire shapes (system hoisting, `tool_use` / `tool_result`\n *   blocks) on the way out, and translating Anthropic's content-block\n *   response (text, tool calls, stop reason, usage) back into the\n *   neutral shapes on the way in.\n * - Does NOT own: dispatching tools, deciding whether to loop, tracking\n *   conversation history, or retrying on failure — those are agent\n *   concerns. The model is a stateless (per-call) protocol adapter.\n *\n * Because it holds a live client and shared defaults, it is modeled as\n * a class (see §4.2 of code-style.md — \"long-lived state across\n * calls\").\n *\n * @example\n * import Anthropic from \"@anthropic-ai/sdk\";\n * const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });\n * const model = new AnthropicModel(client, { name: \"claude-sonnet-4-6\" });\n *\n * const myAgent = agent({\n *   model,\n *   systemPrompt: \"You are a helpful assistant.\",\n *   tools: [searchTool],\n * });\n *\n * const result = await myAgent.execute(\"Summarize today's news.\");\n */\nexport class AnthropicModel implements ModelContract {\n  public readonly name: string;\n  public readonly provider: string;\n  public readonly capabilities: ModelCapabilities;\n  public readonly pricing?: ModelPricing;\n\n  private readonly client: Anthropic;\n  private readonly config: AnthropicModelConfig;\n  private readonly logger: Logger = log;\n\n  public constructor(\n    client: Anthropic,\n    config: AnthropicModelConfig,\n    provider: string = \"anthropic\",\n  ) {\n    this.client = client;\n    this.config = config;\n    this.name = config.name;\n    this.provider = provider;\n    this.pricing = config.pricing;\n    this.capabilities = {\n      structuredOutput: config.structuredOutput ?? true,\n      vision: config.vision ?? inferVisionCapability(config.name),\n    };\n  }\n\n  /**\n   * Single-shot completion. Sends the full message list to the Messages\n   * endpoint, waits for the terminal response, and reshapes it into a\n   * vendor-neutral `ModelResponse`. Per-call `options` override the\n   * instance's `ModelConfig` defaults for this call only.\n   */\n  public async complete(messages: Message[], options?: ModelCallOptions): Promise<ModelResponse> {\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting call to messages.create\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: false,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let response: Anthropic.Message;\n\n    try {\n      response = await this.client.messages.create(\n        { ...this.buildParams(messages, options), stream: false },\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    const finishReason = mapStopReason(response.stop_reason);\n    const usage = this.extractUsage(response.usage);\n    const toolCalls = this.extractToolCalls(response.content);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"call to messages.create succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    return {\n      content: this.extractText(response.content),\n      finishReason,\n      usage,\n      toolCalls,\n    };\n  }\n\n  /**\n   * Incremental streaming completion. Yields neutral `ModelStreamChunk`s\n   * — `delta` for text tokens, `tool-call` once a `tool_use` block's\n   * arguments have fully accumulated, and a terminal `done` carrying the\n   * final finish reason + usage totals. Callers consume it with\n   * `for await`.\n   */\n  public async *stream(\n    messages: Message[],\n    options?: ModelCallOptions,\n  ): AsyncIterable<ModelStreamChunk> {\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting streaming call to messages.create\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: true,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let stream: Awaited<ReturnType<Anthropic[\"messages\"][\"create\"]>>;\n\n    try {\n      stream = await this.client.messages.create(\n        { ...this.buildParams(messages, options), stream: true },\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    let rawStopReason: string | null = null;\n    const usage: Usage = { input: 0, output: 0, total: 0 };\n    const toolBlocks = new Map<number, { id: string; name: string; json: string }>();\n\n    try {\n      for await (const event of stream as AsyncIterable<Anthropic.RawMessageStreamEvent>) {\n        if (event.type === \"message_start\") {\n          usage.input = event.message.usage.input_tokens ?? 0;\n\n          const cached = event.message.usage.cache_read_input_tokens;\n\n          if (cached !== null && cached !== undefined && cached > 0) {\n            usage.cachedTokens = cached;\n          }\n\n          continue;\n        }\n\n        if (event.type === \"content_block_start\") {\n          const block = event.content_block;\n\n          if (block.type === \"tool_use\") {\n            toolBlocks.set(event.index, { id: block.id, name: block.name, json: \"\" });\n          }\n\n          continue;\n        }\n\n        if (event.type === \"content_block_delta\") {\n          if (event.delta.type === \"text_delta\") {\n            yield { type: \"delta\", content: event.delta.text };\n          } else if (event.delta.type === \"input_json_delta\") {\n            const accumulator = toolBlocks.get(event.index);\n\n            if (accumulator) {\n              accumulator.json += event.delta.partial_json;\n            }\n          }\n\n          continue;\n        }\n\n        if (event.type === \"content_block_stop\") {\n          const accumulator = toolBlocks.get(event.index);\n\n          if (accumulator) {\n            yield {\n              type: \"tool-call\",\n              id: accumulator.id,\n              name: accumulator.name,\n              input: safeJsonParse<Record<string, unknown>>(accumulator.json, {}),\n            };\n\n            toolBlocks.delete(event.index);\n          }\n\n          continue;\n        }\n\n        if (event.type === \"message_delta\") {\n          rawStopReason = event.delta.stop_reason ?? rawStopReason;\n          usage.output = event.usage.output_tokens ?? usage.output;\n        }\n      }\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    usage.total = usage.input + usage.output;\n\n    const finishReason = mapStopReason(rawStopReason);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"Streaming call to messages.create succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    yield { type: \"done\", finishReason, usage };\n  }\n\n  /**\n   * Assemble the Anthropic request body shared by `complete()` and\n   * `stream()` (each adds its own `stream` literal so the SDK's create\n   * overload resolves to the right return type). Hoists the system\n   * prompt out of `messages`, resolves `max_tokens` (required by\n   * Anthropic) with the documented default, and conditionally attaches\n   * temperature, tools, and native structured output.\n   */\n  private buildParams(\n    messages: Message[],\n    options: ModelCallOptions | undefined,\n  ): Omit<Anthropic.MessageCreateParamsNonStreaming, \"stream\"> {\n    const { system, messages: anthropicMessages } = toAnthropicMessages(messages);\n    const temperature = options?.temperature ?? this.config.temperature;\n\n    return {\n      model: this.name,\n      max_tokens: options?.maxTokens ?? this.config.maxTokens ?? DEFAULT_MAX_TOKENS,\n      messages: anthropicMessages,\n      ...(system ? { system } : {}),\n      ...(temperature !== undefined ? { temperature } : {}),\n      ...this.buildTools(options?.tools),\n      ...this.buildStructuredOutput(options?.responseSchema),\n    };\n  }\n\n  /**\n   * Spread-friendly tools fragment. Returns an empty object when no\n   * tools were supplied so the caller can unconditionally spread it.\n   */\n  private buildTools(tools: ModelCallOptions[\"tools\"]): { tools?: Anthropic.Tool[] } {\n    const mapped = toAnthropicTools(tools);\n\n    return mapped ? { tools: mapped } : {};\n  }\n\n  /**\n   * Translate the neutral `responseSchema` option into Anthropic's\n   * native `output_config.format` (JSON-schema structured outputs).\n   *\n   * Only emitted when the model declares the `structuredOutput`\n   * capability AND the schema is a proper root-object JSON Schema —\n   * Anthropic rejects non-object roots. When the capability is off\n   * (config override) or the schema is non-object, returns an empty\n   * object: the agent has already injected a soft schema hint into the\n   * system prompt as the fallback, and client-side `validate()` still\n   * enforces shape.\n   */\n  private buildStructuredOutput(responseSchema: Record<string, unknown> | undefined): {\n    output_config?: Anthropic.OutputConfig;\n  } {\n    if (!responseSchema || !this.capabilities.structuredOutput) {\n      return {};\n    }\n\n    if (responseSchema.type !== \"object\" || typeof responseSchema.properties !== \"object\") {\n      return {};\n    }\n\n    return {\n      output_config: {\n        format: { type: \"json_schema\", schema: responseSchema },\n      },\n    };\n  }\n\n  /**\n   * Concatenate every `text` content block into the single neutral\n   * `content` string. `tool_use` and other block types are ignored\n   * here — tool calls are surfaced separately via `extractToolCalls`.\n   */\n  private extractText(content: Anthropic.ContentBlock[]): string {\n    return content\n      .filter((block): block is Anthropic.TextBlock => block.type === \"text\")\n      .map((block) => block.text)\n      .join(\"\");\n  }\n\n  /**\n   * Reshape Anthropic's `tool_use` content blocks into the neutral\n   * `ModelToolCallRequest[]`. Returns `undefined` when the model\n   * requested no tools so callers can branch on presence.\n   */\n  private extractToolCalls(\n    content: Anthropic.ContentBlock[],\n  ): ModelToolCallRequest[] | undefined {\n    const toolUses = content.filter(\n      (block): block is Anthropic.ToolUseBlock => block.type === \"tool_use\",\n    );\n\n    if (toolUses.length === 0) {\n      return undefined;\n    }\n\n    return toolUses.map((block) => ({\n      id: block.id,\n      name: block.name,\n      input: (block.input ?? {}) as Record<string, unknown>,\n    }));\n  }\n\n  /**\n   * Normalize Anthropic's `usage` block into the neutral `Usage` shape.\n   * Anthropic reports `input_tokens` / `output_tokens` separately with\n   * no pre-summed total, so `total` is computed. Cache-read tokens are\n   * surfaced as `cachedTokens` only when non-zero.\n   */\n  private extractUsage(raw: Anthropic.Usage): Usage {\n    const input = raw.input_tokens ?? 0;\n    const output = raw.output_tokens ?? 0;\n    const cached = raw.cache_read_input_tokens;\n\n    return {\n      input,\n      output,\n      total: input + output,\n      ...(cached !== null && cached !== undefined && cached > 0 ? { cachedTokens: cached } : {}),\n    };\n  }\n\n  /**\n   * Wrap a thrown provider error into the typed `AIError` hierarchy and\n   * emit the standard error log line before it propagates. Shared by\n   * every catch site so the log shape stays identical.\n   */\n  private logAndWrap(thrown: unknown) {\n    const wrapped = wrapAnthropicError(thrown);\n\n    this.logger.error(LOG_MODULE, \"error\", wrapped.message, {\n      code: wrapped.code,\n      context: wrapped.context,\n    });\n\n    return wrapped;\n  }\n}\n"],"mappings":"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"}