@ggui-ai/ui-gen 0.28.0 → 0.29.0

package/dist/provider-adapter.js

@@ -1,46 +1,4 @@
-// src/provider-adapter.ts
-function makeProviderError(args) {
-  const out = {
-    kind: args.kind,
-    provider: args.provider,
-    message: args.message,
-    ...args.status !== void 0 ? { status: args.status } : {},
-    ...args.retryAfterSec !== void 0 ? { retryAfterSec: args.retryAfterSec } : {}
-  };
-  return out;
-}
-function statusToErrorKind(status) {
-  if (status === 401) return "unauthorized";
-  if (status === 403) return "forbidden";
-  if (status === 429) return "rate-limited";
-  if (status >= 500 && status < 600) return "server-error";
-  if (status >= 400 && status < 500) return "client-error";
-  return "unknown";
-}
-function defaultValidateConfig(provider, request) {
-  if (!request.apiKey || request.apiKey.length === 0) {
-    return {
-      ok: false,
-      error: makeProviderError({
-        kind: "no-credentials",
-        provider,
-        message: `${provider}: no API key supplied`
-      })
-    };
-  }
-  if (!request.route?.model || request.route.model.length === 0) {
-    return {
-      ok: false,
-      error: makeProviderError({
-        kind: "client-error",
-        provider,
-        message: `${provider}: model id is required`
-      })
-    };
-  }
-  return { ok: true };
-}
-
-export { defaultValidateConfig, makeProviderError, statusToErrorKind };
+export { defaultValidateConfig, makeProviderError, statusToErrorKind } from './chunk-73AURS3I.js';
+import './chunk-G3PMV62Z.js';
 //# sourceMappingURL=provider-adapter.js.map
 //# sourceMappingURL=provider-adapter.js.map

