@yolk-sdk/emulators 0.1.0-canary.96

package/dist/anthropic.d.mts

@@ -0,0 +1,269 @@
+import { EmulatorEvidence, EmulatorRouteEvidence, emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { EmulatorCoverage, EmulatorFaultMatch, EmulatorFaultState, EmulatorRouteCoverage, EmulatorScriptedError } from "./emulator-kernel.mjs";
+import { MessagesEmulator, MessagesErrorEventFault, MessagesFault, MessagesFaultKind, MessagesLedgerEntry, MessagesScriptedMessage, MessagesScriptedToolUse, MessagesScriptedTurn, MessagesScriptedUsage, MessagesWireError } from "./messages.mjs";
+import { SubscriptionUsageEmulator, SubscriptionUsageFault, SubscriptionUsageLedgerEntry, SubscriptionUsageScriptedTurn } from "./subscription-usage.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/anthropic.d.ts
+declare const anthropicMessagesPath = "/v1/messages";
+/** The Claude subscription-usage path (`anthropicClaudeSubscriptionUsageUrl` in the SDK). */
+declare const anthropicSubscriptionUsagePath = "/api/oauth/usage";
+/** The `anthropic-beta` value the Claude usage fetcher sends for OAuth credentials. */
+declare const anthropicOAuthBeta = "oauth-2025-04-20";
+/**
+ * Route evidence manifest of the Claude subscription-usage route (served by the same fetch
+ * handler as the Messages route, with its own ledger and coverage). Synthetic, unverified.
+ */
+declare const anthropicSubscriptionUsageEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence>;
+/**
+ * The recorded Claude usage body (the synthetic `anthropic.claude.usage.snapshot` fixture, copied
+ * as data): `five_hour` and `seven_day` as `{ utilization, resets_at }`.
+ */
+declare const anthropicSubscriptionUsageDefault: Schema.Json;
+/** Synthetic-safe default model ids, including the Anthropic Messages conformance defaults. */
+declare const anthropicEmulatorDefaultModels: ReadonlyArray<string>;
+/**
+ * Route evidence manifest: every emulated Anthropic route and the conformance cases whose
+ * (currently synthetic, unverified) wire shapes it follows.
+ */
+declare const anthropicEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence>;
+/** Optional fault filter; an omitted field matches every request. `path` ending in `*` is a prefix. */
+declare const AnthropicFaultMatch: Schema.Struct<{
+  readonly path: Schema.optionalKey<Schema.String>;
+  readonly model: Schema.optionalKey<Schema.String>;
+}>;
+type AnthropicFaultMatch = typeof EmulatorFaultMatch.Type;
+/** An Anthropic wire error (`{ type, message }`), as sent inside the error envelope. */
+declare const AnthropicWireError: Schema.Struct<{
+  readonly type: Schema.NonEmptyString;
+  readonly message: Schema.String;
+}>;
+type AnthropicWireError = MessagesWireError;
+/** A mid-stream `error` event fault (default `overloaded_error`), streamed responses only. */
+declare const AnthropicErrorEventFault: Schema.Struct<{
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+  readonly kind: Schema.Literal<"error-event-after-chunks">;
+  readonly chunks: Schema.Int;
+  readonly error: Schema.optionalKey<Schema.Struct<{
+    readonly type: Schema.NonEmptyString;
+    readonly message: Schema.String;
+  }>>;
+}>;
+type AnthropicErrorEventFault = typeof MessagesErrorEventFault.Type;
+/**
+ * Wire faults:
+ *
+ * - `status`: answer with this status, headers, and body (for example 429 with `retry-after`,
+ *   or 529). The body defaults to the Anthropic error envelope for the status
+ *   (`rate_limit_error` for 429, `overloaded_error` for 529, `api_error` for other 5xx).
+ * - `error-after-chunks`: send N body chunks, then error the body stream (a dropped connection).
+ * - `truncate-after-chunks`: send N body chunks, then close cleanly (no `message_stop`).
+ * - `error-event-after-chunks`: send N SSE events, then one `event: error` event and close.
+ *
+ * Statuses that cannot carry a body and redirects are rejected, as are invalid headers and
+ * `location`. A fault that cannot take effect answers 500 and is not consumed.
+ */
+declare const AnthropicFault: Schema.Union<readonly [Schema.Struct<{
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+  readonly kind: Schema.Literal<"status">;
+  readonly status: Schema.Int;
+  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+  readonly body: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>, Schema.Struct<{
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+  readonly kind: Schema.Literal<"error-after-chunks">;
+  readonly chunks: Schema.Int;
+}>, Schema.Struct<{
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+  readonly kind: Schema.Literal<"truncate-after-chunks">;
+  readonly chunks: Schema.Int;
+}>, Schema.Struct<{
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+  readonly kind: Schema.Literal<"error-event-after-chunks">;
+  readonly chunks: Schema.Int;
+  readonly error: Schema.optionalKey<Schema.Struct<{
+    readonly type: Schema.NonEmptyString;
+    readonly message: Schema.String;
+  }>>;
+}>]>;
+type AnthropicFault = MessagesFault;
+type AnthropicFaultKind = MessagesFaultKind;
+/** Usage for a scripted turn (sent in `message_start` and `message_delta`). */
+declare const AnthropicScriptedUsage: Schema.Struct<{
+  readonly inputTokens: Schema.Int;
+  readonly outputTokens: Schema.Int;
+}>;
+type AnthropicScriptedUsage = MessagesScriptedUsage;
+/** One scripted `tool_use` block; its JSON input streams as these fragments. */
+declare const AnthropicScriptedToolUse: Schema.Struct<{
+  readonly name: Schema.NonEmptyString;
+  readonly inputFragments: Schema.$Array<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.NonEmptyString>;
+}>;
+type AnthropicScriptedToolUse = MessagesScriptedToolUse;
+/**
+ * A scripted message. Every field is exact except: a block is sent only when its field is
+ * present; `usage` omitted is synthesized and `null` drops it; `stopReason` omitted is
+ * `tool_use` with tool uses, else `end_turn`; `order` defaults to `thinking-first`.
+ */
+declare const AnthropicScriptedMessage: Schema.Struct<{
+  readonly thinking: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly text: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly toolUses: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly inputFragments: Schema.$Array<Schema.String>;
+    readonly id: Schema.optionalKey<Schema.NonEmptyString>;
+  }>>>;
+  readonly order: Schema.optionalKey<Schema.Literals<readonly ["thinking-first", "text-first"]>>;
+  readonly usage: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+    readonly inputTokens: Schema.Int;
+    readonly outputTokens: Schema.Int;
+  }>>>;
+  readonly stopReason: Schema.optionalKey<Schema.NonEmptyString>;
+}>;
+type AnthropicScriptedMessage = MessagesScriptedMessage;
+/** A scripted error response: status, body (a string is sent as is), and optional headers. */
+declare const AnthropicScriptedError: Schema.Struct<{
+  readonly error: Schema.Struct<{
+    readonly status: Schema.Int;
+    readonly body: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+  }>;
+}>;
+type AnthropicScriptedError = typeof EmulatorScriptedError.Type;
+/** A turn queued for the next Messages request. */
+declare const AnthropicScriptedTurn: Schema.Union<readonly [Schema.Struct<{
+  readonly error: Schema.Struct<{
+    readonly status: Schema.Int;
+    readonly body: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+  }>;
+}>, Schema.Struct<{
+  readonly thinking: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly text: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly toolUses: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly inputFragments: Schema.$Array<Schema.String>;
+    readonly id: Schema.optionalKey<Schema.NonEmptyString>;
+  }>>>;
+  readonly order: Schema.optionalKey<Schema.Literals<readonly ["thinking-first", "text-first"]>>;
+  readonly usage: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+    readonly inputTokens: Schema.Int;
+    readonly outputTokens: Schema.Int;
+  }>>>;
+  readonly stopReason: Schema.optionalKey<Schema.NonEmptyString>;
+}>]>;
+type AnthropicScriptedTurn = MessagesScriptedTurn;
+declare const AnthropicEmulatorInputInvalid_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "AnthropicEmulatorInputInvalid";
+} & Readonly<A>;
+/** Thrown by the JS API (`faults.add`, `script.enqueue`) for invalid input; a programmer error. */
+declare class AnthropicEmulatorInputInvalid extends AnthropicEmulatorInputInvalid_base<{
+  readonly input: 'fault' | 'turn';
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+type AnthropicLedgerEntry = MessagesLedgerEntry;
+type AnthropicFaultState = EmulatorFaultState<AnthropicFault>;
+type AnthropicRouteCoverage = EmulatorRouteCoverage;
+type AnthropicCoverage = EmulatorCoverage;
+/** A usage-route fault (`status`, `error-after-chunks`, `truncate-after-chunks`). */
+declare const AnthropicUsageFault: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+  readonly kind: Schema.Literal<"status">;
+  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+  readonly body: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>, Schema.Struct<{
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+  readonly kind: Schema.Literal<"error-after-chunks">;
+  readonly chunks: Schema.Int;
+}>, Schema.Struct<{
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+  readonly kind: Schema.Literal<"truncate-after-chunks">;
+  readonly chunks: Schema.Int;
+}>]>;
+type AnthropicUsageFault = SubscriptionUsageFault;
+/** A usage turn: `{ usage }` (a body with the recorded JSON shape) or `{ error }`. */
+type AnthropicUsageScriptedTurn = SubscriptionUsageScriptedTurn;
+type AnthropicUsageLedgerEntry = SubscriptionUsageLedgerEntry;
+type AnthropicUsageEmulator = SubscriptionUsageEmulator;
+type AnthropicEmulatorOptions = {
+  /** Model ids that exist. Defaults to `anthropicEmulatorDefaultModels`. */readonly knownModels?: ReadonlyArray<string>;
+  /**
+   * Replacement usage-route body; must have the recorded JSON shape (same keys and value kinds).
+   * Defaults to the recorded body (`anthropicSubscriptionUsageDefault`).
+   */
+  readonly subscriptionUsage?: Schema.Json;
+};
+/** The Messages emulator, plus `usage`: the subscription-usage route's own emulator API. */
+type AnthropicEmulator = MessagesEmulator & {
+  readonly usage: AnthropicUsageEmulator;
+};
+/**
+ * Create an Anthropic Messages emulator. Each call has independent ledger, fault, and script
+ * state.
+ *
+ * Without a script, `POST /v1/messages` answers a known model with synthetic content: `stream:
+ * true` streams `message_start`, the content blocks (`content_block_start`, deltas,
+ * `content_block_stop`, with a `ping` after the first block starts), `message_delta` (stop reason
+ * and usage), and `message_stop`; `stream: false` returns one `message` JSON body. A request with
+ * `thinking` enabled (`enabled` or `adaptive`) gets a thinking block before the answer. A request
+ * with `tools` gets one `tool_use` block whose input is synthesized from the tool's `input_schema`
+ * and streamed as `input_json_delta` fragments, stopping with `tool_use`; `tool_choice: { type:
+ * 'tool', name }` picks that tool (otherwise the first) and `tool_choice: { type: 'none' }`
+ * answers with text. An answer that would exceed `max_tokens` is cut and stops with `max_tokens`.
+ * Unknown models get 404 `not_found_error`; a request with neither a non-empty `x-api-key` nor a
+ * bearer credential gets 401 `authentication_error`; a missing or unsupported `anthropic-version`
+ * (only `2023-06-01` is accepted), a missing or non-positive `max_tokens`, or `thinking` with a
+ * forced `tool_choice` (`tool` or `any`) gets 400 `invalid_request_error`; unknown routes get a
+ * 404 envelope. The OAuth `anthropic-beta` header and `budget_tokens` limits are not enforced. The
+ * ledger records which header carried the credential, `anthropic-version`, and `anthropic-beta`,
+ * never a credential value.
+ *
+ * `GET /api/oauth/usage` is fixture-only: a request with a non-empty bearer credential (never
+ * checked or stored), an `anthropic-beta` header listing `oauth-2025-04-20`, `accept:
+ * application/json`, and no query gets the recorded body (`anthropicSubscriptionUsageDefault`,
+ * or a same-shaped `options.subscriptionUsage` / scripted `{ usage }`); anything else answers 400
+ * not-emulated. Throws `AnthropicEmulatorInputInvalid` for a differently shaped
+ * `subscriptionUsage`. Its ledger, faults, turns, and coverage are
+ * `emulator.usage` (control plane `/_emulate/usage/*`); `emulator.faults` and the other top-level
+ * APIs stay the Messages route's. `reset()` and `POST /_emulate/reset` reset both.
+ */
+declare const makeAnthropicEmulator: (options?: AnthropicEmulatorOptions) => AnthropicEmulator;
+//#endregion
+export { AnthropicCoverage, AnthropicEmulator, AnthropicEmulatorInputInvalid, AnthropicEmulatorOptions, AnthropicErrorEventFault, AnthropicFault, AnthropicFaultKind, AnthropicFaultMatch, AnthropicFaultState, AnthropicLedgerEntry, AnthropicRouteCoverage, AnthropicScriptedError, AnthropicScriptedMessage, AnthropicScriptedToolUse, AnthropicScriptedTurn, AnthropicScriptedUsage, AnthropicUsageEmulator, AnthropicUsageFault, AnthropicUsageLedgerEntry, AnthropicUsageScriptedTurn, AnthropicWireError, type EmulatorEvidence, type EmulatorRouteEvidence, anthropicEmulatorDefaultModels, anthropicEmulatorRoutes, anthropicMessagesPath, anthropicOAuthBeta, anthropicSubscriptionUsageDefault, anthropicSubscriptionUsageEmulatorRoutes, anthropicSubscriptionUsagePath, emulatorEvidenceHeader, makeAnthropicEmulator };
+//# sourceMappingURL=anthropic.d.mts.map

