@graphorin/provider 0.5.0

package/dist/adapters/openai-compatible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-compatible.d.ts","names":[],"sources":["../../src/adapters/openai-compatible.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAwBiB,8BAAA;;;;;;;;;;;;;qBAaI,SAAS;;8BAEA;;;;;;;gCAOE,cAAc;;;;;;;;;;;;;iBAc9B,uBAAA,UAAiC,iCAAiC"}

package/dist/adapters/openai-compatible.js

@@ -0,0 +1,28 @@
+import { buildOpenAIShapedProvider } from "../internal/openai-shaped.js";
+
+//#region src/adapters/openai-compatible.ts
+/**
+* Build a Graphorin {@link Provider} backed by an OpenAI-compatible
+* HTTP server. The same code path serves LMStudio, LocalAI, vLLM, and
+* any other compatible self-host endpoint.
+*
+* @stable
+*/
+function openAICompatibleAdapter(options) {
+	return buildOpenAIShapedProvider({
+		providerName: options.name ?? `openai-compatible-${options.model}`,
+		model: options.model,
+		baseUrl: options.baseUrl,
+		...options.chatPath !== void 0 ? { chatPath: options.chatPath } : {},
+		...options.apiKey !== void 0 ? { apiKey: options.apiKey } : {},
+		...options.headers !== void 0 ? { headers: options.headers } : {},
+		...options.fetchImpl !== void 0 ? { fetchImpl: options.fetchImpl } : {},
+		...options.allowInsecureTransport !== void 0 ? { allowInsecureTransport: options.allowInsecureTransport } : {},
+		...options.acceptsSensitivity !== void 0 ? { acceptsSensitivity: options.acceptsSensitivity } : {},
+		...options.logger !== void 0 ? { logger: options.logger } : {}
+	}).provider;
+}
+
+//#endregion
+export { openAICompatibleAdapter };
+//# sourceMappingURL=openai-compatible.js.map

package/dist/adapters/openai-compatible.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-compatible.js","names":[],"sources":["../../src/adapters/openai-compatible.ts"],"sourcesContent":["/**\n * Generic OpenAI-compatible adapter — works against any HTTP server\n * that speaks the `/v1/chat/completions` REST contract. Tested\n * deployments include LMStudio (default port 1234), LocalAI (default\n * port 8080), vLLM (`python -m vllm.entrypoints.openai.api_server`,\n * default port 8000), Together-style self-host endpoints, and any\n * other server in the OpenAI-compatible ecosystem.\n *\n * The adapter shares the same `LocalProviderTrust` classifier as\n * `ollamaAdapter` and `llamaCppServerAdapter` — one classifier, one\n * policy table, one error type.\n *\n * @packageDocumentation\n */\n\nimport type { Provider, Sensitivity } from '@graphorin/core';\n\nimport { buildOpenAIShapedProvider } from '../internal/openai-shaped.js';\n\n/**\n * Options accepted by {@link openAICompatibleAdapter}.\n *\n * @stable\n */\nexport interface OpenAICompatibleAdapterOptions {\n  /** Model identifier sent in the request body's `model` field. */\n  readonly model: string;\n  /**\n   * Base URL of the OpenAI-compatible server. The classifier inspects\n   * the protocol + host to assign a `LocalProviderTrust` value.\n   */\n  readonly baseUrl: string;\n  /** Optional REST path override. Defaults to `/v1/chat/completions`. */\n  readonly chatPath?: string;\n  /** Optional bearer-auth API key. */\n  readonly apiKey?: string;\n  /** Extra headers merged on top of `content-type` + `accept` defaults. */\n  readonly headers?: Readonly<Record<string, string>>;\n  /** Custom `fetch` implementation; useful for tests. */\n  readonly fetchImpl?: typeof fetch;\n  /**\n   * Acknowledge the risk of running over plaintext HTTP against a\n   * public host.\n   */\n  readonly allowInsecureTransport?: boolean;\n  /** Override for the default `acceptsSensitivity` value. */\n  readonly acceptsSensitivity?: ReadonlyArray<Sensitivity>;\n  /** Provider name attached to spans / log lines. */\n  readonly name?: string;\n  /** Optional log sink. */\n  readonly logger?: (level: 'warn' | 'info', message: string, meta?: object) => void;\n}\n\n/**\n * Build a Graphorin {@link Provider} backed by an OpenAI-compatible\n * HTTP server. The same code path serves LMStudio, LocalAI, vLLM, and\n * any other compatible self-host endpoint.\n *\n * @stable\n */\nexport function openAICompatibleAdapter(options: OpenAICompatibleAdapterOptions): Provider {\n  const providerName = options.name ?? `openai-compatible-${options.model}`;\n  const built = buildOpenAIShapedProvider({\n    providerName,\n    model: options.model,\n    baseUrl: options.baseUrl,\n    ...(options.chatPath !== undefined ? { chatPath: options.chatPath } : {}),\n    ...(options.apiKey !== undefined ? { apiKey: options.apiKey } : {}),\n    ...(options.headers !== undefined ? { headers: options.headers } : {}),\n    ...(options.fetchImpl !== undefined ? { fetchImpl: options.fetchImpl } : {}),\n    ...(options.allowInsecureTransport !== undefined\n      ? { allowInsecureTransport: options.allowInsecureTransport }\n      : {}),\n    ...(options.acceptsSensitivity !== undefined\n      ? { acceptsSensitivity: options.acceptsSensitivity }\n      : {}),\n    ...(options.logger !== undefined ? { logger: options.logger } : {}),\n  });\n  return built.provider;\n}\n"],"mappings":";;;;;;;;;;AA4DA,SAAgB,wBAAwB,SAAmD;AAkBzF,QAhBc,0BAA0B;EACtC,cAFmB,QAAQ,QAAQ,qBAAqB,QAAQ;EAGhE,OAAO,QAAQ;EACf,SAAS,QAAQ;EACjB,GAAI,QAAQ,aAAa,SAAY,EAAE,UAAU,QAAQ,UAAU,GAAG,EAAE;EACxE,GAAI,QAAQ,WAAW,SAAY,EAAE,QAAQ,QAAQ,QAAQ,GAAG,EAAE;EAClE,GAAI,QAAQ,YAAY,SAAY,EAAE,SAAS,QAAQ,SAAS,GAAG,EAAE;EACrE,GAAI,QAAQ,cAAc,SAAY,EAAE,WAAW,QAAQ,WAAW,GAAG,EAAE;EAC3E,GAAI,QAAQ,2BAA2B,SACnC,EAAE,wBAAwB,QAAQ,wBAAwB,GAC1D,EAAE;EACN,GAAI,QAAQ,uBAAuB,SAC/B,EAAE,oBAAoB,QAAQ,oBAAoB,GAClD,EAAE;EACN,GAAI,QAAQ,WAAW,SAAY,EAAE,QAAQ,QAAQ,QAAQ,GAAG,EAAE;EACnE,CAAC,CACW"}

