@deepstrike/sdk 0.2.60 → 0.2.61

package/dist/os/public.d.ts

@@ -15,5 +15,5 @@ export { ReplayProvider } from "../runtime/replay-provider.js";
 export type { ReplayProviderOpts } from "../runtime/replay-provider.js";
 export { extractRecordedMessages } from "../runtime/replay-fixture.js";
 export { ProviderReplayValidationError, DEGRADED_REASONING_PLACEHOLDER } from "../providers/replay-validator.js";
-export { assessProviderReplayability, peekProviderReplay, seedProviderReplayFromEvents, isReplayCompatibleWithProvider, } from "../runtime/provider-replay.js";
+export { ProviderReplayProtocolMismatchError, assessProviderReplayability, peekProviderReplay, seedProviderReplayFromEvents, isReplayCompatibleWithProvider, } from "../runtime/provider-replay.js";
 export type { ReplayabilityAssessment } from "../types.js";

package/dist/os/public.js

@@ -12,4 +12,4 @@ export { PermissionManager, PermissionMode } from "../safety/permissions.js";
 export { ReplayProvider } from "../runtime/replay-provider.js";
 export { extractRecordedMessages } from "../runtime/replay-fixture.js";
 export { ProviderReplayValidationError, DEGRADED_REASONING_PLACEHOLDER } from "../providers/replay-validator.js";
-export { assessProviderReplayability, peekProviderReplay, seedProviderReplayFromEvents, isReplayCompatibleWithProvider, } from "../runtime/provider-replay.js";
+export { ProviderReplayProtocolMismatchError, assessProviderReplayability, peekProviderReplay, seedProviderReplayFromEvents, isReplayCompatibleWithProvider, } from "../runtime/provider-replay.js";

package/dist/providers/anthropic-adapter.d.ts

@@ -1,6 +1,15 @@
 import type { Message, ProviderReplay, ProviderUsage, ToolCall } from "../types.js";
 import type { CanonicalAdapterInput } from "./content-normalization.js";
 import { type AdapterDecodeInput, type AdapterOutput, type AdapterStreamInput, type CanonicalStopReason, type ProtocolAdapter } from "./protocol-adapter.js";