package/dist/anthropic.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.mts","names":[],"sources":["../src/anthropic.ts"],"mappings":";;;;;;;cA+Da,qBAAA;;cAGA,8BAAA;AAHqB;AAAA,cAMrB,kBAAA;;;;AAH8B;cAS9B,wCAAA,EAA0C,aAAa,CAAC,qBAAA;;;;AANtC;cAsBlB,iCAAA,EAAmC,MAAA,CAAO,IAEtD;;cAGY,8BAAA,EAAgC,aAAa;;AArBgC;AAgB1F;;cAca,uBAAA,EAAyB,aAAa,CAAC,qBAAA;;cAmBvC,mBAAA,EAAmB,MAAA,CAAA,MAAA;EAAA;;;KAEpB,mBAAA,UAA6B,kBAAA,CAAmB,IAAI;AA9BN;AAAA,cAiC7C,kBAAA,EAAkB,MAAA,CAAA,MAAA;EAAA;;;KAEnB,kBAAA,GAAqB,iBAAiB;AAPlD;AAAA,cAUa,wBAAA,EAAwB,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;KAEzB,wBAAA,UAAkC,uBAAA,CAAwB,IAAI;;;;;;;;;;AAV1E;;;;cAyBa,cAAA,EAAc,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEf,cAAA,GAAiB,aAAa;AAAA,KAE9B,kBAAA,GAAqB,iBAAiB;;cAGrC,sBAAA,EAAsB,MAAA,CAAA,MAAA;EAAA;;;KAEvB,sBAAA,GAAyB,qBAAqB;;cAG7C,wBAAA,EAAwB,MAAA,CAAA,MAAA;EAAA;;;;KAEzB,wBAAA,GAA2B,uBAAuB;;;;;;cAOjD,wBAAA,EAAwB,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;KAEzB,wBAAA,GAA2B,uBAAuB;;cAGjD,sBAAA,EAAsB,MAAA,CAAA,MAAA;EAAA;;;;;;KAEvB,sBAAA,UAAgC,qBAAA,CAAsB,IAAI;;cAGzD,qBAAA,EAAqB,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;KAEtB,qBAAA,GAAwB,oBAAoB;AAAA,cAAA,kCAAA;;;;cAG3C,6BAAA,SAAsC,kCAAA;EAAA,SAGxC,KAAA;EAAA,SACA,MAAA;AAAA;EAAA,IAEI,OAAA,CAAA;AAAA;AAAA,KAKH,oBAAA,GAAuB,mBAAmB;AAAA,KAE1C,mBAAA,GAAsB,kBAAkB,CAAC,cAAA;AAAA,KAEzC,sBAAA,GAAyB,qBAAqB;AAAA,KAE9C,iBAAA,GAAoB,gBAAgB;;cAGnC,mBAAA,EAAmB,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;KAEpB,mBAAA,GAAsB,sBAAsB;;KAG5C,0BAAA,GAA6B,6BAA6B;AAAA,KAE1D,yBAAA,GAA4B,4BAA4B;AAAA,KAExD,sBAAA,GAAyB,yBAAyB;AAAA,KAElD,wBAAA;EAnEe,mFAqEhB,WAAA,GAAc,aAAA;;;;;WAKd,iBAAA,GAAoB,MAAA,CAAO,IAAI;AAAA;;KAI9B,iBAAA,GAAoB,gBAAA;EAAA,SAA8B,KAAA,EAAO,sBAAsB;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgC9E,qBAAA,GAAyB,OAAA,GAAS,wBAAA,KAAgC,iBA2B5E"}