package/dist/adapters/vercel.d.ts

@@ -0,0 +1,135 @@
+import { Message, Provider, ProviderCapabilities, Usage } from "@graphorin/core";
+
+//#region src/adapters/vercel.d.ts
+
+/**
+ * Structural shape the adapter expects from the AI SDK language model
+ * value. The real `LanguageModelV4` matches this shape. Re-declared
+ * here so we do not pin a hard dependency on `@ai-sdk/provider`.
+ *
+ * @stable
+ */
+interface LanguageModelLike {
+  readonly provider: string;
+  readonly modelId: string;
+  readonly specificationVersion?: string | number;
+  /**
+   * Optional capability flags carried by the AI SDK model. The adapter
+   * forwards them onto the canonical `ProviderCapabilities` shape;
+   * missing values are filled in with conservative defaults.
+   */
+  readonly supportedToolCallTypes?: readonly string[];
+}
+/**
+ * Loose chunk shape emitted by the AI SDK's `streamText`. The shape is
+ * intentionally permissive — we accept anything that carries the
+ * fields we use and ignore the rest. This keeps the adapter tolerant
+ * of additive AI SDK schema changes.
+ *
+ * The fields we read are normalized in the adapter via narrow helper
+ * functions, so we deliberately type each as `unknown` and gate
+ * access behind `typeof` checks at runtime.
+ *
+ * @stable
+ */
+interface AISDKChunk {
+  readonly type: string;
+  readonly [extra: string]: unknown;
+}
+/**
+ * Subset of the AI SDK surface used by the adapter.
+ *
+ * @stable
+ */
+interface VercelRuntimeOverrides {
+  readonly streamText: (args: {
+    model: LanguageModelLike;
+    messages: ReadonlyArray<Message>;
+    system?: string;
+    tools?: unknown;
+    toolChoice?: unknown;
+    temperature?: number;
+    maxTokens?: number;
+    abortSignal?: AbortSignal;
+    providerOptions?: Readonly<Record<string, unknown>>;
+  }) => {
+    readonly fullStream: AsyncIterable<AISDKChunk>;
+  };
+  readonly generateText: (args: {
+    model: LanguageModelLike;
+    messages: ReadonlyArray<Message>;
+    system?: string;
+    tools?: unknown;
+    toolChoice?: unknown;
+    temperature?: number;
+    maxTokens?: number;
+    abortSignal?: AbortSignal;
+    providerOptions?: Readonly<Record<string, unknown>>;
+  }) => Promise<{
+    readonly text?: string;
+    readonly toolCalls?: ReadonlyArray<{
+      readonly toolCallId: string;
+      readonly toolName: string;
+      readonly args: unknown;
+    }>;
+    readonly usage?: Partial<Usage> & {
+      readonly inputTokens?: number;
+      readonly outputTokens?: number;
+      readonly totalTokens?: number;
+    };
+    readonly finishReason?: string;
+    readonly providerMetadata?: Readonly<Record<string, unknown>>;
+  }>;
+}
+/**
+ * Options accepted by {@link vercelAdapter}.
+ *
+ * @stable
+ */
+interface VercelAdapterOptions {
+  /**
+   * Fully-qualified provider name, used for span / log labelling.
+   * Defaults to `${model.provider}-${model.modelId}`.
+   */
+  readonly name?: string;
+  /**
+   * Capability declaration. The adapter merges these on top of a
+   * conservative defaults table (`streaming: true`, `toolCalling: true`,
+   * `multimodal: true`, …); supply explicit values to narrow them.
+   */
+  readonly capabilities?: Partial<ProviderCapabilities>;
+  /**
+   * Runtime override for the AI SDK functions. When unset, the adapter
+   * lazily `await import('ai')` on first call. Test suites pass a
+   * fixture-driven implementation directly.
+   */
+  readonly runtimeOverrides?: VercelRuntimeOverrides;
+}
+/**
+ * Wrap a Vercel AI SDK language-model value in a Graphorin
+ * {@link Provider}. The adapter passes Graphorin `Message`s through
+ * directly — both formats use the same role + content discriminated
+ * shape — and translates the streaming chunks emitted by the AI SDK
+ * onto Graphorin `ProviderEvent`s.
+ *
+ * The adapter auto-detects the model's
+ * {@link import('@graphorin/core').ReasoningContract} from its
+ * `modelId` (e.g. Anthropic Claude → `'round-trip-required'`,
+ * OpenAI o1 / o3 → `'hidden'`, Gemini reasoning variants →
+ * `'hidden'`, everything else → `'optional'`). Callers can override
+ * the inferred value via `options.capabilities.reasoningContract`.
+ *
+ * @stable
+ */
+declare function vercelAdapter(model: LanguageModelLike, options?: VercelAdapterOptions): Provider;
+/**
+ * Test-only hook that resets the cached AI SDK runtime. Provider tests
+ * that mutate the cache (e.g. by injecting a mock then verifying the
+ * default loader runs) call this between scenarios.
+ *
+ * @internal
+ */
+declare function __resetVercelRuntimeCache(): void;
+//#endregion
+export { AISDKChunk, LanguageModelLike, VercelAdapterOptions, VercelRuntimeOverrides, __resetVercelRuntimeCache, vercelAdapter };
+//# sourceMappingURL=vercel.d.ts.map

package/dist/adapters/vercel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel.d.ts","names":[],"sources":["../../src/adapters/vercel.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AAmGQ,UA1DS,iBAAA,CA0DT;EAAO,SAAA,QAAA,EAAA,MAAA;EAsBE,SAAA,OAAA,EAAA,MAAoB;EAWH,SAAA,oBAAA,CAAA,EAAA,MAAA,GAAA,MAAA;EAAR;;;AAoC1B;;EAEW,SAAA,sBAAA,CAAA,EAAA,SAAA,MAAA,EAAA;;;AA+VX;;;;;;;;;;;UAxciB,UAAA;;;;;;;;;UAUA,sBAAA;;WAEN;cACG,cAAc;;;;;;kBAMV;sBACI,SAAS;;yBAEN,cAAc;;;WAG5B;cACG,cAAc;;;;;;kBAMV;sBACI,SAAS;QACvB;;yBAEiB;;;;;qBAKJ,QAAQ;;;;;;gCAMG,SAAS;;;;;;;;UASxB,oBAAA;;;;;;;;;;;0BAWS,QAAQ;;;;;;8BAMJ;;;;;;;;;;;;;;;;;;iBA8Bd,aAAA,QACP,6BACE,uBACR;;;;;;;;iBA8Va,yBAAA,CAAA"}