package/dist/provider-adapter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/provider-adapter.ts"],"names":[],"mappings":";AA+PO,SAAS,kBAAkB,IAAA,EAMhB;AAChB,EAAA,MAAM,GAAA,GAAqB;AAAA,IACzB,MAAM,IAAA,CAAK,IAAA;AAAA,IACX,UAAU,IAAA,CAAK,QAAA;AAAA,IACf,SAAS,IAAA,CAAK,OAAA;AAAA,IACd,GAAI,KAAK,MAAA,KAAW,MAAA,GAAY,EAAE,MAAA,EAAQ,IAAA,CAAK,MAAA,EAAO,GAAI,EAAC;AAAA,IAC3D,GAAI,KAAK,aAAA,KAAkB,MAAA,GACvB,EAAE,aAAA,EAAe,IAAA,CAAK,aAAA,EAAc,GACpC;AAAC,GACP;AACA,EAAA,OAAO,GAAA;AACT;AAQO,SAAS,kBAAkB,MAAA,EAAmC;AACnE,EAAA,IAAI,MAAA,KAAW,KAAK,OAAO,cAAA;AAC3B,EAAA,IAAI,MAAA,KAAW,KAAK,OAAO,WAAA;AAC3B,EAAA,IAAI,MAAA,KAAW,KAAK,OAAO,cAAA;AAC3B,EAAA,IAAI,MAAA,IAAU,GAAA,IAAO,MAAA,GAAS,GAAA,EAAK,OAAO,cAAA;AAC1C,EAAA,IAAI,MAAA,IAAU,GAAA,IAAO,MAAA,GAAS,GAAA,EAAK,OAAO,cAAA;AAC1C,EAAA,OAAO,SAAA;AACT;AAcO,SAAS,qBAAA,CACd,UACA,OAAA,EACoB;AACpB,EAAA,IAAI,CAAC,OAAA,CAAQ,MAAA,IAAU,OAAA,CAAQ,MAAA,CAAO,WAAW,CAAA,EAAG;AAClD,IAAA,OAAO;AAAA,MACL,EAAA,EAAI,KAAA;AAAA,MACJ,OAAO,iBAAA,CAAkB;AAAA,QACvB,IAAA,EAAM,gBAAA;AAAA,QACN,QAAA;AAAA,QACA,OAAA,EAAS,GAAG,QAAQ,CAAA,qBAAA;AAAA,OACrB;AAAA,KACH;AAAA,EACF;AACA,EAAA,IAAI,CAAC,QAAQ,KAAA,EAAO,KAAA,IAAS,QAAQ,KAAA,CAAM,KAAA,CAAM,WAAW,CAAA,EAAG;AAC7D,IAAA,OAAO;AAAA,MACL,EAAA,EAAI,KAAA;AAAA,MACJ,OAAO,iBAAA,CAAkB;AAAA,QACvB,IAAA,EAAM,cAAA;AAAA,QACN,QAAA;AAAA,QACA,OAAA,EAAS,GAAG,QAAQ,CAAA,sBAAA;AAAA,OACrB;AAAA,KACH;AAAA,EACF;AACA,EAAA,OAAO,EAAE,IAAI,IAAA,EAAK;AACpB","file":"provider-adapter.js","sourcesContent":["/**\n * Provider adapter contract — the narrow surface every concrete LLM\n * provider client (Anthropic, Google, OpenAI, OpenRouter, Bedrock)\n * implements.\n *\n * **Real role:** a provider-agnostic one-shot LLM caller for\n * lightweight callers that need a single `complete()` round-trip — NOT\n * a generation harness. The primary consumer is the negotiator's LLM\n * seam (`@ggui-ai/mcp-server`'s `llm-backed-negotiator.ts`, via\n * {@link selectAdapter} from `./providers/index.js`); other lightweight\n * one-shot callers use it the same way. It is explicitly NOT part of\n * the generation dispatch path: `createUiGenerator()` accepts no\n * adapter option, and generation-call 429 retry/backoff lives entirely\n * in `harness/llm-router.ts`'s `apiCall()` — a separate retry story for\n * a separate call shape (an agentic SDK loop, not a single completion).\n *\n * The contract is deliberately defined independently of concrete\n * adapters so:\n *\n *   - Adapter implementations can be written against a stable surface —\n *     every concrete adapter MUST pass\n *     {@link providerAdapterContract} or it isn't a `ProviderAdapter`.\n *   - Downstream one-shot callers build against ONE structured failure\n *     shape ({@link ProviderError}) instead of inventing per-provider\n *     error UX.\n *   - The negotiator + cache layers can branch on\n *     `error.kind === 'rate-limited'` etc. without parsing strings.\n *\n * **Scope:**\n *\n *   - Defines the interface, the response shape, the error shape,\n *     and a contract test runner that asserts every adapter\n *     satisfies the seam.\n *   - Does NOT call any LLM. The contract is structural; this\n *     package's own tests exercise the runner against a deterministic\n *     fixture adapter (`provider-adapter-mock.test-util.ts`).\n *\n * **Design choices, locked:**\n *\n *   - One discriminated `ProviderError.kind` union, not per-provider\n *     subclasses. Every provider's raw error funnels through\n *     `mapError` into one of these kinds. Callers branch on `kind`.\n *   - Every error carries `provider` + `message`; transport-shaped\n *     errors carry `status`; backoff-shaped errors carry\n *     `retryAfterSec`. Optional fields don't appear when they don't\n *     apply (no `status: undefined` noise in serialized logs).\n *   - `validateConfig` is synchronous + does NO I/O. It catches the\n *     \"operator never configured the provider\" case (missing key,\n *     malformed model id) before we attempt a network call.\n *   - `complete` is the single-completion seam. Streaming, tool\n *     calling, function calling, and harness retry land in higher\n *     layers — adapters stay narrow.\n */\nimport type { LlmProvider, LlmRoute } from '@ggui-ai/protocol';\n\n/**\n * One LLM completion request as the adapter sees it. Plain data so\n * tests can construct it without DI.\n *\n * `route` is a discriminated `LlmRoute` — `(provider, model)` typed\n * together so the model id is structurally constrained to its\n * provider's namespace (per the `MODELS` registry in\n * `@ggui-ai/protocol/types/llm-route`). This makes the #22 / #42 bug\n * class — passing a LiteLLM-prefixed `'anthropic/claude-haiku-4-5'`\n * where Anthropic expected the wire id `'claude-haiku-4-5-20251001'` —\n * a compile error at every adapter call site. The adapter reads the\n * wire-canonical string off `request.route.model` and passes it\n * verbatim to the provider SDK; no transformation step exists to\n * forget.\n */\nexport interface ProviderRequest {\n  /** API key. Resolved upstream by `@ggui-ai/cli/byok-resolver`. */\n  readonly apiKey: string;\n  /**\n   * Discriminated `(provider, model)` route. `route.model` is the\n   * wire-canonical id the provider's API expects — adapters pass it\n   * verbatim with no stripping or remapping.\n   */\n  readonly route: LlmRoute;\n  /** System prompt text. Adapter wires it into the provider's slot. */\n  readonly systemPrompt: string;\n  /** User prompt text. */\n  readonly userPrompt: string;\n  /**\n   * Optional cap on output tokens. Adapters MUST honor when the\n   * provider supports it; when absent, adapters use the provider\n   * default.\n   */\n  readonly maxTokens?: number;\n  /**\n   * Optional cancellation. Adapters MUST forward into the provider\n   * SDK's abort surface and reject with `ProviderError{kind:'aborted'}`\n   * when fired.\n   */\n  readonly signal?: AbortSignal;\n}\n\n/**\n * Successful provider response, normalized.\n *\n * Tool-calling output, multi-turn dialogue, structured-output\n * coercion all land in higher layers — this contract intentionally\n * stays narrow: text + usage + finish reason. The harness layer\n * composes adapters into multi-turn loops.\n */\nexport interface ProviderResponse {\n  /** The completion text returned by the provider. */\n  readonly text: string;\n  /** Token usage, per-call. Required — adapters synthesize 0 if the\n   *  provider didn't report it (and document that in their adapter). */\n  readonly usage: {\n    readonly inputTokens: number;\n    readonly outputTokens: number;\n  };\n  /**\n   * Why the model stopped. Mapped through a normalized union so\n   * callers don't have to know each provider's vocabulary.\n   *\n   *   - `'stop'`         model emitted EOS / stop sequence\n   *   - `'length'`       hit `maxTokens` or provider context limit\n   *   - `'content-filter'` provider safety filter intervened\n   *   - `'other'`        anything else (provider-specific reason)\n   */\n  readonly finishReason: 'stop' | 'length' | 'content-filter' | 'other';\n}\n\n/**\n * The structured failure contract. Every concrete adapter's\n * `mapError` MUST funnel raw provider errors into this shape so\n * downstream code branches on `kind`, not on string parsing.\n *\n * Discriminator + optional carriers:\n *\n *   - `'no-credentials'`   — no key supplied (pre-flight failure;\n *                            usually surfaced by `validateConfig`,\n *                            not `mapError`).\n *   - `'unauthorized'`     — provider returned 401. Key invalid /\n *                            revoked / wrong type.\n *   - `'forbidden'`        — provider returned 403. Quota exhausted,\n *                            org-level block, model not allowed for\n *                            this key. (Distinct from 401 because\n *                            \"rotate the key\" doesn't help.)\n *   - `'rate-limited'`     — provider returned 429. Carries\n *                            `retryAfterSec` when the provider\n *                            advertised one (`Retry-After` header).\n *   - `'server-error'`     — provider returned 5xx. Retryable.\n *   - `'client-error'`     — provider returned other 4xx. Usually\n *                            non-retryable (bad model id, malformed\n *                            request).\n *   - `'network'`          — TCP-level failure, DNS, EAI_AGAIN, etc.\n *                            No `status`. Retryable.\n *   - `'invalid-response'` — provider returned 2xx with a body the\n *                            adapter couldn't parse. Bug in the\n *                            adapter or in the provider; treat as\n *                            non-retryable.\n *   - `'aborted'`          — caller aborted via `signal`.\n *   - `'unknown'`          — last-resort bucket. Adapters that hit\n *                            this should be patched to map the\n *                            specific case explicitly.\n */\nexport type ProviderErrorKind =\n  | 'no-credentials'\n  | 'unauthorized'\n  | 'forbidden'\n  | 'rate-limited'\n  | 'server-error'\n  | 'client-error'\n  | 'network'\n  | 'invalid-response'\n  | 'aborted'\n  | 'unknown';\n\nexport interface ProviderError {\n  readonly kind: ProviderErrorKind;\n  readonly provider: LlmProvider;\n  /** Human-readable message. Safe to log; should not contain key\n   *  material — adapters MUST scrub before placing here. */\n  readonly message: string;\n  /** HTTP status when transport-shaped. Absent for pre-flight,\n   *  network, aborted, invalid-response. */\n  readonly status?: number;\n  /**\n   * Seconds to wait before retrying. Set ONLY for `'rate-limited'`\n   * when the provider advertised a `Retry-After` header. Higher-level\n   * retry policy uses this when present; falls back to its own\n   * exponential backoff when absent.\n   */\n  readonly retryAfterSec?: number;\n}\n\n/**\n * Pre-flight config validation. Synchronous, no I/O. Catches:\n *\n *   - missing or empty API key       → no-credentials\n *   - missing or empty model id      → client-error\n *\n * Adapters MAY widen the check with provider-specific rules\n * (e.g. \"openrouter model id MUST contain a `/`\"). Failures\n * surface through the same {@link ProviderError} so callers branch\n * on one union.\n */\nexport type ProviderValidation =\n  | { readonly ok: true }\n  | { readonly ok: false; readonly error: ProviderError };\n\n/**\n * The contract every provider client implements.\n */\nexport interface ProviderAdapter {\n  /** Provider this adapter speaks to. Stable identifier; lets the\n   *  caller route a `ProviderRequest` to the right adapter. */\n  readonly provider: LlmProvider;\n  /**\n   * Pre-flight check. MUST return synchronously and MUST NOT touch\n   * the network. Returns `{ok: true}` when the request is at least\n   * structurally valid; returns `{ok: false, error}` otherwise.\n   */\n  validateConfig(request: Pick<ProviderRequest, 'apiKey' | 'route'>): ProviderValidation;\n  /**\n   * Single-completion call. Resolves with `{ok: true, response}` on\n   * success or `{ok: false, error}` on any failure (network,\n   * provider 4xx/5xx, abort). Implementations MUST:\n   *\n   *   1. Funnel every raw provider error through `mapError`.\n   *   2. NOT throw. The result discriminator IS the error path.\n   *   3. Forward `request.signal` into the provider SDK's abort\n   *      mechanism + return `kind:'aborted'` when fired.\n   */\n  complete(request: ProviderRequest): Promise<ProviderResult>;\n  /**\n   * Map an arbitrary thrown / rejected value into a\n   * {@link ProviderError}. Exposed (not just internal) so test\n   * harnesses + retry policies can normalize errors without going\n   * through `complete`.\n   *\n   * MUST NEVER throw — `mapError(unknown)` is the safety net.\n   */\n  mapError(raw: unknown): ProviderError;\n}\n\n/**\n * Discriminated result of a `complete` call. Mirrors `validateConfig`\n * so callers never have to handle thrown errors from this seam.\n */\nexport type ProviderResult =\n  | { readonly ok: true; readonly response: ProviderResponse }\n  | { readonly ok: false; readonly error: ProviderError };\n\n// ─── Helpers concrete adapters compose with ────────────────────────\n\n/**\n * Build a `ProviderError` of the supplied kind. Centralized so\n * concrete adapters don't drift on field shape. Provider-aware so\n * callers don't have to thread it through.\n */\nexport function makeProviderError(args: {\n  readonly kind: ProviderErrorKind;\n  readonly provider: LlmProvider;\n  readonly message: string;\n  readonly status?: number;\n  readonly retryAfterSec?: number;\n}): ProviderError {\n  const out: ProviderError = {\n    kind: args.kind,\n    provider: args.provider,\n    message: args.message,\n    ...(args.status !== undefined ? { status: args.status } : {}),\n    ...(args.retryAfterSec !== undefined\n      ? { retryAfterSec: args.retryAfterSec }\n      : {}),\n  };\n  return out;\n}\n\n/**\n * Map an HTTP status code to the canonical error kind. Adapters\n * call this from `mapError` after they've classified the failure as\n * \"the provider returned a status we understand\". Network / abort /\n * pre-flight live outside this mapping.\n */\nexport function statusToErrorKind(status: number): ProviderErrorKind {\n  if (status === 401) return 'unauthorized';\n  if (status === 403) return 'forbidden';\n  if (status === 429) return 'rate-limited';\n  if (status >= 500 && status < 600) return 'server-error';\n  if (status >= 400 && status < 500) return 'client-error';\n  return 'unknown';\n}\n\n/**\n * Default `validateConfig` implementation. Concrete adapters\n * compose this and add their own provider-specific checks on top.\n *\n * Catches the two universal failures: missing key + missing model.\n * Returns `{ok: true}` when both are present.\n *\n * The model-id check is defense-in-depth — typed `LlmRoute` callers\n * cannot construct a route with an empty model string, but the\n * adapter still validates at runtime in case the request crossed an\n * untyped JSON boundary (e.g. deserialized from a wire format).\n */\nexport function defaultValidateConfig(\n  provider: LlmProvider,\n  request: Pick<ProviderRequest, 'apiKey' | 'route'>,\n): ProviderValidation {\n  if (!request.apiKey || request.apiKey.length === 0) {\n    return {\n      ok: false,\n      error: makeProviderError({\n        kind: 'no-credentials',\n        provider,\n        message: `${provider}: no API key supplied`,\n      }),\n    };\n  }\n  if (!request.route?.model || request.route.model.length === 0) {\n    return {\n      ok: false,\n      error: makeProviderError({\n        kind: 'client-error',\n        provider,\n        message: `${provider}: model id is required`,\n      }),\n    };\n  }\n  return { ok: true };\n}\n"]}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"provider-adapter.js"}

