@deepstrike/sdk 0.2.52 → 0.2.61

package/dist/providers/request-plan.js

@@ -0,0 +1,199 @@
+import { createHash } from "node:crypto";
+const TRANSPORT_ONLY_KEYS = new Set([
+    "apiKey", "api_key", "bearerToken", "bearer_token", "authorization", "credential",
+    "credentials", "retry", "maxRetries", "baseDelay", "timeout", "signal", "access_token", "refresh_token", "token", "secret", "x-api-key",
+]);
+export function createProviderRequestPlan(input) {
+    const options = materialOptions(input.options ?? {});
+    const plan = {
+        providerId: input.providerId,
+        modelId: input.modelId,
+        endpoint: sanitizeEndpoint(input.endpoint),
+        context: clone(input.context),
+        tools: clone(input.tools),
+        options,
+    };
+    const stablePrefix = {
+        providerId: plan.providerId,
+        modelId: plan.modelId,
+        endpoint: plan.endpoint,
+        context: stablePrefixContext(plan.context),
+        tools: plan.tools,
+        options: plan.options,
+    };
+    return {
+        ...plan,
+        fingerprint: sha256(stableJson(plan)),
+        stablePrefixFingerprint: sha256(stableJson(stablePrefix)),
+    };
+}
+/** Build the plan from a resolved provider when the runner only has the public provider object. */
+export function createProviderRequestPlanForProvider(provider, context, tools, options) {
+    const descriptor = provider.descriptor?.() ?? { provider: "unknown", protocol: "unknown", model: "unknown" };
+    const identity = provider.requestPlanIdentity?.();
+    return createProviderRequestPlan({
+        providerId: identity?.providerId ?? descriptor.provider,
+        modelId: identity?.modelId ?? descriptor.model,
+        endpoint: {
+            id: identity?.endpoint?.id ?? `${descriptor.provider}.${descriptor.protocol}`,
+            protocol: identity?.endpoint?.protocol ?? descriptor.protocol,
+            baseURL: identity?.endpoint?.baseURL ?? "",
+        },
+        context,
+        tools,
+        options,
+    });
+}
+export function estimateProviderPromptTokens(context, tools) {
+    const bytes = new TextEncoder().encode(stableJson({ context, tools })).byteLength;
+    return Math.max(1, Math.ceil(bytes / 4));
+}
+/** Bind a preflight count to its exact provider-visible request. Replay only reuses matching facts. */
+export function recordPromptMeasurement(plan, measurement) {
+    return {
+        requestFingerprint: plan.fingerprint,
+        inputTokens: requireNonNegativeInteger(measurement.inputTokens, "inputTokens"),
+        source: clone(measurement.source),
+        confidence: measurement.confidence,
+    };
+}
+export function measurementForPlan(plan, recorded) {
+    if (!recorded || recorded.requestFingerprint !== plan.fingerprint)
+        return undefined;
+    if (!Number.isSafeInteger(recorded.inputTokens) || recorded.inputTokens < 0)
+        return undefined;
+    if (recorded.confidence !== "exact" && recorded.confidence !== "high_confidence" && recorded.confidence !== "low_confidence")
+        return undefined;
+    const source = recorded.source;
+    if (!source || typeof source !== "object")
+        return undefined;
+    if (source.kind === "native" && typeof source["provider"] === "string" && source["provider"].length > 0)
+        return clone(recorded);
+    if (source.kind === "local_exact" && typeof source.tokenizer === "string" && source.tokenizer.length > 0)
+        return clone(recorded);
+    if (source.kind === "postflight")
+        return clone(recorded);
+    if (source.kind === "heuristic")
+        return clone(recorded);
+    return undefined;
+}
+/** Normalize postflight provider facts without turning estimates into actual usage. */
+export function normalizeProviderUsage(usage) {
+    const inputTokens = requireNonNegativeInteger(usage.inputTokens, "inputTokens");
+    const outputTokens = requireNonNegativeInteger(usage.outputTokens, "outputTokens");
+    const cacheReadInputTokens = optionalNonNegativeInteger(usage.cacheReadInputTokens, "cacheReadInputTokens");
+    const cacheCreationInputTokens = optionalNonNegativeInteger(usage.cacheCreationInputTokens, "cacheCreationInputTokens");
+    const reasoningTokens = optionalNonNegativeInteger(usage.reasoningTokens, "reasoningTokens");
+    const cached = (cacheReadInputTokens ?? 0) + (cacheCreationInputTokens ?? 0);
+    if (cached > inputTokens)
+        throw new RangeError("cache token subsets cannot exceed inputTokens");
+    if (reasoningTokens !== undefined && reasoningTokens > outputTokens) {
+        throw new RangeError("reasoningTokens must be a subset of outputTokens");
+    }
+    return {
+        inputTokens,
+        uncachedInputTokens: inputTokens - cached,
+        outputTokens,
+        ...(cacheReadInputTokens !== undefined ? { cacheReadInputTokens } : {}),
+        ...(cacheCreationInputTokens !== undefined ? { cacheCreationInputTokens } : {}),
+        ...(reasoningTokens !== undefined ? { reasoningTokens } : {}),
+    };
+}
+/** Cost is derived only from an explicit, time-valid host snapshot; otherwise it stays unknown. */
+export function priceProviderUsage(usage, snapshot, observedAt = new Date()) {
+    const at = typeof observedAt === "string" ? new Date(observedAt) : observedAt;
+    const from = new Date(snapshot.effectiveFrom);
+    const expires = snapshot.expiresAt ? new Date(snapshot.expiresAt) : undefined;
+    const rates = snapshot.ratesPerMillion;
+    const requiredRates = [rates.input, rates.output];
+    if (!snapshot.version || !snapshot.currency || Number.isNaN(at.valueOf()) || Number.isNaN(from.valueOf())
+        || requiredRates.some(rate => typeof rate !== "number" || !Number.isFinite(rate) || rate < 0)
+        || Object.values(rates).some(rate => typeof rate !== "number" || !Number.isFinite(rate) || rate < 0)) {
+        return { source: "unpriced", reason: "invalid_pricing_snapshot" };
+    }
+    if (at < from)
+        return { source: "unpriced", reason: "pricing_snapshot_not_effective" };
+    if (expires && (Number.isNaN(expires.valueOf()) || at >= expires)) {
+        return { source: "unpriced", reason: "pricing_snapshot_expired" };
+    }
+    const amount = (usage.uncachedInputTokens * rates.input
+        + usage.outputTokens * rates.output
+        + (usage.cacheReadInputTokens ?? 0) * (rates.cacheRead ?? rates.input)
+        + (usage.cacheCreationInputTokens ?? 0) * (rates.cacheCreation ?? rates.input)
+        + (usage.reasoningTokens ?? 0) * (rates.reasoning ?? 0)) / 1_000_000;
+    return { source: "snapshot", currency: snapshot.currency, amount, pricingVersion: snapshot.version };
+}
+function materialOptions(options) {
+    return sanitizeMaterialValue(options);
+}
+function sanitizeEndpoint(endpoint) {
+    try {
+        const url = new URL(endpoint.baseURL);
+        url.username = "";
+        url.password = "";
+        url.search = "";
+        url.hash = "";
+        return { ...clone(endpoint), baseURL: url.toString().replace(/\/$/, "") };
+    }
+    catch {
+        return { ...clone(endpoint), baseURL: "" };
+    }
+}
+function sanitizeMaterialValue(value) {
+    if (value === undefined || typeof value === "function")
+        return undefined;
+    if (Array.isArray(value))
+        return value.map(sanitizeMaterialValue).filter(item => item !== undefined);
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.keys(value).sort().flatMap(key => {
+            if (TRANSPORT_ONLY_KEYS.has(key) || isTransportOnlyKey(key))
+                return [];
+            const sanitized = sanitizeMaterialValue(value[key]);
+            return sanitized === undefined ? [] : [[key, sanitized]];
+        }));
+    }
+    return value;
+}
+function isTransportOnlyKey(key) {
+    const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+    return normalized.includes("authorization") || normalized.includes("credential")
+        || normalized.includes("accesstoken") || normalized.includes("refreshtoken")
+        || normalized.includes("apikey") || normalized === "bearer" || normalized === "token"
+        || normalized === "secret" || normalized === "xapikey";
+}
+function stableJson(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(",")}]`;
+    const object = value;
+    return `{${Object.keys(object).sort().map(key => `${JSON.stringify(key)}:${stableJson(object[key])}`).join(",")}}`;
+}
+function stablePrefixContext(context) {
+    const frozenPrefixLen = context.frozenPrefixLen ?? 0;
+    return {
+        systemText: context.systemText,
+        ...(context.systemStable !== undefined ? { systemStable: context.systemStable } : {}),
+        ...(context.systemKnowledge !== undefined ? { systemKnowledge: context.systemKnowledge } : {}),
+        frozenPrefixLen,
+        turns: clone(context.turns.slice(0, frozenPrefixLen)),
+    };
+}
+function sha256(value) {
+    return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+function clone(value) {
+    if (value === undefined || value === null || typeof value !== "object")
+        return value;
+    if (Array.isArray(value))
+        return value.map(clone);
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clone(item)]));
+}
+function requireNonNegativeInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new RangeError(`${name} must be a non-negative safe integer`);
+    return value;
+}
+function optionalNonNegativeInteger(value, name) {
+    return value === undefined ? undefined : requireNonNegativeInteger(value, name);
+}

package/dist/providers/usage-normalizer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * spc_011-C-07: normalizes each vendor's raw postflight usage object into the shared
+ * `ProviderUsage` shape (`../types.js`). One function per wire family, not one
+ * per provider — DeepSeek/Kimi/GLM/Qwen/MiniMax's OpenAI-wire variants all route through
+ * `normalizeOpenAIUsage` via `OpenAIChatProvider` inheritance, and their Anthropic-wire variants
+ * route through `normalizeAnthropicUsage` via `AnthropicCompatibleProvider` inheritance — the
+ * "8 providers" the spec counts are 8 *providers*, not 8 independent parsing implementations.
+ *
+ * Reuses `openAICachedPromptTokens` (`./base.js`) for the OpenAI-family cache figure rather than
+ * re-deriving it — that function already covers the OpenAI/Qwen/MiniMax/GLM/Kimi standard shape
+ * plus DeepSeek's `prompt_cache_hit_tokens` variant.
+ *
+ * `TokenUsage`/`UsageEvent` are otherwise untouched by this module. Missing or malformed usage
+ * returns `undefined`; absence is not a zero-token measurement.
+ */
+import type { ProviderUsage } from "../types.js";
+/**
+ * Covers both OpenAI wire shapes actually in use: Chat Completions (`prompt_tokens`/
+ * `completion_tokens`/`completion_tokens_details.reasoning_tokens`, used by `openai.ts` and every
+ * `OpenAIChatProvider` subclass) and the Responses API (`input_tokens`/`output_tokens`/
+ * `output_tokens_details.reasoning_tokens`, used by `openai-responses.ts`) — the two field-name
+ * conventions are read via fallback, and only one will ever be present on a given raw object.
+ */
+export declare function normalizeOpenAIUsage(usage: unknown): ProviderUsage | undefined;
+/**
+ * Anthropic's raw `input_tokens` is UNCACHED input only (unlike OpenAI's `prompt_tokens`, which
+ * is already cache-inclusive) — `anthropic.ts`'s own `stream()` sums `input_tokens +
+ * cache_read_input_tokens + cache_creation_input_tokens` into the full prompt size for the same
+ * reason context-pressure accounting needs it (see that file's comment on why excluding cached
+ * tokens would suppress compaction until a 413). This function replicates that same sum so
+ * `ProviderUsage.inputTokens` means the same "full prompt size" thing across vendors — reading
+ * raw `input_tokens` alone here would silently undercount every cache-heavy Anthropic turn.
+ * No `reasoning_tokens`-equivalent field exists in this SDK's `Usage` type, so that field stays
+ * unset rather than guessed.
+ */
+export declare function normalizeAnthropicUsage(usage: unknown): ProviderUsage | undefined;
+/**
+ * `@google/generative-ai`'s `UsageMetadata` has no reasoning/thoughts token field and no separate
+ * cache-write count (only `cachedContentTokenCount`, a read figure) — `reasoningTokens` and
+ * `cacheCreationInputTokens` stay unset rather than invented.
+ */
+export declare function normalizeGeminiUsage(usage: unknown): ProviderUsage | undefined;
+/**
+ * Ollama's final stream chunk (`done: true`) carries `prompt_eval_count`/`eval_count` — no cache
+ * or reasoning concept exists in its API at all, so both stay unset. Before this card `ollama.ts`
+ * read neither field; this is the first usage extraction it has ever had.
+ */
+export declare function normalizeOllamaUsage(chunk: unknown): ProviderUsage | undefined;

package/dist/providers/usage-normalizer.js

@@ -0,0 +1,139 @@
+import { openAICachedPromptTokens } from "./base.js";
+import { ProtocolResponseError } from "./protocol-adapter.js";
+function readNumber(obj, key, protocol) {
+    const value = obj?.[key];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new ProtocolResponseError(protocol, `usage.${key} must be a non-negative safe integer`);
+    }
+    return value;
+}
+function hasOwn(obj, key) {
+    return obj !== undefined && Object.prototype.hasOwnProperty.call(obj, key);
+}
+function openAICacheTelemetry(usage) {
+    const promptDetails = usage?.prompt_tokens_details;
+    const inputDetails = usage?.input_tokens_details;
+    if (hasOwn(usage, "prompt_cache_hit_tokens") || hasOwn(usage, "prompt_cache_miss_tokens")) {
+        return { cacheTelemetryStatus: "measured", cacheTelemetrySource: "deepseek_prompt_cache" };
+    }
+    if (hasOwn(promptDetails, "cached_tokens") || hasOwn(inputDetails, "cached_tokens")) {
+        return { cacheTelemetryStatus: "measured", cacheTelemetrySource: "openai_prompt_details" };
+    }
+    return { cacheTelemetryStatus: "unavailable" };
+}
+/**
+ * Covers both OpenAI wire shapes actually in use: Chat Completions (`prompt_tokens`/
+ * `completion_tokens`/`completion_tokens_details.reasoning_tokens`, used by `openai.ts` and every
+ * `OpenAIChatProvider` subclass) and the Responses API (`input_tokens`/`output_tokens`/
+ * `output_tokens_details.reasoning_tokens`, used by `openai-responses.ts`) — the two field-name
+ * conventions are read via fallback, and only one will ever be present on a given raw object.
+ */
+export function normalizeOpenAIUsage(usage) {
+    const u = usage && typeof usage === "object" ? usage : undefined;
+    const protocol = hasOwn(u, "input_tokens") ? "openai-responses" : "openai-chat";
+    const rawInput = readNumber(u, "prompt_tokens", protocol) ?? readNumber(u, "input_tokens", protocol);
+    const rawOutput = readNumber(u, "completion_tokens", protocol) ?? readNumber(u, "output_tokens", protocol);
+    if (rawInput === undefined && rawOutput === undefined)
+        return undefined;
+    const inputTokens = rawInput ?? 0;
+    const outputTokens = rawOutput ?? 0;
+    const promptDetails = u?.prompt_tokens_details;
+    const inputDetails = u?.input_tokens_details;
+    readNumber(promptDetails, "cached_tokens", protocol);
+    readNumber(inputDetails, "cached_tokens", protocol);
+    const cacheHit = readNumber(u, "prompt_cache_hit_tokens", protocol);
+    const cacheMiss = readNumber(u, "prompt_cache_miss_tokens", protocol);
+    const cacheReadInputTokens = openAICachedPromptTokens(usage);
+    const details = (u?.completion_tokens_details ?? u?.output_tokens_details);
+    const reasoningTokens = readNumber(details, "reasoning_tokens", protocol);
+    if (cacheReadInputTokens > inputTokens) {
+        throw new ProtocolResponseError(protocol, "cache token subsets cannot exceed input tokens");
+    }
+    if (cacheHit !== undefined && cacheMiss !== undefined && cacheHit + cacheMiss !== inputTokens) {
+        throw new ProtocolResponseError(protocol, "DeepSeek cache hit and miss tokens must sum to prompt tokens");
+    }
+    const providerUsage = {
+        inputTokens,
+        outputTokens,
+        ...(cacheReadInputTokens > 0 ? { cacheReadInputTokens } : {}),
+        ...(reasoningTokens !== undefined ? { reasoningTokens } : {}),
+        ...openAICacheTelemetry(u),
+    };
+    return providerUsage;
+}
+/**
+ * Anthropic's raw `input_tokens` is UNCACHED input only (unlike OpenAI's `prompt_tokens`, which
+ * is already cache-inclusive) — `anthropic.ts`'s own `stream()` sums `input_tokens +
+ * cache_read_input_tokens + cache_creation_input_tokens` into the full prompt size for the same
+ * reason context-pressure accounting needs it (see that file's comment on why excluding cached
+ * tokens would suppress compaction until a 413). This function replicates that same sum so
+ * `ProviderUsage.inputTokens` means the same "full prompt size" thing across vendors — reading
+ * raw `input_tokens` alone here would silently undercount every cache-heavy Anthropic turn.
+ * No `reasoning_tokens`-equivalent field exists in this SDK's `Usage` type, so that field stays
+ * unset rather than guessed.
+ */
+export function normalizeAnthropicUsage(usage) {
+    const u = usage && typeof usage === "object" ? usage : undefined;
+    const rawUncachedInput = readNumber(u, "input_tokens", "anthropic-messages");
+    const rawCacheRead = readNumber(u, "cache_read_input_tokens", "anthropic-messages");
+    const rawCacheCreation = readNumber(u, "cache_creation_input_tokens", "anthropic-messages");
+    const rawOutput = readNumber(u, "output_tokens", "anthropic-messages");
+    if (rawUncachedInput === undefined && rawCacheRead === undefined && rawCacheCreation === undefined && rawOutput === undefined)
+        return undefined;
+    const uncachedInput = rawUncachedInput ?? 0;
+    const cacheReadInputTokens = rawCacheRead ?? 0;
+    const cacheCreationInputTokens = rawCacheCreation ?? 0;
+    const outputTokens = rawOutput ?? 0;
+    const providerUsage = {
+        inputTokens: uncachedInput + cacheReadInputTokens + cacheCreationInputTokens,
+        outputTokens,
+        ...(cacheReadInputTokens > 0 ? { cacheReadInputTokens } : {}),
+        ...(cacheCreationInputTokens > 0 ? { cacheCreationInputTokens } : {}),
+        ...(hasOwn(u, "cache_read_input_tokens") || hasOwn(u, "cache_creation_input_tokens")
+            ? { cacheTelemetryStatus: "measured", cacheTelemetrySource: "anthropic_usage" }
+            : { cacheTelemetryStatus: "unavailable" }),
+    };
+    return providerUsage;
+}
+/**
+ * `@google/generative-ai`'s `UsageMetadata` has no reasoning/thoughts token field and no separate
+ * cache-write count (only `cachedContentTokenCount`, a read figure) — `reasoningTokens` and
+ * `cacheCreationInputTokens` stay unset rather than invented.
+ */
+export function normalizeGeminiUsage(usage) {
+    const u = usage && typeof usage === "object" ? usage : undefined;
+    const rawInput = readNumber(u, "promptTokenCount", "gemini");
+    const rawOutput = readNumber(u, "candidatesTokenCount", "gemini");
+    if (rawInput === undefined && rawOutput === undefined)
+        return undefined;
+    const inputTokens = rawInput ?? 0;
+    const outputTokens = rawOutput ?? 0;
+    const cacheReadInputTokens = readNumber(u, "cachedContentTokenCount", "gemini");
+    if ((cacheReadInputTokens ?? 0) > inputTokens) {
+        throw new ProtocolResponseError("gemini", "cache token subsets cannot exceed input tokens");
+    }
+    const providerUsage = {
+        inputTokens,
+        outputTokens,
+        ...(cacheReadInputTokens ? { cacheReadInputTokens } : {}),
+        ...(hasOwn(u, "cachedContentTokenCount")
+            ? { cacheTelemetryStatus: "measured", cacheTelemetrySource: "gemini_usage" }
+            : { cacheTelemetryStatus: "unavailable" }),
+    };
+    return providerUsage;
+}
+/**
+ * Ollama's final stream chunk (`done: true`) carries `prompt_eval_count`/`eval_count` — no cache
+ * or reasoning concept exists in its API at all, so both stay unset. Before this card `ollama.ts`
+ * read neither field; this is the first usage extraction it has ever had.
+ */
+export function normalizeOllamaUsage(chunk) {
+    const u = chunk && typeof chunk === "object" ? chunk : undefined;
+    const rawInput = readNumber(u, "prompt_eval_count", "ollama-chat");
+    const rawOutput = readNumber(u, "eval_count", "ollama-chat");
+    if (rawInput === undefined && rawOutput === undefined)
+        return undefined;
+    return { inputTokens: rawInput ?? 0, outputTokens: rawOutput ?? 0, cacheTelemetryStatus: "unavailable" };
+}

package/dist/providers/vendor-profiles.d.ts

@@ -1,6 +1,5 @@
-import type { RuntimePolicy } from "../types.js";
-import { endpointProfiles } from "./profiles.js";
-import type { ProviderId } from "./profiles.js";
+import { endpointProfiles } from "./endpoints.js";
+import type { ProviderId } from "./endpoints.js";
 export type EndpointProfileKey = keyof typeof endpointProfiles;
 export interface AnthropicVendorProfile {
     /** Identity advertised in `descriptor().provider`. */
@@ -9,44 +8,32 @@ export interface AnthropicVendorProfile {
     defaultModel: string;
     /** Endpoint profile whose `baseURL` is the Anthropic-compatible wire for this vendor. */
     baseURLProfileKey: EndpointProfileKey;
-    /** Recommended `maxTurns` per model id; missing model → empty policy. */
-    policies: Record<string, RuntimePolicy>;
 }
-export declare const DEEPSEEK_POLICIES: Record<string, RuntimePolicy>;
-export declare const KIMI_POLICIES: Record<string, RuntimePolicy>;
-export declare const QWEN_POLICIES: Record<string, RuntimePolicy>;
-export declare const GLM_POLICIES: Record<string, RuntimePolicy>;
-export declare const MINIMAX_POLICIES: Record<string, RuntimePolicy>;
 export declare const anthropicVendorProfiles: {
     deepseek: {
         providerId: "deepseek";
         defaultModel: string;
         baseURLProfileKey: "deepseek.anthropic";
-        policies: Record<string, RuntimePolicy>;
     };
     kimi: {
         providerId: "kimi";
         defaultModel: string;
         baseURLProfileKey: "kimi.anthropic";
-        policies: Record<string, RuntimePolicy>;
     };
     qwen: {
         providerId: "qwen";
         defaultModel: string;
         baseURLProfileKey: "qwen.anthropic";
-        policies: Record<string, RuntimePolicy>;
     };
     glm: {
         providerId: "glm";
         defaultModel: string;
         baseURLProfileKey: "glm.anthropic";
-        policies: Record<string, RuntimePolicy>;
     };
     minimax: {
         providerId: "minimax";
         defaultModel: string;
         baseURLProfileKey: "minimax.anthropic";
-        policies: Record<string, RuntimePolicy>;
     };
 };
 export type AnthropicVendorId = keyof typeof anthropicVendorProfiles;

package/dist/providers/vendor-profiles.js

@@ -1,64 +1,18 @@
-import { endpointProfiles } from "./profiles.js";
-export const DEEPSEEK_POLICIES = {
-    "deepseek-chat": { maxTurns: 25 },
-    "deepseek-reasoner": { maxTurns: 50 },
-    "deepseek-v4-flash": { maxTurns: 20 },
-    "deepseek-v4-pro": { maxTurns: 35 },
-};
-export const KIMI_POLICIES = {
-    "moonshot-v1-8k": { maxTurns: 15 },
-    "moonshot-v1-32k": { maxTurns: 20 },
-    "moonshot-v1-128k": { maxTurns: 30 },
-    "kimi-k2.5": { maxTurns: 30 },
-    "kimi-k2.6": { maxTurns: 35 },
-    "kimi-k2-thinking": { maxTurns: 50 },
-    "kimi-k2-thinking-turbo": { maxTurns: 40 },
-};
-export const QWEN_POLICIES = {
-    "qwen3.7-max-preview": { maxTurns: 45 },
-    "qwen3.7-plus-preview": { maxTurns: 40 },
-    "qwen3.6-max-preview": { maxTurns: 40 },
-    "qwen3.6-plus": { maxTurns: 35 },
-    "qwen3.6-flash": { maxTurns: 20 },
-    "qwen3.6-35b-a3b": { maxTurns: 25 },
-    "qwen3.6-27b": { maxTurns: 25 },
-    "qwen3.5-plus": { maxTurns: 35 },
-    "qwen3.5-flash": { maxTurns: 20 },
-    "qwen3.5-397b-a17b": { maxTurns: 35 },
-    "qwen3.5-122b-a10b": { maxTurns: 25 },
-    "qwen3.5-35b-a3b": { maxTurns: 20 },
-    "qwen3.5-27b": { maxTurns: 20 },
-};
-export const GLM_POLICIES = {
-    "glm-5.2": { maxTurns: 50 },
-    "glm/glm-5.2": { maxTurns: 50 },
-    "glm-5.1": { maxTurns: 50 },
-    "glm/glm-5.1": { maxTurns: 50 },
-    "glm-4-plus": { maxTurns: 35 },
-    "glm/glm-4-plus": { maxTurns: 35 },
-    "glm-4-flash": { maxTurns: 15 },
-    "glm/glm-4-flash": { maxTurns: 15 },
-    "glm-4-air": { maxTurns: 20 },
-    "glm/glm-4-air": { maxTurns: 20 },
-};
-export const MINIMAX_POLICIES = {
-    "MiniMax-M3": { maxTurns: 35 },
-    "MiniMax-M3-highspeed": { maxTurns: 35 },
-    "MiniMax-M2.7": { maxTurns: 35 },
-    "MiniMax-M2.7-highspeed": { maxTurns: 35 },
-    "MiniMax-M2.5": { maxTurns: 25 },
-    "MiniMax-M2.5-highspeed": { maxTurns: 25 },
-    "MiniMax-M2.1": { maxTurns: 25 },
-    "MiniMax-M2.1-highspeed": { maxTurns: 25 },
-    "MiniMax-M2": { maxTurns: 20 },
-    "MiniMax-Text-01": { maxTurns: 20 },
-};
+// Single source of truth for the Anthropic-compatible vendor backends (DeepSeek,
+// Kimi, Qwen, GLM, MiniMax). Each backend differs only by data — provider id,
+// default model, endpoint, and per-model runtime policy — so the generic
+// `AnthropicCompatibleProvider` reads a profile from here instead of every
+// backend subclassing `AnthropicProvider` purely to carry configuration.
+//
+// Runtime policy and default model resolution live in ModelRegistry; this module
+// only carries Anthropic-compatible transport configuration.
+import { endpointProfiles } from "./endpoints.js";
 export const anthropicVendorProfiles = {
-    deepseek: { providerId: "deepseek", defaultModel: "deepseek-v4-flash", baseURLProfileKey: "deepseek.anthropic", policies: DEEPSEEK_POLICIES },
-    kimi: { providerId: "kimi", defaultModel: "kimi-k2.6", baseURLProfileKey: "kimi.anthropic", policies: KIMI_POLICIES },
-    qwen: { providerId: "qwen", defaultModel: "qwen3.6-plus", baseURLProfileKey: "qwen.anthropic", policies: QWEN_POLICIES },
-    glm: { providerId: "glm", defaultModel: "glm-5.2", baseURLProfileKey: "glm.anthropic", policies: GLM_POLICIES },
-    minimax: { providerId: "minimax", defaultModel: "MiniMax-M3", baseURLProfileKey: "minimax.anthropic", policies: MINIMAX_POLICIES },
+    deepseek: { providerId: "deepseek", defaultModel: "deepseek-v4-flash", baseURLProfileKey: "deepseek.anthropic" },
+    kimi: { providerId: "kimi", defaultModel: "kimi-k2.6", baseURLProfileKey: "kimi.anthropic" },
+    qwen: { providerId: "qwen", defaultModel: "qwen3.6-plus", baseURLProfileKey: "qwen.anthropic" },
+    glm: { providerId: "glm", defaultModel: "glm-5.2", baseURLProfileKey: "glm.anthropic" },
+    minimax: { providerId: "minimax", defaultModel: "MiniMax-M3", baseURLProfileKey: "minimax.anthropic" },
 };
 /** Resolve the Anthropic-compatible base URL for a vendor profile. */
 export function anthropicVendorBaseURL(profile) {

package/dist/runtime/canonical-kernel-step.d.ts

@@ -95,8 +95,7 @@ export interface CanonicalRunnerRuntimeOptions {
 }
 /**
  * Canonical operation runtime used by the Node host.
- * Every durable transition below is one of the canonical ABI's five input classes; no legacy
- * envelope or synthesized host transaction reaches core or storage.
+ * Every durable transition below is one of the canonical contract's five input classes.
  */
 export declare class CanonicalRunnerRuntime {
     private readonly options;