package/dist/anthropic.mjs

@@ -0,0 +1,177 @@
+import { emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { EmulatorFaultMatch, EmulatorScriptedError } from "./emulator-kernel.mjs";
+import { withSubscriptionUsage } from "./emulator-compose.mjs";
+import { MessagesErrorEventFault, MessagesFault, MessagesScriptedMessage, MessagesScriptedToolUse, MessagesScriptedTurn, MessagesScriptedUsage, MessagesWireError, makeMessagesEmulator } from "./messages.mjs";
+import { SubscriptionUsageFault, makeSubscriptionUsageEmulator, recordedUsageBody } from "./subscription-usage.mjs";
+import { anthropicClaudeUsageRecording } from "./subscription-usage-recordings.mjs";
+import { Data } from "effect";
+//#region src/anthropic.ts
+/**
+* Anthropic Messages emulator: a plain fetch handler for `POST /v1/messages` (origin
+* `https://api.anthropic.com`), with scripted turns, wire faults, a request ledger, and an
+* `/_emulate/*` control plane.
+*
+* It never imports SDK code: its wire shapes follow the synthetic Anthropic Messages conformance
+* fixtures (`message_start` / `content_block_*` / `message_delta` / `message_stop` SSE with
+* `text_delta`, `thinking_delta`, and `input_json_delta`, the `message` JSON body, and the
+* `{ type: 'error', error: { type, message } }` envelope) and are linked to those conformance
+* case ids in `anthropicEmulatorRoutes`. The Messages machinery lives in the internal
+* `messages.ts` core; faults, the ledger, and the control plane are shared with the Chat
+* Completions emulators.
+*
+* Requests authenticate with a non-empty `x-api-key` (native API keys) or `Authorization:
+* Bearer` (Claude OAuth) credential. Neither value is ever checked or stored.
+*
+* The same fetch handler also answers the Claude subscription-usage route
+* (`GET /api/oauth/usage`, `emulator.usage`) with its own manifest
+* (`anthropicSubscriptionUsageEmulatorRoutes`), ledger, faults, and turns; see
+* `makeAnthropicEmulator`.
+*
+* Runtime-portable Web APIs only (`Request`, `Response`, `ReadableStream`, `TextEncoder`, `URL`);
+* no Effect runtime is required to use it.
+*
+* @experimental
+*/
+const anthropicMessagesPath = "/v1/messages";
+/** The Claude subscription-usage path (`anthropicClaudeSubscriptionUsageUrl` in the SDK). */
+const anthropicSubscriptionUsagePath = "/api/oauth/usage";
+/** The `anthropic-beta` value the Claude usage fetcher sends for OAuth credentials. */
+const anthropicOAuthBeta = "oauth-2025-04-20";
+/**
+* Route evidence manifest of the Claude subscription-usage route (served by the same fetch
+* handler as the Messages route, with its own ledger and coverage). Synthetic, unverified.
+*/
+const anthropicSubscriptionUsageEmulatorRoutes = [{
+	method: "GET",
+	path: anthropicSubscriptionUsagePath,
+	kind: "provider",
+	write: false,
+	caseIds: ["anthropic.claude.usage.snapshot"],
+	evidence: "unverified",
+	observedAt: void 0
+}];
+/**
+* The recorded Claude usage body (the synthetic `anthropic.claude.usage.snapshot` fixture, copied
+* as data): `five_hour` and `seven_day` as `{ utilization, resets_at }`.
+*/
+const anthropicSubscriptionUsageDefault = recordedUsageBody(anthropicClaudeUsageRecording);
+/** Synthetic-safe default model ids, including the Anthropic Messages conformance defaults. */
+const anthropicEmulatorDefaultModels = ["claude-haiku-4-5", "claude-sonnet-4-5"];
+/**
+* Route evidence manifest: every emulated Anthropic route and the conformance cases whose
+* (currently synthetic, unverified) wire shapes it follows.
+*/
+const anthropicEmulatorRoutes = [{
+	method: "POST",
+	path: anthropicMessagesPath,
+	kind: "provider",
+	write: false,
+	caseIds: [
+		"anthropic.messages.stream.plain-text",
+		"anthropic.messages.stream.tool-use-input-deltas",
+		"anthropic.messages.stream.thinking-before-text",
+		"anthropic.messages.stream.error-envelope",
+		"anthropic.messages.stream.max-tokens"
+	],
+	evidence: "unverified",
+	observedAt: void 0
+}];
+/** Optional fault filter; an omitted field matches every request. `path` ending in `*` is a prefix. */
+const AnthropicFaultMatch = EmulatorFaultMatch;
+/** An Anthropic wire error (`{ type, message }`), as sent inside the error envelope. */
+const AnthropicWireError = MessagesWireError;
+/** A mid-stream `error` event fault (default `overloaded_error`), streamed responses only. */
+const AnthropicErrorEventFault = MessagesErrorEventFault;
+/**
+* Wire faults:
+*
+* - `status`: answer with this status, headers, and body (for example 429 with `retry-after`,
+*   or 529). The body defaults to the Anthropic error envelope for the status
+*   (`rate_limit_error` for 429, `overloaded_error` for 529, `api_error` for other 5xx).
+* - `error-after-chunks`: send N body chunks, then error the body stream (a dropped connection).
+* - `truncate-after-chunks`: send N body chunks, then close cleanly (no `message_stop`).
+* - `error-event-after-chunks`: send N SSE events, then one `event: error` event and close.
+*
+* Statuses that cannot carry a body and redirects are rejected, as are invalid headers and
+* `location`. A fault that cannot take effect answers 500 and is not consumed.
+*/
+const AnthropicFault = MessagesFault;
+/** Usage for a scripted turn (sent in `message_start` and `message_delta`). */
+const AnthropicScriptedUsage = MessagesScriptedUsage;
+/** One scripted `tool_use` block; its JSON input streams as these fragments. */
+const AnthropicScriptedToolUse = MessagesScriptedToolUse;
+/**
+* A scripted message. Every field is exact except: a block is sent only when its field is
+* present; `usage` omitted is synthesized and `null` drops it; `stopReason` omitted is
+* `tool_use` with tool uses, else `end_turn`; `order` defaults to `thinking-first`.
+*/
+const AnthropicScriptedMessage = MessagesScriptedMessage;
+/** A scripted error response: status, body (a string is sent as is), and optional headers. */
+const AnthropicScriptedError = EmulatorScriptedError;
+/** A turn queued for the next Messages request. */
+const AnthropicScriptedTurn = MessagesScriptedTurn;
+/** Thrown by the JS API (`faults.add`, `script.enqueue`) for invalid input; a programmer error. */
+var AnthropicEmulatorInputInvalid = class extends Data.TaggedError("AnthropicEmulatorInputInvalid") {
+	get message() {
+		return `Invalid Anthropic emulator ${this.input}: ${this.reason}`;
+	}
+};
+/** A usage-route fault (`status`, `error-after-chunks`, `truncate-after-chunks`). */
+const AnthropicUsageFault = SubscriptionUsageFault;
+/**
+* Create an Anthropic Messages emulator. Each call has independent ledger, fault, and script
+* state.
+*
+* Without a script, `POST /v1/messages` answers a known model with synthetic content: `stream:
+* true` streams `message_start`, the content blocks (`content_block_start`, deltas,
+* `content_block_stop`, with a `ping` after the first block starts), `message_delta` (stop reason
+* and usage), and `message_stop`; `stream: false` returns one `message` JSON body. A request with
+* `thinking` enabled (`enabled` or `adaptive`) gets a thinking block before the answer. A request
+* with `tools` gets one `tool_use` block whose input is synthesized from the tool's `input_schema`
+* and streamed as `input_json_delta` fragments, stopping with `tool_use`; `tool_choice: { type:
+* 'tool', name }` picks that tool (otherwise the first) and `tool_choice: { type: 'none' }`
+* answers with text. An answer that would exceed `max_tokens` is cut and stops with `max_tokens`.
+* Unknown models get 404 `not_found_error`; a request with neither a non-empty `x-api-key` nor a
+* bearer credential gets 401 `authentication_error`; a missing or unsupported `anthropic-version`
+* (only `2023-06-01` is accepted), a missing or non-positive `max_tokens`, or `thinking` with a
+* forced `tool_choice` (`tool` or `any`) gets 400 `invalid_request_error`; unknown routes get a
+* 404 envelope. The OAuth `anthropic-beta` header and `budget_tokens` limits are not enforced. The
+* ledger records which header carried the credential, `anthropic-version`, and `anthropic-beta`,
+* never a credential value.
+*
+* `GET /api/oauth/usage` is fixture-only: a request with a non-empty bearer credential (never
+* checked or stored), an `anthropic-beta` header listing `oauth-2025-04-20`, `accept:
+* application/json`, and no query gets the recorded body (`anthropicSubscriptionUsageDefault`,
+* or a same-shaped `options.subscriptionUsage` / scripted `{ usage }`); anything else answers 400
+* not-emulated. Throws `AnthropicEmulatorInputInvalid` for a differently shaped
+* `subscriptionUsage`. Its ledger, faults, turns, and coverage are
+* `emulator.usage` (control plane `/_emulate/usage/*`); `emulator.faults` and the other top-level
+* APIs stay the Messages route's. `reset()` and `POST /_emulate/reset` reset both.
+*/
+const makeAnthropicEmulator = (options = {}) => withSubscriptionUsage(makeMessagesEmulator({
+	path: anthropicMessagesPath,
+	routes: anthropicEmulatorRoutes,
+	knownModels: options.knownModels ?? anthropicEmulatorDefaultModels,
+	inputInvalid: (input, reason) => new AnthropicEmulatorInputInvalid({
+		input,
+		reason
+	})
+}), makeSubscriptionUsageEmulator({
+	path: anthropicSubscriptionUsagePath,
+	routes: anthropicSubscriptionUsageEmulatorRoutes,
+	recording: anthropicClaudeUsageRecording,
+	headers: [{
+		name: "anthropic-beta",
+		record: true,
+		accepts: (value) => value.split(",").map((beta) => beta.trim()).includes(anthropicOAuthBeta)
+	}],
+	subscriptionUsage: options.subscriptionUsage,
+	inputInvalid: (input, reason) => new AnthropicEmulatorInputInvalid({
+		input,
+		reason
+	})
+}), anthropicSubscriptionUsagePath);
+//#endregion
+export { AnthropicEmulatorInputInvalid, AnthropicErrorEventFault, AnthropicFault, AnthropicFaultMatch, AnthropicScriptedError, AnthropicScriptedMessage, AnthropicScriptedToolUse, AnthropicScriptedTurn, AnthropicScriptedUsage, AnthropicUsageFault, AnthropicWireError, anthropicEmulatorDefaultModels, anthropicEmulatorRoutes, anthropicMessagesPath, anthropicOAuthBeta, anthropicSubscriptionUsageDefault, anthropicSubscriptionUsageEmulatorRoutes, anthropicSubscriptionUsagePath, emulatorEvidenceHeader, makeAnthropicEmulator };
+
+//# sourceMappingURL=anthropic.mjs.map

package/dist/anthropic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.mjs","names":[],"sources":["../src/anthropic.ts"],"sourcesContent":["/**\n * Anthropic Messages emulator: a plain fetch handler for `POST /v1/messages` (origin\n * `https://api.anthropic.com`), with scripted turns, wire faults, a request ledger, and an\n * `/_emulate/*` control plane.\n *\n * It never imports SDK code: its wire shapes follow the synthetic Anthropic Messages conformance\n * fixtures (`message_start` / `content_block_*` / `message_delta` / `message_stop` SSE with\n * `text_delta`, `thinking_delta`, and `input_json_delta`, the `message` JSON body, and the\n * `{ type: 'error', error: { type, message } }` envelope) and are linked to those conformance\n * case ids in `anthropicEmulatorRoutes`. The Messages machinery lives in the internal\n * `messages.ts` core; faults, the ledger, and the control plane are shared with the Chat\n * Completions emulators.\n *\n * Requests authenticate with a non-empty `x-api-key` (native API keys) or `Authorization:\n * Bearer` (Claude OAuth) credential. Neither value is ever checked or stored.\n *\n * The same fetch handler also answers the Claude subscription-usage route\n * (`GET /api/oauth/usage`, `emulator.usage`) with its own manifest\n * (`anthropicSubscriptionUsageEmulatorRoutes`), ledger, faults, and turns; see\n * `makeAnthropicEmulator`.\n *\n * Runtime-portable Web APIs only (`Request`, `Response`, `ReadableStream`, `TextEncoder`, `URL`);\n * no Effect runtime is required to use it.\n *\n * @experimental\n */\nimport { Data } from 'effect'\nimport type * as Schema from 'effect/Schema'\nimport { withSubscriptionUsage } from './emulator-compose.ts'\nimport type {\n  EmulatorCoverage,\n  EmulatorFaultState,\n  EmulatorRouteCoverage\n} from './emulator-kernel.ts'\nimport { EmulatorFaultMatch, EmulatorScriptedError } from './emulator-kernel.ts'\nimport {\n  MessagesErrorEventFault,\n  MessagesFault,\n  MessagesScriptedMessage,\n  MessagesScriptedToolUse,\n  MessagesScriptedTurn,\n  MessagesScriptedUsage,\n  MessagesWireError,\n  makeMessagesEmulator,\n  type MessagesEmulator,\n  type MessagesFaultKind,\n  type MessagesLedgerEntry\n} from './messages.ts'\nimport type { EmulatorRouteEvidence } from './route-evidence.ts'\nimport {\n  makeSubscriptionUsageEmulator,\n  recordedUsageBody,\n  SubscriptionUsageFault,\n  type SubscriptionUsageEmulator,\n  type SubscriptionUsageLedgerEntry,\n  type SubscriptionUsageScriptedTurn\n} from './subscription-usage.ts'\nimport { anthropicClaudeUsageRecording } from './subscription-usage-recordings.ts'\n\nexport type { EmulatorEvidence, EmulatorRouteEvidence } from './route-evidence.ts'\n\nexport { emulatorEvidenceHeader } from './route-evidence.ts'\n\nexport const anthropicMessagesPath = '/v1/messages'\n\n/** The Claude subscription-usage path (`anthropicClaudeSubscriptionUsageUrl` in the SDK). */\nexport const anthropicSubscriptionUsagePath = '/api/oauth/usage'\n\n/** The `anthropic-beta` value the Claude usage fetcher sends for OAuth credentials. */\nexport const anthropicOAuthBeta = 'oauth-2025-04-20'\n\n/**\n * Route evidence manifest of the Claude subscription-usage route (served by the same fetch\n * handler as the Messages route, with its own ledger and coverage). Synthetic, unverified.\n */\nexport const anthropicSubscriptionUsageEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> = [\n  {\n    method: 'GET',\n    path: anthropicSubscriptionUsagePath,\n    kind: 'provider',\n    write: false,\n    caseIds: ['anthropic.claude.usage.snapshot'],\n    evidence: 'unverified',\n    observedAt: undefined\n  }\n]\n\n/**\n * The recorded Claude usage body (the synthetic `anthropic.claude.usage.snapshot` fixture, copied\n * as data): `five_hour` and `seven_day` as `{ utilization, resets_at }`.\n */\nexport const anthropicSubscriptionUsageDefault: Schema.Json = recordedUsageBody(\n  anthropicClaudeUsageRecording\n)\n\n/** Synthetic-safe default model ids, including the Anthropic Messages conformance defaults. */\nexport const anthropicEmulatorDefaultModels: ReadonlyArray<string> = [\n  'claude-haiku-4-5',\n  'claude-sonnet-4-5'\n]\n\n/**\n * Route evidence manifest: every emulated Anthropic route and the conformance cases whose\n * (currently synthetic, unverified) wire shapes it follows.\n */\nexport const anthropicEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> = [\n  {\n    method: 'POST',\n    path: anthropicMessagesPath,\n    kind: 'provider',\n    write: false,\n    caseIds: [\n      'anthropic.messages.stream.plain-text',\n      'anthropic.messages.stream.tool-use-input-deltas',\n      'anthropic.messages.stream.thinking-before-text',\n      'anthropic.messages.stream.error-envelope',\n      'anthropic.messages.stream.max-tokens'\n    ],\n    evidence: 'unverified',\n    observedAt: undefined\n  }\n]\n\n/** Optional fault filter; an omitted field matches every request. `path` ending in `*` is a prefix. */\nexport const AnthropicFaultMatch = EmulatorFaultMatch\n\nexport type AnthropicFaultMatch = typeof EmulatorFaultMatch.Type\n\n/** An Anthropic wire error (`{ type, message }`), as sent inside the error envelope. */\nexport const AnthropicWireError = MessagesWireError\n\nexport type AnthropicWireError = MessagesWireError\n\n/** A mid-stream `error` event fault (default `overloaded_error`), streamed responses only. */\nexport const AnthropicErrorEventFault = MessagesErrorEventFault\n\nexport type AnthropicErrorEventFault = typeof MessagesErrorEventFault.Type\n\n/**\n * Wire faults:\n *\n * - `status`: answer with this status, headers, and body (for example 429 with `retry-after`,\n *   or 529). The body defaults to the Anthropic error envelope for the status\n *   (`rate_limit_error` for 429, `overloaded_error` for 529, `api_error` for other 5xx).\n * - `error-after-chunks`: send N body chunks, then error the body stream (a dropped connection).\n * - `truncate-after-chunks`: send N body chunks, then close cleanly (no `message_stop`).\n * - `error-event-after-chunks`: send N SSE events, then one `event: error` event and close.\n *\n * Statuses that cannot carry a body and redirects are rejected, as are invalid headers and\n * `location`. A fault that cannot take effect answers 500 and is not consumed.\n */\nexport const AnthropicFault = MessagesFault\n\nexport type AnthropicFault = MessagesFault\n\nexport type AnthropicFaultKind = MessagesFaultKind\n\n/** Usage for a scripted turn (sent in `message_start` and `message_delta`). */\nexport const AnthropicScriptedUsage = MessagesScriptedUsage\n\nexport type AnthropicScriptedUsage = MessagesScriptedUsage\n\n/** One scripted `tool_use` block; its JSON input streams as these fragments. */\nexport const AnthropicScriptedToolUse = MessagesScriptedToolUse\n\nexport type AnthropicScriptedToolUse = MessagesScriptedToolUse\n\n/**\n * A scripted message. Every field is exact except: a block is sent only when its field is\n * present; `usage` omitted is synthesized and `null` drops it; `stopReason` omitted is\n * `tool_use` with tool uses, else `end_turn`; `order` defaults to `thinking-first`.\n */\nexport const AnthropicScriptedMessage = MessagesScriptedMessage\n\nexport type AnthropicScriptedMessage = MessagesScriptedMessage\n\n/** A scripted error response: status, body (a string is sent as is), and optional headers. */\nexport const AnthropicScriptedError = EmulatorScriptedError\n\nexport type AnthropicScriptedError = typeof EmulatorScriptedError.Type\n\n/** A turn queued for the next Messages request. */\nexport const AnthropicScriptedTurn = MessagesScriptedTurn\n\nexport type AnthropicScriptedTurn = MessagesScriptedTurn\n\n/** Thrown by the JS API (`faults.add`, `script.enqueue`) for invalid input; a programmer error. */\nexport class AnthropicEmulatorInputInvalid extends Data.TaggedError(\n  'AnthropicEmulatorInputInvalid'\n)<{\n  readonly input: 'fault' | 'turn'\n  readonly reason: string\n}> {\n  override get message(): string {\n    return `Invalid Anthropic emulator ${this.input}: ${this.reason}`\n  }\n}\n\nexport type AnthropicLedgerEntry = MessagesLedgerEntry\n\nexport type AnthropicFaultState = EmulatorFaultState<AnthropicFault>\n\nexport type AnthropicRouteCoverage = EmulatorRouteCoverage\n\nexport type AnthropicCoverage = EmulatorCoverage\n\n/** A usage-route fault (`status`, `error-after-chunks`, `truncate-after-chunks`). */\nexport const AnthropicUsageFault = SubscriptionUsageFault\n\nexport type AnthropicUsageFault = SubscriptionUsageFault\n\n/** A usage turn: `{ usage }` (a body with the recorded JSON shape) or `{ error }`. */\nexport type AnthropicUsageScriptedTurn = SubscriptionUsageScriptedTurn\n\nexport type AnthropicUsageLedgerEntry = SubscriptionUsageLedgerEntry\n\nexport type AnthropicUsageEmulator = SubscriptionUsageEmulator\n\nexport type AnthropicEmulatorOptions = {\n  /** Model ids that exist. Defaults to `anthropicEmulatorDefaultModels`. */\n  readonly knownModels?: ReadonlyArray<string>\n  /**\n   * Replacement usage-route body; must have the recorded JSON shape (same keys and value kinds).\n   * Defaults to the recorded body (`anthropicSubscriptionUsageDefault`).\n   */\n  readonly subscriptionUsage?: Schema.Json\n}\n\n/** The Messages emulator, plus `usage`: the subscription-usage route's own emulator API. */\nexport type AnthropicEmulator = MessagesEmulator & { readonly usage: AnthropicUsageEmulator }\n\n/**\n * Create an Anthropic Messages emulator. Each call has independent ledger, fault, and script\n * state.\n *\n * Without a script, `POST /v1/messages` answers a known model with synthetic content: `stream:\n * true` streams `message_start`, the content blocks (`content_block_start`, deltas,\n * `content_block_stop`, with a `ping` after the first block starts), `message_delta` (stop reason\n * and usage), and `message_stop`; `stream: false` returns one `message` JSON body. A request with\n * `thinking` enabled (`enabled` or `adaptive`) gets a thinking block before the answer. A request\n * with `tools` gets one `tool_use` block whose input is synthesized from the tool's `input_schema`\n * and streamed as `input_json_delta` fragments, stopping with `tool_use`; `tool_choice: { type:\n * 'tool', name }` picks that tool (otherwise the first) and `tool_choice: { type: 'none' }`\n * answers with text. An answer that would exceed `max_tokens` is cut and stops with `max_tokens`.\n * Unknown models get 404 `not_found_error`; a request with neither a non-empty `x-api-key` nor a\n * bearer credential gets 401 `authentication_error`; a missing or unsupported `anthropic-version`\n * (only `2023-06-01` is accepted), a missing or non-positive `max_tokens`, or `thinking` with a\n * forced `tool_choice` (`tool` or `any`) gets 400 `invalid_request_error`; unknown routes get a\n * 404 envelope. The OAuth `anthropic-beta` header and `budget_tokens` limits are not enforced. The\n * ledger records which header carried the credential, `anthropic-version`, and `anthropic-beta`,\n * never a credential value.\n *\n * `GET /api/oauth/usage` is fixture-only: a request with a non-empty bearer credential (never\n * checked or stored), an `anthropic-beta` header listing `oauth-2025-04-20`, `accept:\n * application/json`, and no query gets the recorded body (`anthropicSubscriptionUsageDefault`,\n * or a same-shaped `options.subscriptionUsage` / scripted `{ usage }`); anything else answers 400\n * not-emulated. Throws `AnthropicEmulatorInputInvalid` for a differently shaped\n * `subscriptionUsage`. Its ledger, faults, turns, and coverage are\n * `emulator.usage` (control plane `/_emulate/usage/*`); `emulator.faults` and the other top-level\n * APIs stay the Messages route's. `reset()` and `POST /_emulate/reset` reset both.\n */\nexport const makeAnthropicEmulator = (options: AnthropicEmulatorOptions = {}): AnthropicEmulator =>\n  withSubscriptionUsage(\n    makeMessagesEmulator({\n      path: anthropicMessagesPath,\n      routes: anthropicEmulatorRoutes,\n      knownModels: options.knownModels ?? anthropicEmulatorDefaultModels,\n      inputInvalid: (input, reason) => new AnthropicEmulatorInputInvalid({ input, reason })\n    }),\n    makeSubscriptionUsageEmulator({\n      path: anthropicSubscriptionUsagePath,\n      routes: anthropicSubscriptionUsageEmulatorRoutes,\n      recording: anthropicClaudeUsageRecording,\n      headers: [\n        {\n          name: 'anthropic-beta',\n          record: true,\n          accepts: value =>\n            value\n              .split(',')\n              .map(beta => beta.trim())\n              .includes(anthropicOAuthBeta)\n        }\n      ],\n      subscriptionUsage: options.subscriptionUsage,\n      inputInvalid: (input, reason) => new AnthropicEmulatorInputInvalid({ input, reason })\n    }),\n    anthropicSubscriptionUsagePath\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,MAAa,wBAAwB;;AAGrC,MAAa,iCAAiC;;AAG9C,MAAa,qBAAqB;;;;;AAMlC,MAAa,2CAAiF,CAC5F;CACE,QAAQ;CACR,MAAM;CACN,MAAM;CACN,OAAO;CACP,SAAS,CAAC,iCAAiC;CAC3C,UAAU;CACV,YAAY,KAAA;AACd,CACF;;;;;AAMA,MAAa,oCAAiD,kBAC5D,6BACF;;AAGA,MAAa,iCAAwD,CACnE,oBACA,mBACF;;;;;AAMA,MAAa,0BAAgE,CAC3E;CACE,QAAQ;CACR,MAAM;CACN,MAAM;CACN,OAAO;CACP,SAAS;EACP;EACA;EACA;EACA;EACA;CACF;CACA,UAAU;CACV,YAAY,KAAA;AACd,CACF;;AAGA,MAAa,sBAAsB;;AAKnC,MAAa,qBAAqB;;AAKlC,MAAa,2BAA2B;;;;;;;;;;;;;;AAiBxC,MAAa,iBAAiB;;AAO9B,MAAa,yBAAyB;;AAKtC,MAAa,2BAA2B;;;;;;AASxC,MAAa,2BAA2B;;AAKxC,MAAa,yBAAyB;;AAKtC,MAAa,wBAAwB;;AAKrC,IAAa,gCAAb,cAAmD,KAAK,YACtD,+BACF,EAGG;CACD,IAAa,UAAkB;EAC7B,OAAO,8BAA8B,KAAK,MAAM,IAAI,KAAK;CAC3D;AACF;;AAWA,MAAa,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDnC,MAAa,yBAAyB,UAAoC,CAAC,MACzE,sBACE,qBAAqB;CACnB,MAAM;CACN,QAAQ;CACR,aAAa,QAAQ,eAAe;CACpC,eAAe,OAAO,WAAW,IAAI,8BAA8B;EAAE;EAAO;CAAO,CAAC;AACtF,CAAC,GACD,8BAA8B;CAC5B,MAAM;CACN,QAAQ;CACR,WAAW;CACX,SAAS,CACP;EACE,MAAM;EACN,QAAQ;EACR,UAAS,UACP,MACG,MAAM,GAAG,EACT,KAAI,SAAQ,KAAK,KAAK,CAAC,EACvB,SAAS,kBAAkB;CAClC,CACF;CACA,mBAAmB,QAAQ;CAC3B,eAAe,OAAO,WAAW,IAAI,8BAA8B;EAAE;EAAO;CAAO,CAAC;AACtF,CAAC,GACD,8BACF"}