package/dist/providers/index.d.ts

@@ -140,6 +140,94 @@ interface BedrockAdapterOptions {
  */
 declare function createBedrockAdapter(options?: BedrockAdapterOptions): ProviderAdapter;
 
+/**
+ * The one tool the call asks for: the Messages API's own wire shape for a
+ * tool (`name`, `description`, `input_schema`), sent as-is under a raw
+ * `fetch`. It is not an SDK type and does not stand in for one; this
+ * package takes no Anthropic SDK dependency.
+ */
+interface AnthropicTool {
+    readonly name: string;
+    readonly description: string;
+    /** The tool's input JSON Schema, sent verbatim. */
+    readonly input_schema: Readonly<Record<string, unknown>>;
+}
+interface AnthropicToolCallRequest {
+    readonly apiKey: string;
+    /** The wire model id, sent verbatim. */
+    readonly model: string;
+    readonly systemPrompt: string;
+    readonly userPrompt: string;
+    readonly tool: AnthropicTool;
+    /** The answer budget. Absent ⇒ 1024. Headroom is added on top where the model needs it. */
+    readonly maxTokens?: number;
+    /** Cancels the request. */
+    readonly signal?: AbortSignal;
+    /** Override for tests and instrumentation. Absent ⇒ the global `fetch` at call time. */
+    readonly fetch?: typeof globalThis.fetch;
+    /** Override for a proxy endpoint. */
+    readonly endpoint?: string;
+}
+/** The tool input, with the response's token usage when it reported one. */
+interface AnthropicToolCallResult {
+    readonly input: unknown;
+    /**
+     * `usage.input_tokens` / `usage.output_tokens` when both are numbers;
+     * absent otherwise. An unmetered response reports no usage, never
+     * zeros. No `cache_control` is sent, so there are no cache counts.
+     */
+    readonly usage?: {
+        readonly input: number;
+        readonly output: number;
+    };
+}
+/**
+ * How a structured call ended without the tool input it asked for:
+ *
+ *   - `max_tokens`: the budget ran out (`stop_reason: max_tokens`) before
+ *     the tool call.
+ *   - `no_tool_call`: the model finished without calling the tool
+ *     (possible under `auto`).
+ *   - `refusal`: the model declined (`stop_reason: refusal`).
+ *   - `http`: the API answered non-2xx.
+ *   - `malformed`: the body was JSON but not a Messages response.
+ */
+declare const ANTHROPIC_STRUCTURED_CALL_FAILURE_KINDS: readonly ["max_tokens", "no_tool_call", "refusal", "http", "malformed"];
+type AnthropicStructuredCallFailureKind = (typeof ANTHROPIC_STRUCTURED_CALL_FAILURE_KINDS)[number];
+/**
+ * A structured call that returned no tool input, NAMED by why. The kind
+ * is in the message too (`[max_tokens]` …), so a consumer that only
+ * surfaces the message (the rerank judge's `reason`) still reports
+ * which failure it was.
+ */
+declare class AnthropicStructuredCallError extends Error {
+    readonly kind: AnthropicStructuredCallFailureKind;
+    readonly status: number | undefined;
+    readonly stopReason: string | undefined;
+    constructor(kind: AnthropicStructuredCallFailureKind, detail: string, extra?: {
+        readonly status?: number;
+        readonly stopReason?: string;
+    });
+}
+/**
+ * Whether `err` is an {@link AnthropicStructuredCallError}, by its shape:
+ * an `Error` named `AnthropicStructuredCallError` whose `kind` is one of
+ * {@link ANTHROPIC_STRUCTURED_CALL_FAILURE_KINDS}.
+ *
+ * Prefer this to `instanceof`. An `instanceof` check holds only while one
+ * copy of this package is installed: a consumer that resolves a second
+ * copy (its own `@ggui-ai/ui-gen` at a different version from the one
+ * `@ggui-ai/mcp-server` depends on) gets errors from a class it did not
+ * import, and every one of them fails the check.
+ */
+declare function isAnthropicStructuredCallError(err: unknown): err is AnthropicStructuredCallError;
+/**
+ * Send one structured call and return the named tool's input. Every way
+ * the turn ends without that input throws an
+ * {@link AnthropicStructuredCallError} whose kind says which.
+ */
+declare function anthropicToolCall(request: AnthropicToolCallRequest): Promise<AnthropicToolCallResult>;
+
 /**
  * Public barrel for `@ggui-ai/ui-gen/providers`.
  *
@@ -204,4 +292,4 @@ declare function createBedrockAdapter(options?: BedrockAdapterOptions): Provider
  */
 declare function selectAdapter(provider: LlmProvider): ProviderAdapter;
 
-export { type AnthropicAdapterOptions, type BedrockAdapterOptions, type GoogleAdapterOptions, type OpenAiAdapterOptions, type OpenRouterAdapterOptions, createAnthropicAdapter, createBedrockAdapter, createGoogleAdapter, createOpenAiAdapter, createOpenRouterAdapter, selectAdapter };
+export { ANTHROPIC_STRUCTURED_CALL_FAILURE_KINDS, type AnthropicAdapterOptions, AnthropicStructuredCallError, type AnthropicStructuredCallFailureKind, type AnthropicTool, type AnthropicToolCallRequest, type AnthropicToolCallResult, type BedrockAdapterOptions, type GoogleAdapterOptions, type OpenAiAdapterOptions, type OpenRouterAdapterOptions, anthropicToolCall, createAnthropicAdapter, createBedrockAdapter, createGoogleAdapter, createOpenAiAdapter, createOpenRouterAdapter, isAnthropicStructuredCallError, selectAdapter };

package/dist/providers/index.js

@@ -1,47 +1,7 @@
+import { defaultValidateConfig, makeProviderError, statusToErrorKind } from '../chunk-73AURS3I.js';
+import '../chunk-G3PMV62Z.js';
 import { AnthropicBedrockMantle, AnthropicBedrock } from '@anthropic-ai/bedrock-sdk';
-
-// src/provider-adapter.ts
-function makeProviderError(args) {
-  const out = {
-    kind: args.kind,
-    provider: args.provider,
-    message: args.message,
-    ...args.status !== void 0 ? { status: args.status } : {},
-    ...args.retryAfterSec !== void 0 ? { retryAfterSec: args.retryAfterSec } : {}
-  };
-  return out;
-}
-function statusToErrorKind(status) {
-  if (status === 401) return "unauthorized";
-  if (status === 403) return "forbidden";
-  if (status === 429) return "rate-limited";
-  if (status >= 500 && status < 600) return "server-error";
-  if (status >= 400 && status < 500) return "client-error";
-  return "unknown";
-}
-function defaultValidateConfig(provider, request) {
-  if (!request.apiKey || request.apiKey.length === 0) {
-    return {
-      ok: false,
-      error: makeProviderError({
-        kind: "no-credentials",
-        provider,
-        message: `${provider}: no API key supplied`
-      })
-    };
-  }
-  if (!request.route?.model || request.route.model.length === 0) {
-    return {
-      ok: false,
-      error: makeProviderError({
-        kind: "client-error",
-        provider,
-        message: `${provider}: model id is required`
-      })
-    };
-  }
-  return { ok: true };
-}
+import { anthropicRejectsForcedToolChoice, isRecord } from '@ggui-ai/protocol';
 
 // src/providers/anthropic-wire.ts
 function parseAnthropicMessagesResponse(raw, provider) {
@@ -704,6 +664,117 @@ function createBedrockAdapter(options = {}) {
     }
   };
 }