package/dist/adapters/vercel.js

@@ -0,0 +1,306 @@
+import { ProviderHttpError, ProviderStreamParseError } from "../errors/errors.js";
+import { applyReasoningPolicy } from "../reasoning/apply-policy.js";
+import { resolveReasoningRetention } from "../reasoning/retention.js";
+import { inferReasoningContract } from "../reasoning/classify-contract.js";
+
+//#region src/adapters/vercel.ts
+const DEFAULT_CAPABILITIES = {
+	streaming: true,
+	toolCalling: true,
+	parallelToolCalls: true,
+	multimodal: true,
+	structuredOutput: true,
+	reasoning: true,
+	contextWindow: 2e5,
+	maxOutput: 16384
+};
+/**
+* Wrap a Vercel AI SDK language-model value in a Graphorin
+* {@link Provider}. The adapter passes Graphorin `Message`s through
+* directly — both formats use the same role + content discriminated
+* shape — and translates the streaming chunks emitted by the AI SDK
+* onto Graphorin `ProviderEvent`s.
+*
+* The adapter auto-detects the model's
+* {@link import('@graphorin/core').ReasoningContract} from its
+* `modelId` (e.g. Anthropic Claude → `'round-trip-required'`,
+* OpenAI o1 / o3 → `'hidden'`, Gemini reasoning variants →
+* `'hidden'`, everything else → `'optional'`). Callers can override
+* the inferred value via `options.capabilities.reasoningContract`.
+*
+* @stable
+*/
+function vercelAdapter(model, options = {}) {
+	const name = options.name ?? `${model.provider}-${model.modelId}`;
+	const inferredContract = inferReasoningContract({
+		modelId: model.modelId,
+		provider: model.provider
+	});
+	const capabilities = {
+		...DEFAULT_CAPABILITIES,
+		reasoningContract: inferredContract,
+		...options.capabilities
+	};
+	const runtime = options.runtimeOverrides;
+	return {
+		name,
+		modelId: model.modelId,
+		capabilities,
+		stream(req) {
+			return streamFromVercel(model, name, capabilities, req, runtime);
+		},
+		async generate(req) {
+			return generateFromVercel(model, name, capabilities, req, runtime);
+		}
+	};
+}
+async function* streamFromVercel(model, providerName, capabilities, req, overrides) {
+	const sdk = await loadRuntime(overrides);
+	const callArgs = buildCallArgs(model, applyRequestPreflight(req, capabilities));
+	let stream;
+	try {
+		stream = sdk.streamText(callArgs).fullStream;
+	} catch (cause) {
+		throw new ProviderHttpError({
+			providerName,
+			status: statusFromCause(cause),
+			message: "streamText() failed before yielding any chunks",
+			cause
+		});
+	}
+	yield {
+		type: "stream-start",
+		metadata: {
+			providerName,
+			modelId: model.modelId
+		}
+	};
+	let finalUsage;
+	let finishReason = "stop";
+	for await (const chunk of stream) {
+		if (req.signal?.aborted) {
+			finishReason = "aborted";
+			break;
+		}
+		switch (chunk.type) {
+			case "text-delta": {
+				const delta = pickString(chunk.textDelta) ?? pickString(chunk.text) ?? "";
+				if (delta.length > 0) yield {
+					type: "text-delta",
+					delta
+				};
+				break;
+			}
+			case "reasoning":
+			case "reasoning-delta": {
+				const delta = pickString(chunk.textDelta) ?? pickString(chunk.delta) ?? pickString(chunk.text) ?? "";
+				if (delta.length > 0) yield {
+					type: "reasoning-delta",
+					delta
+				};
+				break;
+			}
+			case "tool-call-streaming-start":
+			case "tool-input-start": {
+				const toolCallId = pickString(chunk.toolCallId) ?? pickString(chunk.id);
+				const toolName = pickString(chunk.toolName);
+				if (toolCallId !== void 0 && toolName !== void 0) yield {
+					type: "tool-call-start",
+					toolCallId,
+					toolName
+				};
+				break;
+			}
+			case "tool-call-delta":
+			case "tool-input-delta": {
+				const toolCallId = pickString(chunk.toolCallId) ?? pickString(chunk.id);
+				const argsDelta = pickString(chunk.argsTextDelta) ?? pickString(chunk.delta) ?? pickString(chunk.inputTextDelta);
+				if (toolCallId !== void 0 && argsDelta !== void 0 && argsDelta.length > 0) yield {
+					type: "tool-call-input-delta",
+					toolCallId,
+					argsDelta
+				};
+				break;
+			}
+			case "tool-call": {
+				const toolCallId = pickString(chunk.toolCallId) ?? pickString(chunk.id);
+				if (toolCallId !== void 0) yield {
+					type: "tool-call-end",
+					toolCallId,
+					finalArgs: chunk.args ?? chunk.input
+				};
+				break;
+			}
+			case "finish":
+				finishReason = mapFinishReason(pickString(chunk.finishReason));
+				finalUsage = mapUsage(chunk.totalUsage ?? chunk.usage);
+				break;
+			case "error": {
+				const errorField = chunk.error;
+				yield {
+					type: "error",
+					error: {
+						kind: "unknown",
+						message: typeof errorField === "string" ? errorField : typeof errorField === "object" && errorField !== null ? pickString(errorField.message) ?? "unknown error" : "unknown error"
+					}
+				};
+				break;
+			}
+			default: break;
+		}
+	}
+	yield {
+		type: "finish",
+		finishReason,
+		usage: finalUsage ?? {
+			promptTokens: 0,
+			completionTokens: 0,
+			totalTokens: 0
+		}
+	};
+}
+async function generateFromVercel(model, providerName, capabilities, req, overrides) {
+	const sdk = await loadRuntime(overrides);
+	const callArgs = buildCallArgs(model, applyRequestPreflight(req, capabilities));
+	let result;
+	try {
+		result = await sdk.generateText(callArgs);
+	} catch (cause) {
+		throw new ProviderHttpError({
+			providerName,
+			status: statusFromCause(cause),
+			message: "generateText() rejected",
+			cause
+		});
+	}
+	return {
+		usage: mapUsage(result.usage) ?? {
+			promptTokens: 0,
+			completionTokens: 0,
+			totalTokens: 0
+		},
+		finishReason: mapFinishReason(result.finishReason),
+		...result.text !== void 0 ? { text: result.text } : {},
+		...result.toolCalls !== void 0 ? { toolCalls: result.toolCalls.map(normalizeToolCall) } : {},
+		...result.providerMetadata !== void 0 ? { providerMetadata: result.providerMetadata } : {}
+	};
+}
+function applyRequestPreflight(req, capabilities) {
+	const retention = resolveReasoningRetention({
+		...req.reasoningRetention !== void 0 ? { requested: req.reasoningRetention } : {},
+		...capabilities.reasoningContract !== void 0 ? { contract: capabilities.reasoningContract } : {}
+	});
+	if (retention === "pass-through-all") return req;
+	const filtered = applyReasoningPolicy({
+		messages: req.messages,
+		retention
+	});
+	if (filtered === req.messages) return req;
+	return {
+		...req,
+		messages: filtered
+	};
+}
+function buildCallArgs(model, req) {
+	return {
+		model,
+		messages: req.messages,
+		...req.systemMessage !== void 0 ? { system: req.systemMessage } : {},
+		...req.tools !== void 0 ? { tools: req.tools } : {},
+		...req.toolChoice !== void 0 ? { toolChoice: req.toolChoice } : {},
+		...req.temperature !== void 0 ? { temperature: req.temperature } : {},
+		...req.maxTokens !== void 0 ? {
+			maxTokens: req.maxTokens,
+			maxOutputTokens: req.maxTokens
+		} : {},
+		...req.signal !== void 0 ? { abortSignal: req.signal } : {},
+		...req.providerOptions !== void 0 ? { providerOptions: req.providerOptions } : {}
+	};
+}
+function pickString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+/**
+* Normalize a generate() tool call across peers: AI SDK v4 carries
+* `args`, v7 carries `input` (PS-6). The framework shape is `args`.
+*/
+function normalizeToolCall(tc) {
+	const t = tc;
+	return {
+		toolCallId: pickString(t.toolCallId) ?? pickString(t.id) ?? "",
+		toolName: pickString(t.toolName) ?? "",
+		args: t.args ?? t.input
+	};
+}
+/**
+* Lift a real HTTP status from a rejected AI SDK call (PS-2). The SDK's
+* `APICallError` carries a numeric `statusCode`; surfacing it lets
+* `withRetry` / `withFallback` see a genuine 429 / 5xx instead of the
+* `status: 0` network-error placeholder. Returns `0` when no status is
+* present (a true transport-level failure or an abort) — `0` is itself
+* retryable / fallback-eligible by default, while an abort is excluded by
+* the predicates via the wrapped `cause`.
+*/
+function statusFromCause(cause) {
+	if (cause !== null && typeof cause === "object") {
+		const c = cause;
+		if (typeof c.statusCode === "number" && Number.isFinite(c.statusCode)) return c.statusCode;
+		if (typeof c.status === "number" && Number.isFinite(c.status)) return c.status;
+	}
+	return 0;
+}
+function mapFinishReason(value) {
+	switch (value) {
+		case "stop":
+		case "length":
+		case "tool-calls":
+		case "content-filter":
+		case "error": return value;
+		case "aborted":
+		case "cancelled": return "aborted";
+		default: return "stop";
+	}
+}
+function mapUsage(input) {
+	if (input === void 0 || input === null || typeof input !== "object") return void 0;
+	const u = input;
+	const promptTokens = u.promptTokens ?? u.inputTokens ?? 0;
+	const completionTokens = u.completionTokens ?? u.outputTokens ?? 0;
+	return {
+		promptTokens,
+		completionTokens,
+		totalTokens: u.totalTokens ?? promptTokens + completionTokens,
+		...u.reasoningTokens !== void 0 ? { reasoningTokens: u.reasoningTokens } : {}
+	};
+}
+let cachedRuntime = null;
+async function loadRuntime(overrides) {
+	if (overrides !== void 0) return overrides;
+	if (cachedRuntime !== null) return cachedRuntime;
+	let mod;
+	try {
+		mod = await import("ai");
+	} catch (cause) {
+		throw new ProviderStreamParseError("vercel", "Failed to import the 'ai' peer dependency. Install it with `pnpm add ai` or pass a runtimeOverrides value.", cause);
+	}
+	if (typeof mod.streamText !== "function" || typeof mod.generateText !== "function") throw new ProviderStreamParseError("vercel", "The installed 'ai' package does not expose streamText / generateText functions.");
+	cachedRuntime = {
+		streamText: mod.streamText,
+		generateText: mod.generateText
+	};
+	return cachedRuntime;
+}
+/**
+* Test-only hook that resets the cached AI SDK runtime. Provider tests
+* that mutate the cache (e.g. by injecting a mock then verifying the
+* default loader runs) call this between scenarios.
+*
+* @internal
+*/
+function __resetVercelRuntimeCache() {
+	cachedRuntime = null;
+}
+
+//#endregion
+export { __resetVercelRuntimeCache, vercelAdapter };
+//# sourceMappingURL=vercel.js.map