+export declare const ANTHROPIC_TEXTUAL_TOOL_CALL_START_MARKER = "<\uFF5C\uFF5CDSML\uFF5C\uFF5Ctool_calls>";
+type TextualToolCallPolicy = "off" | "reject";
+interface TextualToolCallGuardState {
+    policy: TextualToolCallPolicy;
+    mode: "passthrough" | "candidate";
+    tail: string;
+    capturedLength: number;
+    sawNativeToolCall: boolean;
+}
 export interface AnthropicRequestPlan {
     transport: "stable" | "beta";
     params: Record<string, unknown>;
@@ -25,17 +34,19 @@ export interface AnthropicStreamState {
     }>;
     readonly nativeBlocks: Record<number, Record<string, unknown>>;
     readonly finalToolCalls: ToolCall[];
+    readonly textualToolCallGuard: TextualToolCallGuardState;
     finalText: string;
     uncachedInput: number;
     cacheReadTokens: number;
     cacheCreationTokens: number;
+    cacheTelemetryMeasured: boolean;
     outputTokens: number;
 }
 export declare class AnthropicMessagesAdapter implements ProtocolAdapter<AnthropicRequestPlan, Record<string, any>, AnthropicStreamChunk, AnthropicStreamState, undefined> {
     readonly protocol: "anthropic-messages";
     readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
     buildRequest(input: CanonicalAdapterInput): AnthropicRequestPlan;
-    decodeComplete(raw: Record<string, any>, _input: AdapterDecodeInput): {
+    decodeComplete(raw: Record<string, any>, decodeInput: AdapterDecodeInput): {
         message: Message;
         replay?: ProviderReplay;
     };
@@ -45,3 +56,4 @@ export declare class AnthropicMessagesAdapter implements ProtocolAdapter<Anthrop
     normalizeUsage(raw: unknown): ProviderUsage | undefined;
     normalizeStopReason(raw: string | undefined): CanonicalStopReason | undefined;
 }
+export {};

package/dist/providers/anthropic-adapter.js

@@ -1,6 +1,9 @@
 import { normalizeToolCall } from "./base.js";
 import { ProtocolResponseError, } from "./protocol-adapter.js";
 import { ANTHROPIC_PROTOCOL_CAPABILITIES } from "./protocol-capabilities.js";
+import { endpointProfiles } from "./endpoints.js";
+export const ANTHROPIC_TEXTUAL_TOOL_CALL_START_MARKER = "<｜｜DSML｜｜tool_calls>";
+const TEXTUAL_TOOL_CALL_CAPTURE_LIMIT = 64 * 1024;
 const CACHE_BREAKPOINT_STRATEGIES = new Set([
     "default", "tools-only", "system-only", "frozen-prefix", "none",
 ]);
@@ -13,10 +16,63 @@ function cacheStrategy(extensions) {
 function extensionsForWire(extensions) {
     const blocked = new Set([
         "model", "messages", "system", "tools", "max_tokens", "stream",
-        "__deepstrikeThinkingEnabled", "degradeMissingReasoningReplay",
+        "__deepstrikeThinkingEnabled", "degradeMissingReasoningReplay", "textualToolCallPolicy",
     ]);
     return Object.fromEntries(Object.entries(extensions).filter(([key]) => !blocked.has(key)));
 }
+function textualToolCallPolicy(input) {
+    if (input.tools.length === 0)
+        return "off";
+    const explicit = input.extensions.textualToolCallPolicy;
+    if (explicit === "off" || explicit === "reject")
+        return explicit;
+    const official = endpointProfiles["anthropic.messages"];
+    const endpoint = input.resolved.endpoint;
+    const isOfficial = input.resolved.identity.endpointId === official.id
+        && (!endpoint || endpoint.baseURL === official.baseURL);
+    return isOfficial ? "off" : "reject";
+}
+function textualToolCallError() {
+    return new ProtocolResponseError("anthropic-messages", "Provider emitted a tool call as text instead of a native tool block", { providerCode: "textual_tool_call", retryable: true });
+}
+function hasTextualToolCall(text, input) {
+    return textualToolCallPolicy(input) === "reject"
+        && text.includes(ANTHROPIC_TEXTUAL_TOOL_CALL_START_MARKER);
+}
+function markerTailLength(text) {
+    const max = Math.min(text.length, ANTHROPIC_TEXTUAL_TOOL_CALL_START_MARKER.length - 1);
+    for (let length = max; length > 0; length -= 1) {
+        if (text.endsWith(ANTHROPIC_TEXTUAL_TOOL_CALL_START_MARKER.slice(0, length)))
+            return length;
+    }
+    return 0;
+}
+function utf8Length(text) {
+    return Buffer.byteLength(text, "utf8");
+}
+function guardTextDelta(text, guard) {
+    if (guard.policy === "off")
+        return text;
+    if (guard.mode === "candidate") {
+        guard.capturedLength += utf8Length(text);
+        if (guard.capturedLength > TEXTUAL_TOOL_CALL_CAPTURE_LIMIT)
+            throw textualToolCallError();
+        return "";
+    }
+    const combined = guard.tail + text;
+    const markerIndex = combined.indexOf(ANTHROPIC_TEXTUAL_TOOL_CALL_START_MARKER);
+    if (markerIndex >= 0) {
+        guard.mode = "candidate";
+        guard.tail = "";
+        guard.capturedLength = utf8Length(combined.slice(markerIndex));
+        if (guard.capturedLength > TEXTUAL_TOOL_CALL_CAPTURE_LIMIT)
+            throw textualToolCallError();
+        return combined.slice(0, markerIndex);
+    }
+    const tailLength = markerTailLength(combined);
+    guard.tail = tailLength > 0 ? combined.slice(-tailLength) : "";
+    return tailLength > 0 ? combined.slice(0, -tailLength) : combined;
+}
 function systemBlocks(context, strategy) {
     if (!context.systemStable && !context.systemKnowledge) {
         return context.systemText || undefined;
@@ -206,22 +262,12 @@ function assertCacheBudget(params) {
         throw new Error(`Anthropic cache_control budget exceeded: ${count} > 4`);
     }
 }
-function estimateCacheRead(cacheRead, slots) {
-    if (cacheRead <= 0)
-        return undefined;
-    const keys = ["system", "tools", "messages"].filter(key => slots[key]);
-    if (!keys.length)
-        return undefined;
-    const share = Math.floor(cacheRead / keys.length);
-    const remainder = cacheRead - share * keys.length;
-    return Object.fromEntries(keys.map((key, index) => [key, share + (index === 0 ? remainder : 0)]));
-}
 function numeric(raw, field) {
     const value = raw[field];
     if (value === undefined || value === null)
         return undefined;
-    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-        throw new ProtocolResponseError("anthropic-messages", `usage.${field} is invalid`);
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new ProtocolResponseError("anthropic-messages", `usage.${field} must be a non-negative safe integer`);
     }
     return value;
 }
@@ -265,7 +311,7 @@ export class AnthropicMessagesAdapter {
             cacheSlots: countSlots(system, tools, messages),
         };
     }
-    decodeComplete(raw, _input) {
+    decodeComplete(raw, decodeInput) {
         let content = "";
         const toolCalls = [];
         for (const block of raw.content ?? []) {
@@ -277,6 +323,8 @@ export class AnthropicMessagesAdapter {
                     toolCalls.push(call);
             }
         }
+        if (hasTextualToolCall(content, decodeInput.input))
+            throw textualToolCallError();
         const usage = this.normalizeUsage(raw.usage);
         const blocks = raw.content;
         return {
@@ -297,10 +345,18 @@ export class AnthropicMessagesAdapter {
             toolBlocks: {},
             nativeBlocks: {},
             finalToolCalls: [],
+            textualToolCallGuard: {
+                policy: textualToolCallPolicy(input.input),
+                mode: "passthrough",
+                tail: "",
+                capturedLength: 0,
+                sawNativeToolCall: false,
+            },
             finalText: "",
             uncachedInput: 0,
             cacheReadTokens: 0,
             cacheCreationTokens: 0,
+            cacheTelemetryMeasured: false,
             outputTokens: 0,
         };
     }
@@ -309,20 +365,26 @@ export class AnthropicMessagesAdapter {
         if (chunk.type === "message_start" || chunk.type === "message_delta") {
             const raw = chunk.usage ?? chunk.message?.usage;
             if (raw) {
+                if (Object.prototype.hasOwnProperty.call(raw, "cache_read_input_tokens")
+                    || Object.prototype.hasOwnProperty.call(raw, "cache_creation_input_tokens")) {
+                    state.cacheTelemetryMeasured = true;
+                }
                 state.uncachedInput = Math.max(state.uncachedInput, numeric(raw, "input_tokens") ?? 0);
                 state.cacheReadTokens = Math.max(state.cacheReadTokens, numeric(raw, "cache_read_input_tokens") ?? 0);
                 state.cacheCreationTokens = Math.max(state.cacheCreationTokens, numeric(raw, "cache_creation_input_tokens") ?? 0);
                 state.outputTokens = Math.max(state.outputTokens, numeric(raw, "output_tokens") ?? 0);
                 const inputTokens = state.uncachedInput + state.cacheReadTokens + state.cacheCreationTokens;
+                const cacheTelemetryStatus = state.cacheTelemetryMeasured ? "measured" : "unavailable";
                 const providerUsage = {
                     inputTokens,
                     outputTokens: state.outputTokens,
                     ...(state.cacheReadTokens ? { cacheReadInputTokens: state.cacheReadTokens } : {}),
                     ...(state.cacheCreationTokens ? { cacheCreationInputTokens: state.cacheCreationTokens } : {}),
+                    cacheTelemetryStatus,
+                    ...(state.cacheTelemetryMeasured ? { cacheTelemetrySource: "anthropic_usage" } : {}),
                 };
                 const rawStopReason = chunk.delta?.stop_reason;
                 const stopReason = this.normalizeStopReason(rawStopReason);
-                const bySlot = estimateCacheRead(state.cacheReadTokens, state.cacheSlots);
                 events.push({
                     type: "usage",
                     totalTokens: inputTokens + state.outputTokens,
@@ -330,7 +392,8 @@ export class AnthropicMessagesAdapter {
                     outputTokens: state.outputTokens,
                     cacheReadInputTokens: state.cacheReadTokens,
                     cacheCreationInputTokens: state.cacheCreationTokens,
-                    ...(bySlot ? { cacheReadInputTokensBySlot: bySlot } : {}),
+                    cacheTelemetryStatus,
+                    ...(state.cacheTelemetryMeasured ? { cacheTelemetrySource: "anthropic_usage" } : {}),
                     ...(stopReason ? { stopReason } : {}),
                     ...(rawStopReason ? { rawStopReason } : {}),
                     providerUsage,
@@ -339,7 +402,15 @@ export class AnthropicMessagesAdapter {
         }
         else if (chunk.type === "content_block_start") {
             state.nativeBlocks[chunk.index] = { ...chunk.content_block };
-            if (chunk.content_block.type === "tool_use") {
+            if (chunk.content_block.type === "text") {
+                const initialText = String(chunk.content_block.text ?? "");
+                const visibleText = guardTextDelta(initialText, state.textualToolCallGuard);
+                state.finalText += visibleText;
+                if (visibleText)
+                    events.push({ type: "text_delta", delta: visibleText });
+            }
+            else if (chunk.content_block.type === "tool_use") {
+                state.textualToolCallGuard.sawNativeToolCall = true;
                 state.toolBlocks[chunk.index] = {
                     id: chunk.content_block.id,
                     name: chunk.content_block.name,
@@ -350,12 +421,14 @@ export class AnthropicMessagesAdapter {
         else if (chunk.type === "content_block_delta") {
             const delta = chunk.delta;
             if (delta.type === "text_delta") {
-                state.finalText += delta.text;
+                const visibleText = guardTextDelta(delta.text, state.textualToolCallGuard);
+                state.finalText += visibleText;
                 state.nativeBlocks[chunk.index] = {
                     ...state.nativeBlocks[chunk.index],
                     text: String(state.nativeBlocks[chunk.index]?.text ?? "") + delta.text,
                 };
-                events.push({ type: "text_delta", delta: delta.text });
+                if (visibleText)
+                    events.push({ type: "text_delta", delta: visibleText });
             }
             else if (delta.type === "thinking_delta") {
                 state.nativeBlocks[chunk.index] = {
@@ -400,12 +473,21 @@ export class AnthropicMessagesAdapter {
         return { events };
     }
     finishStream(state) {
+        if (state.textualToolCallGuard.mode === "candidate")
+            throw textualToolCallError();
+        const events = [];
+        if (state.textualToolCallGuard.tail) {
+            const tail = state.textualToolCallGuard.tail;
+            state.textualToolCallGuard.tail = "";
+            state.finalText += tail;
+            events.push({ type: "text_delta", delta: tail });
+        }
         const blocks = Object.keys(state.nativeBlocks)
             .map(Number)
             .sort((left, right) => left - right)
             .map(index => state.nativeBlocks[index]);
         return {
-            events: [],
+            events,
             ...(blocks.length ? { replay: { protocol: "anthropic-messages", native_blocks: blocks } } : {}),
         };
     }
@@ -428,6 +510,10 @@ export class AnthropicMessagesAdapter {
             outputTokens: output ?? 0,
             ...(cacheRead ? { cacheReadInputTokens: cacheRead } : {}),
             ...(cacheCreation ? { cacheCreationInputTokens: cacheCreation } : {}),
+            ...(Object.prototype.hasOwnProperty.call(record, "cache_read_input_tokens")
+                || Object.prototype.hasOwnProperty.call(record, "cache_creation_input_tokens")
+                ? { cacheTelemetryStatus: "measured", cacheTelemetrySource: "anthropic_usage" }
+                : { cacheTelemetryStatus: "unavailable" }),
         };
     }
     normalizeStopReason(raw) {

package/dist/providers/anthropic.d.ts

@@ -22,6 +22,7 @@ export declare class AnthropicProvider implements LLMProvider {
     private readonly nativeAssistantBlocks;
     private readonly resolvedRuntimePolicy;
     private readonly directNativeTokenCounting;
+    private readonly defaultTextualToolCallPolicy;
     private resolvedRuntime?;
     constructor(config: AnthropicProviderConfig);
     runtimePolicy(): RuntimePolicy;

package/dist/providers/anthropic.js

@@ -16,6 +16,7 @@ export class AnthropicProvider {
     nativeAssistantBlocks = new Map();
     resolvedRuntimePolicy;
     directNativeTokenCounting;
+    defaultTextualToolCallPolicy;
     resolvedRuntime;
     constructor(config) {
         if (!config || typeof config !== "object" || Array.isArray(config)) {
@@ -40,8 +41,11 @@ export class AnthropicProvider {
         this.maxRetries = c.retry?.maxRetries ?? 3;
         this.baseDelay = c.retry?.baseDelay ?? 1000;
         this.resolvedRuntimePolicy = c.runtimePolicy ?? {};
-        this.directNativeTokenCounting = c.baseURL === undefined
-            || c.baseURL === endpointProfiles["anthropic.messages"].baseURL;
+        const configuredBaseURL = c.baseURL?.replace(/\/+$/, "");
+        const officialBaseURL = endpointProfiles["anthropic.messages"].baseURL.replace(/\/+$/, "");
+        this.directNativeTokenCounting = configuredBaseURL === undefined
+            || configuredBaseURL === officialBaseURL;
+        this.defaultTextualToolCallPolicy = this.directNativeTokenCounting ? "off" : "reject";
     }
     runtimePolicy() {
         return this.resolvedRuntimePolicy;
@@ -107,7 +111,10 @@ export class AnthropicProvider {
             context,
             tools,
             resolved,
-            extensions,
+            extensions: {
+                textualToolCallPolicy: this.defaultTextualToolCallPolicy,
+                ...extensions,
+            },
             replayForMessage: message => this.peekProviderReplay(message),
         });
     }

package/dist/providers/base.d.ts

@@ -18,8 +18,8 @@ export declare const INTERNAL_EXTENSION_KEYS: readonly string[];
 export declare function omitExtensionKeys(extensions: Record<string, unknown> | undefined, keys: readonly string[]): Record<string, unknown>;
 /**
  * Cached-prompt-token count from an OpenAI-compatible usage object. Covers the
- * standard `prompt_tokens_details.cached_tokens` (OpenAI, Qwen, MiniMax, GLM,
- * Kimi) and DeepSeek's `prompt_cache_hit_tokens`. These caches bill reads only,
+ * Chat `prompt_tokens_details.cached_tokens`, Responses
+ * `input_tokens_details.cached_tokens`, and DeepSeek's `prompt_cache_hit_tokens`. These caches bill reads only,
  * so there is no separate cache-creation count. The figure is a subset of
  * `prompt_tokens` (the full prompt), surfaced for cost visibility — it must not
  * be subtracted from the input count the kernel uses for context accounting.

package/dist/providers/base.js

@@ -44,8 +44,8 @@ export function omitExtensionKeys(extensions, keys) {
 }
 /**
  * Cached-prompt-token count from an OpenAI-compatible usage object. Covers the
- * standard `prompt_tokens_details.cached_tokens` (OpenAI, Qwen, MiniMax, GLM,
- * Kimi) and DeepSeek's `prompt_cache_hit_tokens`. These caches bill reads only,
+ * Chat `prompt_tokens_details.cached_tokens`, Responses
+ * `input_tokens_details.cached_tokens`, and DeepSeek's `prompt_cache_hit_tokens`. These caches bill reads only,
  * so there is no separate cache-creation count. The figure is a subset of
  * `prompt_tokens` (the full prompt), surfaced for cost visibility — it must not
  * be subtracted from the input count the kernel uses for context accounting.
@@ -54,10 +54,12 @@ export function openAICachedPromptTokens(usage) {
     if (!usage || typeof usage !== "object")
         return 0;
     const u = usage;
-    const details = u.prompt_tokens_details;
-    const standard = typeof details?.cached_tokens === "number" ? details.cached_tokens : 0;
+    const promptDetails = u.prompt_tokens_details;
+    const inputDetails = u.input_tokens_details;
+    const standard = typeof promptDetails?.cached_tokens === "number" ? promptDetails.cached_tokens : 0;
+    const responses = typeof inputDetails?.cached_tokens === "number" ? inputDetails.cached_tokens : 0;
     const deepseek = typeof u.prompt_cache_hit_tokens === "number" ? u.prompt_cache_hit_tokens : 0;
-    return Math.max(standard, deepseek);
+    return Math.max(standard, responses, deepseek);
 }
 /**
  * Prompt-cache hit rate for one usage record: the fraction of the full prompt

package/dist/providers/catalog.js

@@ -1,5 +1,5 @@
 import { PROVIDER_REGISTRY, providerRegistryKey, supportsBearerCredential } from "./registry.js";
-import { endpointCapabilitiesFor, generationProtocol, modelRegistry, normalizeModelId, resolveEffectiveModelCapabilities, } from "./model-registry.js";
+import { defaultEndpointForProvider, endpointCapabilitiesFor, generationProtocol, modelRegistry, normalizeModelId, resolveEffectiveModelCapabilities, } from "./model-registry.js";
 import { endpointProfiles } from "./endpoints.js";
 import { resolveCredential, resolveCredentialSync, CredentialResolutionError, } from "./credentials.js";
 export function createProvider(options) {
@@ -38,7 +38,9 @@ async function resolveRuntimeDraftAsync(options) {
 }
 function resolveRuntimeDraftWithRegistration(options, parsedProviderId, initialRegistration) {
     const providerHint = options.provider ?? parsedProviderId;
-    const endpointId = (options.endpoint ?? initialRegistration?.defaultEndpointId ?? defaultEndpointForProvider(providerHint));
+    const endpointId = (options.endpoint
+        ?? initialRegistration?.defaultEndpointId
+        ?? (providerHint ? defaultEndpointForProvider(providerHint) : undefined));
     if (!endpointId) {
         throw new Error(`Unknown model profile: ${options.model}. Pass provider or endpoint for custom model names.`);
     }
@@ -85,7 +87,7 @@ function constructResolvedRuntime(draft, credential, options) {
         effectiveCapabilities: resolveEffectiveModelCapabilities({
             model: draft.registration.descriptor,
             protocol,
-            endpointCapabilities: endpointCapabilitiesFor(draft.endpointId, options.baseURL === undefined || options.endpoint !== undefined),
+            endpointCapabilities: endpointCapabilitiesFor(draft.endpointId, options.baseURL === undefined || options.endpoint !== undefined, options.baseURL === undefined),
         }),
         ...(draft.registration.recommendedRuntimePolicy ? { runtimePolicy: draft.registration.recommendedRuntimePolicy } : {}),
     };
@@ -132,20 +134,3 @@ function providerPrefix(model) {
 function providerIds() {
     return Array.from(new Set(Object.values(endpointProfiles).map(endpoint => endpoint.providerId)));
 }
-function defaultEndpointForProvider(providerId) {
-    if (!providerId)
-        return undefined;
-    const defaults = {
-        anthropic: "anthropic.messages",
-        openai: "openai.chat",
-        minimax: "minimax.anthropic",
-        deepseek: "deepseek.anthropic",
-        kimi: "kimi.anthropic",
-        qwen: "qwen.anthropic",
-        gemini: "gemini.google",
-        glm: "glm.anthropic",
-        baai: "baai.self-hosted.embeddings",
-        ollama: "ollama.local",
-    };
-    return defaults[providerId];
-}

package/dist/providers/factories.js

@@ -1,31 +1,41 @@
 import { PROVIDER_REGISTRY } from "./registry.js";
 import { OllamaProvider } from "./ollama.js";
-import { defaultModelForProvider, getRuntimePolicy, isKnownProviderId } from "./model-registry.js";
-function build(providerId, protocol, o) {
+import { defaultEndpointForProvider, defaultModelForProvider, getRuntimePolicy, isKnownProviderId } from "./model-registry.js";
+import { endpointProfiles } from "./endpoints.js";
+function build(providerId, o) {
     if (!isKnownProviderId(providerId))
         throw new Error(`Unknown provider: ${providerId}`);
+    const defaultProtocol = endpointProfiles[defaultEndpointForProvider(providerId)].protocol;
+    const protocol = o.protocol === "openai"
+        ? "openai-chat"
+        : o.protocol === "anthropic"
+            ? "anthropic-messages"
+            : defaultProtocol;
+    if (protocol !== "openai-chat" && protocol !== "anthropic-messages") {
+        throw new Error(`Provider ${providerId} does not use an OpenAI- or Anthropic-compatible default`);
+    }
     const model = o.model ?? defaultModelForProvider(providerId);
     return PROVIDER_REGISTRY[`${providerId}:${protocol}`](o.apiKey, model, o.retry, o.baseURL, getRuntimePolicy(providerId, model));
 }
 /** DeepSeek. Defaults to the OpenAI-compatible wire (richer reasoning-replay handling). */
 export function deepseek(o) {
-    return build("deepseek", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", o);
+    return build("deepseek", o);
 }
 /** Moonshot Kimi. Defaults to the OpenAI-compatible wire. */
 export function kimi(o) {
-    return build("kimi", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", o);
+    return build("kimi", o);
 }
 /** Alibaba Qwen / DashScope. Defaults to the OpenAI-compatible (DashScope) wire. */
 export function qwen(o) {
-    return build("qwen", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", o);
+    return build("qwen", o);
 }
 /** Zhipu GLM. Defaults to the OpenAI-compatible wire. */
 export function glm(o) {
-    return build("glm", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", o);
+    return build("glm", o);
 }
 /** MiniMax. Defaults to the Anthropic-compatible wire (the primary M2.x path). */
 export function minimax(o) {
-    return build("minimax", o.protocol === "openai" ? "openai-chat" : "anthropic-messages", o);
+    return build("minimax", o);
 }
 /** Google Gemini (single wire). */
 export function gemini(o) {

package/dist/providers/gemini-adapter.js

@@ -1,5 +1,6 @@
 import { projectToolOutputToText } from "./content-normalization.js";
 import { normalizeToolCall } from "./base.js";
+import { normalizeGeminiUsage } from "./usage-normalizer.js";
 import { ProtocolResponseError, GEMINI_PROTOCOL_CAPABILITIES, } from "./protocol-adapter.js";
 // Google Generate Content streams response chunks, while @google/generative-ai 0.24.1 exposes
 // a separate promise for the aggregated response. Candidate finishReason and aggregate usage are
@@ -145,8 +146,8 @@ function numberField(raw, field) {
     const value = raw[field];
     if (value === undefined)
         return undefined;
-    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-        throw new ProtocolResponseError("gemini", `usage.${field} must be a non-negative finite number`);
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new ProtocolResponseError("gemini", `usage.${field} must be a non-negative safe integer`);
     }
     return value;
 }
@@ -222,6 +223,8 @@ export class GeminiAdapter {
                 ...(usage.cacheReadInputTokens
                     ? { cacheReadInputTokens: usage.cacheReadInputTokens }
                     : {}),
+                ...(usage.cacheTelemetryStatus ? { cacheTelemetryStatus: usage.cacheTelemetryStatus } : {}),
+                ...(usage.cacheTelemetrySource ? { cacheTelemetrySource: usage.cacheTelemetrySource } : {}),
                 providerUsage: usage,
                 ...(stopReason ? { stopReason } : {}),
                 ...(rawStopReason ? { rawStopReason } : {}),
@@ -236,19 +239,8 @@ export class GeminiAdapter {
             throw new ProtocolResponseError("gemini", "usage must be an object");
         }
         const usage = raw;
-        const inputTokens = numberField(usage, "promptTokenCount");
-        const outputTokens = numberField(usage, "candidatesTokenCount");
         numberField(usage, "totalTokenCount");
-        const cacheReadInputTokens = numberField(usage, "cachedContentTokenCount");
-        if (inputTokens === undefined
-            && outputTokens === undefined
-            && cacheReadInputTokens === undefined)
-            return undefined;
-        return {
-            inputTokens: inputTokens ?? 0,
-            outputTokens: outputTokens ?? 0,
-            ...(cacheReadInputTokens ? { cacheReadInputTokens } : {}),
-        };
+        return normalizeGeminiUsage(usage);
     }
     normalizeStopReason(raw) {
         if (raw === undefined)

package/dist/providers/model-registry.d.ts

@@ -29,8 +29,26 @@ export interface DynamicModelDescriptorResolver {
 }
 export interface EndpointRuntimeCapabilities {
     nativeTokenCounting?: boolean;
+    promptCaching?: boolean;
     protocolOverrides?: ProtocolRuntimeCapabilityOverrides;
 }
+export interface CacheCapabilityEvidence {
+    endpointId: EndpointProfileId;
+    source: string;
+    verifiedAt: "2026-08-26";
+    classification: "documentation" | "live_probe";
+    usageFields: readonly string[];
+}
+export interface TokenMeasurementEvidence {
+    endpointId: EndpointProfileId;
+    source: string;
+    verifiedAt: "2026-08-26";
+    providerApiState: "supported" | "unsupported" | "unknown";
+    adapterState: "available" | "unavailable";
+    method: "provider_preflight" | "official_local_tokenizer" | "postflight" | "heuristic";
+    coverage: readonly string[];
+    sdk: string;
+}
 export type CapabilityEvidenceLayer = "model" | "protocol" | "endpoint";
 export interface EffectiveCapability<T = boolean> {
     state: CapabilityState;
@@ -74,7 +92,10 @@ export interface RegistryRuleEvidence {
     verifiedAt: "2026-08-12";
 }
 export declare const registryEvidence: readonly RegistryRuleEvidence[];
+export declare const cacheCapabilityEvidence: readonly CacheCapabilityEvidence[];
+export declare const tokenMeasurementEvidence: readonly TokenMeasurementEvidence[];
 export declare function defaultModelForProvider(providerId: ProviderId): string;
+export declare function defaultEndpointForProvider(providerId: ProviderId): EndpointProfileId;
 export declare class ModelRegistry {
     resolve(modelId: string, providerId?: ProviderId): ModelRegistration | undefined;
 }
@@ -94,5 +115,5 @@ export declare function resolveEffectiveModelCapabilities(input: {
     endpointCapabilities?: EndpointRuntimeCapabilities;
 }): EffectiveModelCapabilities;
 export declare function generationProtocol(protocol: EndpointProtocol): GenerationProtocol | undefined;
-export declare function endpointCapabilitiesFor(endpointId: EndpointProfileId, preserveEndpointIdentity: boolean): EndpointRuntimeCapabilities | undefined;
+export declare function endpointCapabilitiesFor(endpointId: EndpointProfileId, preserveEndpointIdentity: boolean, preserveCacheEvidence?: boolean): EndpointRuntimeCapabilities | undefined;
 export declare function isKnownProviderId(value: string): value is ProviderId;