+var DEFAULT_ENDPOINT4 = "https://api.anthropic.com/v1/messages";
+var DEFAULT_API_VERSION2 = "2023-06-01";
+var DEFAULT_ANSWER_BUDGET = 1024;
+var ALWAYS_THINKING_HEADROOM_TOKENS = 16e3;
+var ANTHROPIC_STRUCTURED_CALL_FAILURE_KINDS = [
+  "max_tokens",
+  "no_tool_call",
+  "refusal",
+  "http",
+  "malformed"
+];
+var AnthropicStructuredCallError = class extends Error {
+  kind;
+  status;
+  stopReason;
+  constructor(kind, detail, extra = {}) {
+    super(`anthropic structured call [${kind}]: ${detail}`);
+    this.name = "AnthropicStructuredCallError";
+    this.kind = kind;
+    this.status = extra.status;
+    this.stopReason = extra.stopReason;
+  }
+};
+function isAnthropicStructuredCallError(err) {
+  if (!(err instanceof Error) || err.name !== "AnthropicStructuredCallError") {
+    return false;
+  }
+  const kind = Reflect.get(err, "kind");
+  return ANTHROPIC_STRUCTURED_CALL_FAILURE_KINDS.some((known) => known === kind);
+}
+async function anthropicToolCall(request) {
+  const answerBudget = request.maxTokens ?? DEFAULT_ANSWER_BUDGET;
+  const refusesForcedTool = anthropicRejectsForcedToolChoice(request.model);
+  const maxTokens = refusesForcedTool ? answerBudget + ALWAYS_THINKING_HEADROOM_TOKENS : answerBudget;
+  const toolName = request.tool.name;
+  const body = {
+    model: request.model,
+    max_tokens: maxTokens,
+    system: refusesForcedTool ? `${request.systemPrompt}
+
+Answer by calling the \`${toolName}\` tool exactly once. Do not answer in text.` : request.systemPrompt,
+    messages: [{ role: "user", content: request.userPrompt }],
+    tools: [
+      {
+        name: toolName,
+        description: request.tool.description,
+        input_schema: request.tool.input_schema
+      }
+    ],
+    tool_choice: refusesForcedTool ? { type: "auto", disable_parallel_tool_use: true } : { type: "tool", name: toolName }
+  };
+  const fetchImpl = request.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(request.endpoint ?? DEFAULT_ENDPOINT4, {
+    method: "POST",
+    headers: {
+      "x-api-key": request.apiKey,
+      "anthropic-version": DEFAULT_API_VERSION2,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body),
+    ...request.signal !== void 0 ? { signal: request.signal } : {}
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new AnthropicStructuredCallError(
+      "http",
+      `HTTP ${response.status}: ${text.slice(0, 500)}`,
+      { status: response.status }
+    );
+  }
+  const json = await response.json();
+  if (!isRecord(json) || !Array.isArray(json["content"])) {
+    throw new AnthropicStructuredCallError(
+      "malformed",
+      "response body is not a Messages response"
+    );
+  }
+  const stopReason = typeof json["stop_reason"] === "string" ? json["stop_reason"] : void 0;
+  const toolUse = json["content"].find(
+    (block) => isRecord(block) && block["type"] === "tool_use" && block["name"] === toolName
+  );
+  if (toolUse !== void 0 && toolUse["input"] !== void 0) {
+    const usage = readUsage(json["usage"]);
+    return { input: toolUse["input"], ...usage !== void 0 ? { usage } : {} };
+  }
+  if (stopReason === "max_tokens") {
+    throw new AnthropicStructuredCallError(
+      "max_tokens",
+      `stop_reason=max_tokens before the "${toolName}" tool_use block (max_tokens=${maxTokens})`,
+      { stopReason }
+    );
+  }
+  if (stopReason === "refusal") {
+    throw new AnthropicStructuredCallError(
+      "refusal",
+      "the model declined (stop_reason=refusal)",
+      { stopReason }
+    );
+  }
+  throw new AnthropicStructuredCallError(
+    "no_tool_call",
+    `the turn ended (stop_reason=${stopReason ?? "absent"}) without a "${toolName}" tool_use block`,
+    stopReason !== void 0 ? { stopReason } : {}
+  );
+}
+function readUsage(usage) {
+  if (!isRecord(usage)) return void 0;
+  const input = usage["input_tokens"];
+  const output = usage["output_tokens"];
+  return typeof input === "number" && typeof output === "number" ? { input, output } : void 0;
+}
 
 // src/providers/index.ts
 function selectAdapter(provider) {
@@ -721,6 +792,6 @@ function selectAdapter(provider) {
   }
 }
 
-export { createAnthropicAdapter, createBedrockAdapter, createGoogleAdapter, createOpenAiAdapter, createOpenRouterAdapter, selectAdapter };
+export { ANTHROPIC_STRUCTURED_CALL_FAILURE_KINDS, AnthropicStructuredCallError, anthropicToolCall, createAnthropicAdapter, createBedrockAdapter, createGoogleAdapter, createOpenAiAdapter, createOpenRouterAdapter, isAnthropicStructuredCallError, selectAdapter };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map