package/dist/adapters/vercel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel.js","names":["DEFAULT_CAPABILITIES: Omit<ProviderCapabilities, 'reasoningContract'>","capabilities: ProviderCapabilities","stream: AsyncIterable<AISDKChunk>","finalUsage: Usage | undefined","finishReason: FinishReason","result: Awaited<ReturnType<VercelRuntimeOverrides['generateText']>>","cachedRuntime: VercelRuntimeOverrides | null","mod: { streamText?: unknown; generateText?: unknown }"],"sources":["../../src/adapters/vercel.ts"],"sourcesContent":["/**\n * `vercelAdapter` — wraps a Vercel AI SDK `LanguageModel`-shaped value\n * into a Graphorin {@link Provider}. The adapter is the default cloud\n * path: it speaks the AI SDK's `streamText` / `generateText` API and\n * maps the resulting events onto the canonical\n * {@link import('@graphorin/core').ProviderEvent} discriminated union.\n *\n * The AI SDK is an **optional peer dependency** of `@graphorin/provider`.\n * Production callers leave `runtimeOverrides` unset and the adapter\n * dynamically imports the package on first use; test fixtures pass a\n * `runtimeOverrides` value to short-circuit the import and feed\n * fixture chunks directly. The overrides shape is intentionally\n * structural so users can supply hand-rolled stubs or any compatible\n * library.\n *\n * @packageDocumentation\n */\n\nimport type {\n  FinishReason,\n  Message,\n  Provider,\n  ProviderCapabilities,\n  ProviderEvent,\n  ProviderRequest,\n  ProviderResponse,\n  Usage,\n} from '@graphorin/core';\n\nimport { ProviderHttpError, ProviderStreamParseError } from '../errors/errors.js';\nimport { applyReasoningPolicy } from '../reasoning/apply-policy.js';\nimport { inferReasoningContract } from '../reasoning/classify-contract.js';\nimport { resolveReasoningRetention } from '../reasoning/retention.js';\n\n/**\n * Structural shape the adapter expects from the AI SDK language model\n * value. The real `LanguageModelV4` matches this shape. Re-declared\n * here so we do not pin a hard dependency on `@ai-sdk/provider`.\n *\n * @stable\n */\nexport interface LanguageModelLike {\n  readonly provider: string;\n  readonly modelId: string;\n  readonly specificationVersion?: string | number;\n  /**\n   * Optional capability flags carried by the AI SDK model. The adapter\n   * forwards them onto the canonical `ProviderCapabilities` shape;\n   * missing values are filled in with conservative defaults.\n   */\n  readonly supportedToolCallTypes?: readonly string[];\n}\n\n/**\n * Loose chunk shape emitted by the AI SDK's `streamText`. The shape is\n * intentionally permissive — we accept anything that carries the\n * fields we use and ignore the rest. This keeps the adapter tolerant\n * of additive AI SDK schema changes.\n *\n * The fields we read are normalized in the adapter via narrow helper\n * functions, so we deliberately type each as `unknown` and gate\n * access behind `typeof` checks at runtime.\n *\n * @stable\n */\nexport interface AISDKChunk {\n  readonly type: string;\n  readonly [extra: string]: unknown;\n}\n\n/**\n * Subset of the AI SDK surface used by the adapter.\n *\n * @stable\n */\nexport interface VercelRuntimeOverrides {\n  readonly streamText: (args: {\n    model: LanguageModelLike;\n    messages: ReadonlyArray<Message>;\n    system?: string;\n    tools?: unknown;\n    toolChoice?: unknown;\n    temperature?: number;\n    maxTokens?: number;\n    abortSignal?: AbortSignal;\n    providerOptions?: Readonly<Record<string, unknown>>;\n  }) => {\n    readonly fullStream: AsyncIterable<AISDKChunk>;\n  };\n  readonly generateText: (args: {\n    model: LanguageModelLike;\n    messages: ReadonlyArray<Message>;\n    system?: string;\n    tools?: unknown;\n    toolChoice?: unknown;\n    temperature?: number;\n    maxTokens?: number;\n    abortSignal?: AbortSignal;\n    providerOptions?: Readonly<Record<string, unknown>>;\n  }) => Promise<{\n    readonly text?: string;\n    readonly toolCalls?: ReadonlyArray<{\n      readonly toolCallId: string;\n      readonly toolName: string;\n      readonly args: unknown;\n    }>;\n    readonly usage?: Partial<Usage> & {\n      readonly inputTokens?: number;\n      readonly outputTokens?: number;\n      readonly totalTokens?: number;\n    };\n    readonly finishReason?: string;\n    readonly providerMetadata?: Readonly<Record<string, unknown>>;\n  }>;\n}\n\n/**\n * Options accepted by {@link vercelAdapter}.\n *\n * @stable\n */\nexport interface VercelAdapterOptions {\n  /**\n   * Fully-qualified provider name, used for span / log labelling.\n   * Defaults to `${model.provider}-${model.modelId}`.\n   */\n  readonly name?: string;\n  /**\n   * Capability declaration. The adapter merges these on top of a\n   * conservative defaults table (`streaming: true`, `toolCalling: true`,\n   * `multimodal: true`, …); supply explicit values to narrow them.\n   */\n  readonly capabilities?: Partial<ProviderCapabilities>;\n  /**\n   * Runtime override for the AI SDK functions. When unset, the adapter\n   * lazily `await import('ai')` on first call. Test suites pass a\n   * fixture-driven implementation directly.\n   */\n  readonly runtimeOverrides?: VercelRuntimeOverrides;\n}\n\nconst DEFAULT_CAPABILITIES: Omit<ProviderCapabilities, 'reasoningContract'> = {\n  streaming: true,\n  toolCalling: true,\n  parallelToolCalls: true,\n  multimodal: true,\n  structuredOutput: true,\n  reasoning: true,\n  contextWindow: 200_000,\n  maxOutput: 16_384,\n};\n\n/**\n * Wrap a Vercel AI SDK language-model value in a Graphorin\n * {@link Provider}. The adapter passes Graphorin `Message`s through\n * directly — both formats use the same role + content discriminated\n * shape — and translates the streaming chunks emitted by the AI SDK\n * onto Graphorin `ProviderEvent`s.\n *\n * The adapter auto-detects the model's\n * {@link import('@graphorin/core').ReasoningContract} from its\n * `modelId` (e.g. Anthropic Claude → `'round-trip-required'`,\n * OpenAI o1 / o3 → `'hidden'`, Gemini reasoning variants →\n * `'hidden'`, everything else → `'optional'`). Callers can override\n * the inferred value via `options.capabilities.reasoningContract`.\n *\n * @stable\n */\nexport function vercelAdapter(\n  model: LanguageModelLike,\n  options: VercelAdapterOptions = {},\n): Provider {\n  const name = options.name ?? `${model.provider}-${model.modelId}`;\n  const inferredContract = inferReasoningContract({\n    modelId: model.modelId,\n    provider: model.provider,\n  });\n  const capabilities: ProviderCapabilities = {\n    ...DEFAULT_CAPABILITIES,\n    reasoningContract: inferredContract,\n    ...options.capabilities,\n  };\n  const runtime = options.runtimeOverrides;\n\n  return {\n    name,\n    modelId: model.modelId,\n    capabilities,\n    stream(req) {\n      return streamFromVercel(model, name, capabilities, req, runtime);\n    },\n    async generate(req) {\n      return generateFromVercel(model, name, capabilities, req, runtime);\n    },\n  };\n}\n\nasync function* streamFromVercel(\n  model: LanguageModelLike,\n  providerName: string,\n  capabilities: ProviderCapabilities,\n  req: ProviderRequest,\n  overrides: VercelRuntimeOverrides | undefined,\n): AsyncIterable<ProviderEvent> {\n  const sdk = await loadRuntime(overrides);\n  const callArgs = buildCallArgs(model, applyRequestPreflight(req, capabilities));\n  let stream: AsyncIterable<AISDKChunk>;\n  try {\n    const result = sdk.streamText(callArgs);\n    stream = result.fullStream;\n  } catch (cause) {\n    throw new ProviderHttpError({\n      providerName,\n      status: statusFromCause(cause),\n      message: 'streamText() failed before yielding any chunks',\n      cause,\n    });\n  }\n\n  yield {\n    type: 'stream-start',\n    metadata: {\n      providerName,\n      modelId: model.modelId,\n    },\n  };\n\n  let finalUsage: Usage | undefined;\n  let finishReason: FinishReason = 'stop';\n\n  for await (const chunk of stream) {\n    if (req.signal?.aborted) {\n      // PS-12: an aborted stream must report 'aborted', not the initial 'stop'\n      // — mirrors the openai-shaped and ollama adapters.\n      finishReason = 'aborted';\n      break;\n    }\n    switch (chunk.type) {\n      case 'text-delta': {\n        const delta = pickString(chunk.textDelta) ?? pickString(chunk.text) ?? '';\n        if (delta.length > 0) {\n          yield { type: 'text-delta', delta };\n        }\n        break;\n      }\n      case 'reasoning':\n      case 'reasoning-delta': {\n        const delta =\n          pickString(chunk.textDelta) ?? pickString(chunk.delta) ?? pickString(chunk.text) ?? '';\n        if (delta.length > 0) {\n          yield { type: 'reasoning-delta', delta };\n        }\n        break;\n      }\n      // PS-6 dual-shape: AI SDK v4 streams `tool-call-streaming-start` /\n      // `tool-call-delta` keyed by `toolCallId`/`argsTextDelta`; v7 streams\n      // `tool-input-start` / `tool-input-delta` keyed by `id`/`delta`.\n      case 'tool-call-streaming-start':\n      case 'tool-input-start': {\n        const toolCallId = pickString(chunk.toolCallId) ?? pickString(chunk.id);\n        const toolName = pickString(chunk.toolName);\n        if (toolCallId !== undefined && toolName !== undefined) {\n          yield {\n            type: 'tool-call-start',\n            toolCallId,\n            toolName,\n          };\n        }\n        break;\n      }\n      case 'tool-call-delta':\n      case 'tool-input-delta': {\n        const toolCallId = pickString(chunk.toolCallId) ?? pickString(chunk.id);\n        const argsDelta =\n          pickString(chunk.argsTextDelta) ??\n          pickString(chunk.delta) ??\n          pickString(chunk.inputTextDelta);\n        if (toolCallId !== undefined && argsDelta !== undefined && argsDelta.length > 0) {\n          yield {\n            type: 'tool-call-input-delta',\n            toolCallId,\n            argsDelta,\n          };\n        }\n        break;\n      }\n      case 'tool-call': {\n        const toolCallId = pickString(chunk.toolCallId) ?? pickString(chunk.id);\n        if (toolCallId !== undefined) {\n          yield {\n            type: 'tool-call-end',\n            toolCallId,\n            // v4 carries `args`; v7 carries `input`.\n            finalArgs: chunk.args ?? chunk.input,\n          };\n        }\n        break;\n      }\n      case 'finish': {\n        finishReason = mapFinishReason(pickString(chunk.finishReason));\n        // v4 carries `usage`; v7 carries `totalUsage` (zeroing the v4\n        // read nulled cost tracking on streaming).\n        finalUsage = mapUsage(chunk.totalUsage ?? chunk.usage);\n        break;\n      }\n      case 'error': {\n        const errorField = chunk.error;\n        const message =\n          typeof errorField === 'string'\n            ? errorField\n            : typeof errorField === 'object' && errorField !== null\n              ? (pickString((errorField as { message?: unknown }).message) ?? 'unknown error')\n              : 'unknown error';\n        yield {\n          type: 'error',\n          error: { kind: 'unknown', message },\n        };\n        break;\n      }\n      default:\n        // Unknown chunk types are forward-compatible no-ops; we keep\n        // streaming so additive AI SDK upgrades do not break callers.\n        break;\n    }\n  }\n\n  yield {\n    type: 'finish',\n    finishReason,\n    usage: finalUsage ?? { promptTokens: 0, completionTokens: 0, totalTokens: 0 },\n  };\n}\n\nasync function generateFromVercel(\n  model: LanguageModelLike,\n  providerName: string,\n  capabilities: ProviderCapabilities,\n  req: ProviderRequest,\n  overrides: VercelRuntimeOverrides | undefined,\n): Promise<ProviderResponse> {\n  const sdk = await loadRuntime(overrides);\n  const callArgs = buildCallArgs(model, applyRequestPreflight(req, capabilities));\n  let result: Awaited<ReturnType<VercelRuntimeOverrides['generateText']>>;\n  try {\n    result = await sdk.generateText(callArgs);\n  } catch (cause) {\n    throw new ProviderHttpError({\n      providerName,\n      status: statusFromCause(cause),\n      message: 'generateText() rejected',\n      cause,\n    });\n  }\n  const usage = mapUsage(result.usage) ?? {\n    promptTokens: 0,\n    completionTokens: 0,\n    totalTokens: 0,\n  };\n  const finishReason = mapFinishReason(result.finishReason);\n  const response: ProviderResponse = {\n    usage,\n    finishReason,\n    ...(result.text !== undefined ? { text: result.text } : {}),\n    ...(result.toolCalls !== undefined\n      ? { toolCalls: result.toolCalls.map(normalizeToolCall) }\n      : {}),\n    ...(result.providerMetadata !== undefined ? { providerMetadata: result.providerMetadata } : {}),\n  };\n  return response;\n}\n\nfunction applyRequestPreflight(\n  req: ProviderRequest,\n  capabilities: ProviderCapabilities,\n): ProviderRequest {\n  const retention = resolveReasoningRetention({\n    ...(req.reasoningRetention !== undefined ? { requested: req.reasoningRetention } : {}),\n    ...(capabilities.reasoningContract !== undefined\n      ? { contract: capabilities.reasoningContract }\n      : {}),\n  });\n  if (retention === 'pass-through-all') return req;\n  const filtered = applyReasoningPolicy({ messages: req.messages, retention });\n  if (filtered === req.messages) return req;\n  return { ...req, messages: filtered };\n}\n\nfunction buildCallArgs(model: LanguageModelLike, req: ProviderRequest) {\n  return {\n    model,\n    messages: req.messages,\n    ...(req.systemMessage !== undefined ? { system: req.systemMessage } : {}),\n    ...(req.tools !== undefined ? { tools: req.tools } : {}),\n    ...(req.toolChoice !== undefined ? { toolChoice: req.toolChoice } : {}),\n    ...(req.temperature !== undefined ? { temperature: req.temperature } : {}),\n    // v4 reads `maxTokens`; v7 renamed it `maxOutputTokens` — send both\n    // so the cap is honoured against either peer (PS-6).\n    ...(req.maxTokens !== undefined\n      ? { maxTokens: req.maxTokens, maxOutputTokens: req.maxTokens }\n      : {}),\n    ...(req.signal !== undefined ? { abortSignal: req.signal } : {}),\n    ...(req.providerOptions !== undefined ? { providerOptions: req.providerOptions } : {}),\n  } as const;\n}\n\nfunction pickString(value: unknown): string | undefined {\n  return typeof value === 'string' ? value : undefined;\n}\n\n/**\n * Normalize a generate() tool call across peers: AI SDK v4 carries\n * `args`, v7 carries `input` (PS-6). The framework shape is `args`.\n */\nfunction normalizeToolCall(tc: unknown): { toolCallId: string; toolName: string; args: unknown } {\n  const t = tc as {\n    toolCallId?: unknown;\n    id?: unknown;\n    toolName?: unknown;\n    args?: unknown;\n    input?: unknown;\n  };\n  return {\n    toolCallId: pickString(t.toolCallId) ?? pickString(t.id) ?? '',\n    toolName: pickString(t.toolName) ?? '',\n    args: t.args ?? t.input,\n  };\n}\n\n/**\n * Lift a real HTTP status from a rejected AI SDK call (PS-2). The SDK's\n * `APICallError` carries a numeric `statusCode`; surfacing it lets\n * `withRetry` / `withFallback` see a genuine 429 / 5xx instead of the\n * `status: 0` network-error placeholder. Returns `0` when no status is\n * present (a true transport-level failure or an abort) — `0` is itself\n * retryable / fallback-eligible by default, while an abort is excluded by\n * the predicates via the wrapped `cause`.\n */\nfunction statusFromCause(cause: unknown): number {\n  if (cause !== null && typeof cause === 'object') {\n    const c = cause as { statusCode?: unknown; status?: unknown };\n    if (typeof c.statusCode === 'number' && Number.isFinite(c.statusCode)) return c.statusCode;\n    if (typeof c.status === 'number' && Number.isFinite(c.status)) return c.status;\n  }\n  return 0;\n}\n\nfunction mapFinishReason(value: string | undefined): FinishReason {\n  switch (value) {\n    case 'stop':\n    case 'length':\n    case 'tool-calls':\n    case 'content-filter':\n    case 'error':\n      return value;\n    case 'aborted':\n    case 'cancelled':\n      return 'aborted';\n    default:\n      return 'stop';\n  }\n}\n\nfunction mapUsage(input: unknown): Usage | undefined {\n  if (input === undefined || input === null || typeof input !== 'object') return undefined;\n  const u = input as {\n    promptTokens?: number;\n    completionTokens?: number;\n    inputTokens?: number;\n    outputTokens?: number;\n    reasoningTokens?: number;\n    totalTokens?: number;\n  };\n  const promptTokens = u.promptTokens ?? u.inputTokens ?? 0;\n  const completionTokens = u.completionTokens ?? u.outputTokens ?? 0;\n  const totalTokens = u.totalTokens ?? promptTokens + completionTokens;\n  const usage: Usage = {\n    promptTokens,\n    completionTokens,\n    totalTokens,\n    ...(u.reasoningTokens !== undefined ? { reasoningTokens: u.reasoningTokens } : {}),\n  };\n  return usage;\n}\n\nlet cachedRuntime: VercelRuntimeOverrides | null = null;\n\nasync function loadRuntime(\n  overrides: VercelRuntimeOverrides | undefined,\n): Promise<VercelRuntimeOverrides> {\n  if (overrides !== undefined) return overrides;\n  if (cachedRuntime !== null) return cachedRuntime;\n  let mod: { streamText?: unknown; generateText?: unknown };\n  try {\n    mod = (await import('ai')) as { streamText?: unknown; generateText?: unknown };\n  } catch (cause) {\n    throw new ProviderStreamParseError(\n      'vercel',\n      \"Failed to import the 'ai' peer dependency. Install it with `pnpm add ai` or pass a runtimeOverrides value.\",\n      cause,\n    );\n  }\n  if (typeof mod.streamText !== 'function' || typeof mod.generateText !== 'function') {\n    throw new ProviderStreamParseError(\n      'vercel',\n      \"The installed 'ai' package does not expose streamText / generateText functions.\",\n    );\n  }\n  cachedRuntime = {\n    streamText: mod.streamText as VercelRuntimeOverrides['streamText'],\n    generateText: mod.generateText as VercelRuntimeOverrides['generateText'],\n  };\n  return cachedRuntime;\n}\n\n/**\n * Test-only hook that resets the cached AI SDK runtime. Provider tests\n * that mutate the cache (e.g. by injecting a mock then verifying the\n * default loader runs) call this between scenarios.\n *\n * @internal\n */\nexport function __resetVercelRuntimeCache(): void {\n  cachedRuntime = null;\n}\n"],"mappings":"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"}

package/dist/counters/anthropic.d.ts

@@ -0,0 +1,36 @@
+import { Message, TokenCounter } from "@graphorin/core";
+
+//#region src/counters/anthropic.d.ts
+
+/**
+ * Options for {@link AnthropicAPICounter}.
+ *
+ * @stable
+ */
+interface AnthropicAPICounterOptions {
+  readonly modelId: string;
+  readonly apiKey?: string;
+  readonly baseUrl?: string;
+  readonly fetchImpl?: typeof fetch;
+  /** Identifier carried on the produced counter. */
+  readonly id?: string;
+}
+/**
+ * Counter that talks to `POST /v1/messages/count_tokens` when an API
+ * key is configured. Without an API key, the counter delegates to
+ * `JsTiktokenCounter('cl100k_base')` — the closest publicly-available
+ * proxy for Anthropic's tokenizer.
+ *
+ * @stable
+ */
+declare class AnthropicAPICounter implements TokenCounter {
+  #private;
+  readonly id: string;
+  readonly version: string;
+  constructor(options: AnthropicAPICounterOptions);
+  count(messages: ReadonlyArray<Message>): Promise<number>;
+  countText(text: string): Promise<number>;
+}
+//#endregion
+export { AnthropicAPICounter, AnthropicAPICounterOptions };
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/counters/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","names":[],"sources":["../../src/counters/anthropic.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAoBiB,0BAAA;;;;8BAIa;;;;;;;;;;;;cAajB,mBAAA,YAA+B;;;;uBASrB;kBAUC,cAAc,WAAW;2BAqBhB"}

package/dist/counters/anthropic.js

@@ -0,0 +1,63 @@
+import { stripTrailingSlashes } from "../internal/url-utils.js";
+import { JsTiktokenCounter } from "./js-tiktoken.js";
+
+//#region src/counters/anthropic.ts
+/**
+* Counter that talks to `POST /v1/messages/count_tokens` when an API
+* key is configured. Without an API key, the counter delegates to
+* `JsTiktokenCounter('cl100k_base')` — the closest publicly-available
+* proxy for Anthropic's tokenizer.
+*
+* @stable
+*/
+var AnthropicAPICounter = class {
+	id;
+	version;
+	#modelId;
+	#apiKey;
+	#baseUrl;
+	#fetchImpl;
+	#fallback;
+	constructor(options) {
+		this.#modelId = options.modelId;
+		if (options.apiKey !== void 0) this.#apiKey = options.apiKey;
+		this.#baseUrl = stripTrailingSlashes(options.baseUrl ?? "https://api.anthropic.com");
+		this.#fetchImpl = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
+		this.#fallback = new JsTiktokenCounter({
+			encoding: "cl100k_base",
+			modelId: options.modelId
+		});
+		this.id = options.id ?? `anthropic-native@${options.modelId}`;
+		this.version = `anthropic-native-${options.modelId}-v1`;
+	}
+	async count(messages) {
+		if (this.#apiKey === void 0) return this.#fallback.count(messages);
+		try {
+			const resp = await this.#fetchImpl(`${this.#baseUrl}/v1/messages/count_tokens`, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					"x-api-key": this.#apiKey,
+					"anthropic-version": "2023-06-01"
+				},
+				body: JSON.stringify({
+					model: this.#modelId,
+					messages
+				})
+			});
+			if (!resp.ok) return this.#fallback.count(messages);
+			const json = await resp.json();
+			if (typeof json.input_tokens === "number") return json.input_tokens;
+			return this.#fallback.count(messages);
+		} catch {
+			return this.#fallback.count(messages);
+		}
+	}
+	async countText(text) {
+		return this.#fallback.countText(text);
+	}
+};
+
+//#endregion
+export { AnthropicAPICounter };
+//# sourceMappingURL=anthropic.js.map

package/dist/counters/anthropic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.js","names":["#modelId","#apiKey","#baseUrl","#fetchImpl","#fallback"],"sources":["../../src/counters/anthropic.ts"],"sourcesContent":["/**\n * `AnthropicAPICounter` — uses Anthropic's native count-tokens\n * endpoint when an API key is configured, otherwise falls back to\n * `JsTiktokenCounter`. The native call is opt-in: the user supplies\n * an explicit `apiKey`. The framework never makes the call without\n * one.\n *\n * @packageDocumentation\n */\n\nimport type { Message, TokenCounter } from '@graphorin/core';\n\nimport { stripTrailingSlashes } from '../internal/url-utils.js';\nimport { JsTiktokenCounter } from './js-tiktoken.js';\n\n/**\n * Options for {@link AnthropicAPICounter}.\n *\n * @stable\n */\nexport interface AnthropicAPICounterOptions {\n  readonly modelId: string;\n  readonly apiKey?: string;\n  readonly baseUrl?: string;\n  readonly fetchImpl?: typeof fetch;\n  /** Identifier carried on the produced counter. */\n  readonly id?: string;\n}\n\n/**\n * Counter that talks to `POST /v1/messages/count_tokens` when an API\n * key is configured. Without an API key, the counter delegates to\n * `JsTiktokenCounter('cl100k_base')` — the closest publicly-available\n * proxy for Anthropic's tokenizer.\n *\n * @stable\n */\nexport class AnthropicAPICounter implements TokenCounter {\n  readonly id: string;\n  readonly version: string;\n  readonly #modelId: string;\n  readonly #apiKey?: string;\n  readonly #baseUrl: string;\n  readonly #fetchImpl: typeof fetch;\n  readonly #fallback: JsTiktokenCounter;\n\n  constructor(options: AnthropicAPICounterOptions) {\n    this.#modelId = options.modelId;\n    if (options.apiKey !== undefined) this.#apiKey = options.apiKey;\n    this.#baseUrl = stripTrailingSlashes(options.baseUrl ?? 'https://api.anthropic.com');\n    this.#fetchImpl = options.fetchImpl ?? globalThis.fetch.bind(globalThis);\n    this.#fallback = new JsTiktokenCounter({ encoding: 'cl100k_base', modelId: options.modelId });\n    this.id = options.id ?? `anthropic-native@${options.modelId}`;\n    this.version = `anthropic-native-${options.modelId}-v1`;\n  }\n\n  async count(messages: ReadonlyArray<Message>): Promise<number> {\n    if (this.#apiKey === undefined) return this.#fallback.count(messages);\n    try {\n      const resp = await this.#fetchImpl(`${this.#baseUrl}/v1/messages/count_tokens`, {\n        method: 'POST',\n        headers: {\n          'content-type': 'application/json',\n          'x-api-key': this.#apiKey,\n          'anthropic-version': '2023-06-01',\n        },\n        body: JSON.stringify({ model: this.#modelId, messages }),\n      });\n      if (!resp.ok) return this.#fallback.count(messages);\n      const json = (await resp.json()) as { input_tokens?: number };\n      if (typeof json.input_tokens === 'number') return json.input_tokens;\n      return this.#fallback.count(messages);\n    } catch {\n      return this.#fallback.count(messages);\n    }\n  }\n\n  async countText(text: string): Promise<number> {\n    return this.#fallback.countText(text);\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAqCA,IAAa,sBAAb,MAAyD;CACvD,AAAS;CACT,AAAS;CACT,CAASA;CACT,CAASC;CACT,CAASC;CACT,CAASC;CACT,CAASC;CAET,YAAY,SAAqC;AAC/C,QAAKJ,UAAW,QAAQ;AACxB,MAAI,QAAQ,WAAW,OAAW,OAAKC,SAAU,QAAQ;AACzD,QAAKC,UAAW,qBAAqB,QAAQ,WAAW,4BAA4B;AACpF,QAAKC,YAAa,QAAQ,aAAa,WAAW,MAAM,KAAK,WAAW;AACxE,QAAKC,WAAY,IAAI,kBAAkB;GAAE,UAAU;GAAe,SAAS,QAAQ;GAAS,CAAC;AAC7F,OAAK,KAAK,QAAQ,MAAM,oBAAoB,QAAQ;AACpD,OAAK,UAAU,oBAAoB,QAAQ,QAAQ;;CAGrD,MAAM,MAAM,UAAmD;AAC7D,MAAI,MAAKH,WAAY,OAAW,QAAO,MAAKG,SAAU,MAAM,SAAS;AACrE,MAAI;GACF,MAAM,OAAO,MAAM,MAAKD,UAAW,GAAG,MAAKD,QAAS,4BAA4B;IAC9E,QAAQ;IACR,SAAS;KACP,gBAAgB;KAChB,aAAa,MAAKD;KAClB,qBAAqB;KACtB;IACD,MAAM,KAAK,UAAU;KAAE,OAAO,MAAKD;KAAU;KAAU,CAAC;IACzD,CAAC;AACF,OAAI,CAAC,KAAK,GAAI,QAAO,MAAKI,SAAU,MAAM,SAAS;GACnD,MAAM,OAAQ,MAAM,KAAK,MAAM;AAC/B,OAAI,OAAO,KAAK,iBAAiB,SAAU,QAAO,KAAK;AACvD,UAAO,MAAKA,SAAU,MAAM,SAAS;UAC/B;AACN,UAAO,MAAKA,SAAU,MAAM,SAAS;;;CAIzC,MAAM,UAAU,MAA+B;AAC7C,SAAO,MAAKA,SAAU,UAAU,KAAK"}