@deepstrike/sdk 0.2.28 → 0.2.31

package/dist/planes/public.d.ts

@@ -0,0 +1,13 @@
+export { WorktreeExecutionPlane, GitWorktreeManager } from "../runtime/worktree-plane.js";
+export type { WorktreeManager } from "../runtime/worktree-plane.js";
+export { FilteredExecutionPlane } from "../runtime/filtered-plane.js";
+export { ProcessSandboxPlane } from "../runtime/process-sandbox-plane.js";
+export type { SandboxOptions } from "../runtime/process-sandbox-plane.js";
+export { McpProxyPlane } from "../runtime/mcp-proxy-plane.js";
+export type { McpServerConfig } from "../runtime/mcp-proxy-plane.js";
+export { RemoteVpcPlane } from "../runtime/remote-vpc-plane.js";
+export type { RemoteVpcOptions } from "../runtime/remote-vpc-plane.js";
+export { NullArchiveStore, FileArchiveStore } from "../runtime/archive.js";
+export type { ArchiveStore } from "../runtime/archive.js";
+export { EnvCredentialVault, InMemoryCredentialVault, ChainedCredentialVault } from "../runtime/credential-vault.js";
+export type { CredentialVault } from "../runtime/credential-vault.js";

package/dist/planes/public.js

@@ -0,0 +1,9 @@
+// `@deepstrike/sdk/planes` — advanced execution planes, archive stores, and credential vaults.
+// The root package exports `LocalExecutionPlane`; specialized planes live here.
+export { WorktreeExecutionPlane, GitWorktreeManager } from "../runtime/worktree-plane.js";
+export { FilteredExecutionPlane } from "../runtime/filtered-plane.js";
+export { ProcessSandboxPlane } from "../runtime/process-sandbox-plane.js";
+export { McpProxyPlane } from "../runtime/mcp-proxy-plane.js";
+export { RemoteVpcPlane } from "../runtime/remote-vpc-plane.js";
+export { NullArchiveStore, FileArchiveStore } from "../runtime/archive.js";
+export { EnvCredentialVault, InMemoryCredentialVault, ChainedCredentialVault } from "../runtime/credential-vault.js";

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

@@ -0,0 +1,23 @@
+import type { RuntimePolicy } from "../types.js";
+import { AnthropicProvider } from "./anthropic.js";
+import { type AnthropicVendorProfile } from "./vendor-profiles.js";
+/**
+ * A vendor that exposes an Anthropic-compatible Messages endpoint (DeepSeek,
+ * Kimi, Qwen, GLM, MiniMax, …). All wire behavior is inherited from
+ * `AnthropicProvider`; the only per-vendor variation is configuration, supplied
+ * as an `AnthropicVendorProfile`. This replaces the family of near-identical
+ * `<Vendor>AnthropicProvider` subclasses that existed only to carry that config.
+ *
+ * Adding a new Anthropic-compatible vendor is now "add a profile" — no new
+ * provider class is required (the named `<Vendor>AnthropicProvider` shims are
+ * kept only for backward compatibility / `instanceof` checks).
+ */
+export declare class AnthropicCompatibleProvider extends AnthropicProvider {
+    private readonly vendorProfile;
+    constructor(profile: AnthropicVendorProfile, apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+    protected providerName(): string;
+    runtimePolicy(): RuntimePolicy;
+}

package/dist/providers/anthropic-compatible.js

@@ -0,0 +1,29 @@
+import { AnthropicProvider } from "./anthropic.js";
+import { anthropicVendorBaseURL } from "./vendor-profiles.js";
+/**
+ * A vendor that exposes an Anthropic-compatible Messages endpoint (DeepSeek,
+ * Kimi, Qwen, GLM, MiniMax, …). All wire behavior is inherited from
+ * `AnthropicProvider`; the only per-vendor variation is configuration, supplied
+ * as an `AnthropicVendorProfile`. This replaces the family of near-identical
+ * `<Vendor>AnthropicProvider` subclasses that existed only to carry that config.
+ *
+ * Adding a new Anthropic-compatible vendor is now "add a profile" — no new
+ * provider class is required (the named `<Vendor>AnthropicProvider` shims are
+ * kept only for backward compatibility / `instanceof` checks).
+ */
+export class AnthropicCompatibleProvider extends AnthropicProvider {
+    vendorProfile;
+    constructor(profile, apiKey, model, retry, baseURL) {
+        super(apiKey, model ?? profile.defaultModel, retry, {
+            baseURL: baseURL ?? anthropicVendorBaseURL(profile),
+            authMode: "api-key",
+        });
+        this.vendorProfile = profile;
+    }
+    providerName() {
+        return this.vendorProfile.providerId;
+    }
+    runtimePolicy() {
+        return this.vendorProfile.policies[this.model] ?? {};
+    }
+}

package/dist/providers/anthropic.d.ts

@@ -3,14 +3,23 @@ interface AnthropicProviderOptions {
     baseURL?: string;
     authMode?: "api-key" | "bearer";
 }
+/** Options-object form for `AnthropicProvider` — the recommended constructor shape. */
+export interface AnthropicProviderConfig extends AnthropicProviderOptions {
+    apiKey: string;
+    model?: string;
+    retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    };
+}
 export declare class AnthropicProvider implements LLMProvider {
-    protected readonly model: string;
     private client;
     private circuit;
     private maxRetries;
     private baseDelay;
+    protected readonly model: string;
     private nativeAssistantBlocks;
-    constructor(apiKey: string, model?: string, retry?: {
+    constructor(apiKeyOrConfig: string | AnthropicProviderConfig, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, options?: AnthropicProviderOptions);

package/dist/providers/anthropic.js

@@ -13,23 +13,28 @@ const CLAUDE_POLICIES = {
     "claude-3-5-haiku-latest": { maxTurns: 15 },
 };
 export class AnthropicProvider {
-    model;
     client;
     circuit;
     maxRetries;
     baseDelay;
+    model;
     nativeAssistantBlocks = new Map();
-    constructor(apiKey, model = "claude-sonnet-4-6", retry = { maxRetries: 3, baseDelay: 1000 }, options = {}) {
-        this.model = model;
+    // Accepts the options object (`new AnthropicProvider({ apiKey, model, baseURL })`) or the legacy
+    // positional form (still used by the Anthropic-compatible backend subclasses' `super(...)` calls).
+    constructor(apiKeyOrConfig, model = "claude-sonnet-4-6", retry = { maxRetries: 3, baseDelay: 1000 }, options = {}) {
+        const c = typeof apiKeyOrConfig === "string"
+            ? { apiKey: apiKeyOrConfig, model, retry, ...options }
+            : { model: "claude-sonnet-4-6", retry: { maxRetries: 3, baseDelay: 1000 }, ...apiKeyOrConfig };
+        this.model = c.model ?? "claude-sonnet-4-6";
         this.client = withServerRuntimeGuard(() => new Anthropic({
-            ...(options.authMode === "bearer"
-                ? { authToken: apiKey, apiKey: null }
-                : { apiKey, authToken: null }),
-            ...(options.baseURL ? { baseURL: options.baseURL } : {}),
+            ...(c.authMode === "bearer"
+                ? { authToken: c.apiKey, apiKey: null }
+                : { apiKey: c.apiKey, authToken: null }),
+            ...(c.baseURL ? { baseURL: c.baseURL } : {}),
         }));
         this.circuit = new CircuitBreaker();
-        this.maxRetries = retry.maxRetries;
-        this.baseDelay = retry.baseDelay;
+        this.maxRetries = c.retry?.maxRetries ?? 3;
+        this.baseDelay = c.retry?.baseDelay ?? 1000;
     }
     runtimePolicy() {
         return CLAUDE_POLICIES[this.model] ?? {};

package/dist/providers/catalog.js

@@ -1,12 +1,4 @@
-import { AnthropicProvider } from "./anthropic.js";
-import { OpenAIChatProvider } from "./openai.js";
-import { DeepSeekProvider, DeepSeekAnthropicProvider } from "./deepseek.js";
-import { KimiProvider, KimiAnthropicProvider } from "./kimi.js";
-import { OpenAIResponsesProvider } from "./openai-responses.js";
-import { MiniMaxAnthropicProvider, MiniMaxOpenAIProvider } from "./minimax.js";
-import { QwenProvider, QwenAnthropicProvider } from "./qwen.js";
-import { GeminiProvider } from "./gemini.js";
-import { GLMProvider, GLMAnthropicProvider } from "./glm.js";
+import { PROVIDER_REGISTRY, providerRegistryKey } from "./registry.js";
 import { endpointProfiles, getModelProfile, modelProfiles } from "./profiles.js";
 export function createProvider(options) {
     const profile = isModelProfileId(options.model) ? getModelProfile(options.model) : undefined;
@@ -31,50 +23,10 @@ export function createProvider(options) {
     }
     const model = modelNameForProvider(options.model, providerId);
     const baseURL = options.baseURL ?? endpoint.baseURL;
-    if (providerId === "anthropic" && endpoint.protocol === "anthropic-messages") {
-        return new AnthropicProvider(options.apiKey, model, options.retry, { baseURL });
-    }
-    if (providerId === "openai") {
-        if (endpoint.protocol === "openai-chat") {
-            return new OpenAIChatProvider(options.apiKey, model, options.retry, baseURL);
-        }
-        if (endpoint.protocol === "openai-responses") {
-            return new OpenAIResponsesProvider(options.apiKey, model, options.retry, baseURL);
-        }
-    }
-    if (providerId === "minimax" && endpoint.protocol === "anthropic-messages") {
-        return new MiniMaxAnthropicProvider(options.apiKey, model, options.retry, baseURL);
-    }
-    if (providerId === "minimax" && endpoint.protocol === "openai-chat") {
-        return new MiniMaxOpenAIProvider(options.apiKey, model, options.retry, baseURL);
-    }
-    if (providerId === "deepseek" && endpoint.protocol === "anthropic-messages") {
-        return new DeepSeekAnthropicProvider(options.apiKey, model, options.retry, baseURL);
-    }
-    if (providerId === "deepseek" && endpoint.protocol === "openai-chat") {
-        return new DeepSeekProvider(options.apiKey, model, options.retry, baseURL);
-    }
-    if (providerId === "kimi" && endpoint.protocol === "anthropic-messages") {
-        return new KimiAnthropicProvider(options.apiKey, model, options.retry, baseURL);
-    }
-    if (providerId === "kimi" && endpoint.protocol === "openai-chat") {
-        return new KimiProvider(options.apiKey, model, options.retry, baseURL);
-    }
-    if (providerId === "qwen" && endpoint.protocol === "anthropic-messages") {
-        return new QwenAnthropicProvider(options.apiKey, model, options.retry, baseURL);
-    }
-    if (providerId === "qwen" && endpoint.protocol === "openai-chat") {
-        return new QwenProvider(options.apiKey, model, options.retry, baseURL);
-    }
-    if (providerId === "gemini" && endpoint.protocol === "gemini") {
-        return new GeminiProvider(options.apiKey, model, options.retry, baseURL);
-    }
-    if (providerId === "glm" && endpoint.protocol === "anthropic-messages") {
-        return new GLMAnthropicProvider(options.apiKey, model, options.retry, baseURL);
-    }
-    if (providerId === "glm" && endpoint.protocol === "openai-chat") {
-        return new GLMProvider(options.apiKey, model, options.retry, baseURL);
-    }
+    // Single data-driven dispatch: one registry keyed by (providerId, protocol).
+    const make = PROVIDER_REGISTRY[providerRegistryKey(providerId, endpoint.protocol)];
+    if (make)
+        return make(options.apiKey, model, options.retry, baseURL);
     throw new Error(`No Node provider factory for ${options.model} on ${endpoint.id}`);
 }
 function isModelProfileId(model) {

package/dist/providers/deepseek.d.ts

@@ -1,17 +1,25 @@
-import type { Message, ProviderDescriptor, RenderedContext, ToolSchema, StreamEvent, RuntimePolicy } from "../types.js";
-import { AnthropicProvider } from "./anthropic.js";
-import { OpenAIChatProvider } from "./openai.js";
+import type { ProviderDescriptor, RuntimePolicy } from "../types.js";
+import { OpenAIChatProvider, type OpenAIChatTurnReasoning } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
 /**
  * DeepSeek over its Anthropic-compatible endpoint.
+ * @deprecated Prefer `deepseek({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.deepseek`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export declare class DeepSeekAnthropicProvider extends AnthropicProvider {
+export declare class DeepSeekAnthropicProvider extends AnthropicCompatibleProvider {
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    protected providerName(): string;
-    runtimePolicy(): RuntimePolicy;
 }
+/**
+ * DeepSeek over its OpenAI-compatible endpoint. Reasoning is carried out-of-band as
+ * `reasoning_content`; replay persists DeepSeek's schema_version-2 envelope (with the
+ * native `tool_calls` blocks). Request shaping (`reasoning_effort` + `extra_body.thinking`)
+ * and replay are supplied via the OpenAIChatProvider Template-Method hooks; the streaming /
+ * tool-call machinery is inherited from the base class.
+ */
 export declare class DeepSeekProvider extends OpenAIChatProvider {
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
@@ -20,7 +28,19 @@ export declare class DeepSeekProvider extends OpenAIChatProvider {
     runtimePolicy(): RuntimePolicy;
     descriptor(): ProviderDescriptor;
     protected requireNonEmptyReasoningReplayForToolTurns(extensions?: Record<string, unknown>): boolean;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    protected cacheKeyParams(): Record<string, unknown>;
+    protected usesInlineThinkingTags(): boolean;
+    protected exposeReasoningDelta(extensions?: Record<string, unknown>): boolean;
+    protected prepareExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
+    protected rememberCompleteReplay(content: string, toolCalls: Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>, r: OpenAIChatTurnReasoning): void;
+    protected rememberStreamReplay(content: string, toolCalls: Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>, r: OpenAIChatTurnReasoning): void;
     private rememberDeepSeekReplay;
 }

package/dist/providers/deepseek.js

@@ -1,30 +1,26 @@
-import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIChatProvider } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
 import { endpointProfiles } from "./profiles.js";
-import { omitExtensionKeys, openAICachedPromptTokens } from "./base.js";
-const DEEPSEEK_POLICIES = {
-    "deepseek-chat": { maxTurns: 25 },
-    "deepseek-reasoner": { maxTurns: 50 },
-    "deepseek-v4-flash": { maxTurns: 20 },
-    "deepseek-v4-pro": { maxTurns: 35 },
-};
+import { omitExtensionKeys } from "./base.js";
+import { DEEPSEEK_POLICIES, anthropicVendorProfiles } from "./vendor-profiles.js";
 /**
  * DeepSeek over its Anthropic-compatible endpoint.
+ * @deprecated Prefer `deepseek({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.deepseek`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export class DeepSeekAnthropicProvider extends AnthropicProvider {
-    constructor(apiKey, model = "deepseek-v4-flash", retry, baseURL = endpointProfiles["deepseek.anthropic"].baseURL) {
-        super(apiKey, model, retry, {
-            baseURL,
-            authMode: "api-key",
-        });
-    }
-    providerName() {
-        return "deepseek";
-    }
-    runtimePolicy() {
-        return DEEPSEEK_POLICIES[this.model] ?? {};
+export class DeepSeekAnthropicProvider extends AnthropicCompatibleProvider {
+    constructor(apiKey, model, retry, baseURL) {
+        super(anthropicVendorProfiles.deepseek, apiKey, model, retry, baseURL);
     }
 }
+/**
+ * DeepSeek over its OpenAI-compatible endpoint. Reasoning is carried out-of-band as
+ * `reasoning_content`; replay persists DeepSeek's schema_version-2 envelope (with the
+ * native `tool_calls` blocks). Request shaping (`reasoning_effort` + `extra_body.thinking`)
+ * and replay are supplied via the OpenAIChatProvider Template-Method hooks; the streaming /
+ * tool-call machinery is inherited from the base class.
+ */
 export class DeepSeekProvider extends OpenAIChatProvider {
     constructor(apiKey, model = "deepseek-v4-flash", retry, baseURL = endpointProfiles["deepseek.openai"].baseURL) {
         super(apiKey, model, retry, baseURL);
@@ -53,146 +49,38 @@ export class DeepSeekProvider extends OpenAIChatProvider {
             return false;
         return extensions?.thinking !== false;
     }
-    async complete(context, tools, extensions) {
+    // DeepSeek strictly validates the request body and 400s on unknown params, so never send
+    // OpenAI's `prompt_cache_key` (DeepSeek auto prefix-caches anyway).
+    // Ref: https://api-docs.deepseek.com/quick_start/error_codes
+    cacheKeyParams() {
+        return {};
+    }
+    // Reasoning arrives out-of-band as `reasoning_content`, never as inline <thinking> tags.
+    usesInlineThinkingTags() {
+        return false;
+    }
+    exposeReasoningDelta(extensions) {
+        return (extensions?.exposeReasoning ?? false);
+    }
+    prepareExtensions(extensions) {
         const thinking = extensions?.thinking === false ? "disabled" : "enabled";
         const thinkingEnabled = thinking !== "disabled";
         const reasoningEffort = extensions?.reasoningEffort === "max" ? "max" : "high";
-        const requestExtensions = {
+        return {
             ...omitExtensionKeys(extensions, ["thinking", "reasoningEffort", "exposeReasoning", "extra_body", "reasoning_effort"]),
             __deepstrikeThinkingEnabled: thinkingEnabled,
-            // Re-thread the degrade control flag (omitExtensionKeys strips internal
-            // keys) so buildChatMessages can honor it; the wire-request omit drops it.
+            // Re-thread the degrade control flag (omitExtensionKeys strips internal keys) so
+            // buildChatMessages can honor it; the base requestExtensions omit keeps it off nothing.
             ...(extensions?.degradeMissingReasoningReplay === true ? { degradeMissingReasoningReplay: true } : {}),
             reasoning_effort: reasoningEffort,
             extra_body: { thinking: { type: thinking } },
         };
-        if (this.circuit.isOpen())
-            throw new Error("Circuit breaker open");
-        const msgs = this.buildChatMessages(context, requestExtensions);
-        let lastErr;
-        for (let i = 0; i < this.maxRetries; i++) {
-            try {
-                const resp = await this.client.chat.completions.create({
-                    ...this.requestExtensions(requestExtensions),
-                    model: this.model,
-                    messages: msgs,
-                    ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
-                });
-                this.circuit.recordSuccess();
-                const choice = resp.choices[0].message;
-                const nativeToolCalls = choice.tool_calls ?? [];
-                const toolCalls = this.chat.normalizeToolCalls(nativeToolCalls);
-                const content = choice.content ?? "";
-                this.rememberDeepSeekReplay(content, toolCalls, choice.reasoning_content, nativeToolCalls);
-                return { role: "assistant", content, tokenCount: resp.usage?.completion_tokens ?? resp.usage?.total_tokens, toolCalls };
-            }
-            catch (err) {
-                lastErr = err;
-                this.circuit.recordFailure();
-                if (i < this.maxRetries - 1)
-                    await new Promise(r => setTimeout(r, this.baseDelay * 2 ** i));
-            }
-        }
-        throw lastErr;
     }
-    async *stream(context, tools, extensions) {
-        const exposeReasoning = extensions?.exposeReasoning ?? false;
-        const thinking = extensions?.thinking === false ? "disabled" : "enabled";
-        const reasoningEffort = extensions?.reasoningEffort === "max" ? "max" : "high";
-        const msgs = this.buildChatMessages(context, extensions);
-        const toolCallBufs = {};
-        const emittedToolCallIndexes = new Set();
-        let reasoningContent = "";
-        let finalText = "";
-        const stream = await this.client.chat.completions.create({
-            ...omitExtensionKeys(extensions, [
-                "model", "messages", "tools", "stream", "stream_options", "extra_body", "reasoning_effort",
-                "exposeReasoning", "thinking", "reasoningEffort", "__deepstrikeThinkingEnabled",
-            ]),
-            model: this.model,
-            messages: msgs,
-            ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
-            stream: true,
-            stream_options: { include_usage: true },
-            reasoning_effort: reasoningEffort,
-            extra_body: { thinking: { type: thinking } },
-        });
-        let totalTokens = 0;
-        let inputTokens = 0;
-        let outputTokens = 0;
-        let cacheReadTokens = 0;
-        for await (const chunk of stream) {
-            if (chunk.usage) {
-                totalTokens = chunk.usage.total_tokens;
-                inputTokens = chunk.usage.prompt_tokens ?? 0;
-                outputTokens = chunk.usage.completion_tokens ?? 0;
-                cacheReadTokens = openAICachedPromptTokens(chunk.usage);
-                continue;
-            }
-            const choice = chunk.choices[0];
-            if (!choice)
-                continue;
-            const delta = choice.delta;
-            if (!delta)
-                continue;
-            if (exposeReasoning && delta.reasoning_content) {
-                yield { type: "thinking_delta", delta: delta.reasoning_content };
-            }
-            if (delta.reasoning_content)
-                reasoningContent += String(delta.reasoning_content);
-            if (delta.content) {
-                finalText += String(delta.content);
-                yield { type: "text_delta", delta: delta.content };
-            }
-            for (const tc of delta.tool_calls ?? []) {
-                const idx = tc.index;
-                if (!toolCallBufs[idx])
-                    toolCallBufs[idx] = { id: tc.id ?? "", name: "", argsBuf: "" };
-                if (tc.function?.name)
-                    toolCallBufs[idx].name += tc.function.name;
-                toolCallBufs[idx].argsBuf += tc.function?.arguments ?? "";
-            }
-            if (choice.finish_reason === "tool_calls") {
-                const toolCalls = Object.values(toolCallBufs).map(tb => ({
-                    id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
-                }));
-                this.rememberDeepSeekReplay(finalText, toolCalls, reasoningContent, nativeToolCallsFromBuffers(toolCallBufs));
-                for (const [index, tb] of Object.entries(toolCallBufs)) {
-                    const idx = Number(index);
-                    if (emittedToolCallIndexes.has(idx))
-                        continue;
-                    let args = {};
-                    try {
-                        args = JSON.parse(tb.argsBuf || "{}");
-                    }
-                    catch {
-                        args = {};
-                    }
-                    emittedToolCallIndexes.add(idx);
-                    yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
-                }
-            }
-        }
-        const toolCalls = Object.values(toolCallBufs).map(tb => ({
-            id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
-        }));
-        this.rememberDeepSeekReplay(finalText, toolCalls, reasoningContent, nativeToolCallsFromBuffers(toolCallBufs));
-        for (const [index, tb] of Object.entries(toolCallBufs)) {
-            const idx = Number(index);
-            if (emittedToolCallIndexes.has(idx))
-                continue;
-            let args = {};
-            try {
-                args = JSON.parse(tb.argsBuf || "{}");
-            }
-            catch {
-                args = {};
-            }
-            emittedToolCallIndexes.add(idx);
-            yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
-        }
-        if (totalTokens > 0)
-            yield { type: "usage", totalTokens, inputTokens, outputTokens, ...(cacheReadTokens > 0 ? { cacheReadInputTokens: cacheReadTokens } : {}) };
+    rememberCompleteReplay(content, toolCalls, r) {
+        this.rememberDeepSeekReplay(content, toolCalls, r.reasoningContent, r.nativeToolCalls);
+    }
+    rememberStreamReplay(content, toolCalls, r) {
+        this.rememberDeepSeekReplay(content, toolCalls, r.reasoningContent, r.nativeToolCalls);
     }
     rememberDeepSeekReplay(content, toolCalls, reasoningContent, nativeToolCalls) {
         if (typeof reasoningContent !== "string" || !reasoningContent.trim())
@@ -207,10 +95,3 @@ export class DeepSeekProvider extends OpenAIChatProvider {
         });
     }
 }
-function nativeToolCallsFromBuffers(toolCallBufs) {
-    return Object.values(toolCallBufs).map(tb => ({
-        id: tb.id,
-        type: "function",
-        function: { name: tb.name, arguments: tb.argsBuf || "{}" },
-    }));
-}

package/dist/providers/factories.d.ts

@@ -0,0 +1,31 @@
+import type { LLMProvider } from "../types.js";
+/** Options for a backend provider factory. `protocol` only applies to backends with both wires. */
+export interface BackendProviderOptions {
+    apiKey: string;
+    model?: string;
+    /** Override the endpoint base URL (defaults to the backend's profile for the chosen protocol). */
+    baseURL?: string;
+    retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    };
+    /** Wire protocol for dual-protocol backends. Defaults per backend (see each factory). */
+    protocol?: "openai" | "anthropic";
+}
+/** DeepSeek. Defaults to the OpenAI-compatible wire (richer reasoning-replay handling). */
+export declare function deepseek(o: BackendProviderOptions): LLMProvider;
+/** Moonshot Kimi. Defaults to the OpenAI-compatible wire. */
+export declare function kimi(o: BackendProviderOptions): LLMProvider;
+/** Alibaba Qwen / DashScope. Defaults to the OpenAI-compatible (DashScope) wire. */
+export declare function qwen(o: BackendProviderOptions): LLMProvider;
+/** Zhipu GLM. Defaults to the OpenAI-compatible wire. */
+export declare function glm(o: BackendProviderOptions): LLMProvider;
+/** MiniMax. Defaults to the Anthropic-compatible wire (the primary M2.x path). */
+export declare function minimax(o: BackendProviderOptions): LLMProvider;
+/** Google Gemini (single wire). */
+export declare function gemini(o: Omit<BackendProviderOptions, "protocol">): LLMProvider;
+/** Local Ollama (single wire, no API key). */
+export declare function ollama(o?: {
+    model?: string;
+    baseURL?: string;
+}): LLMProvider;

package/dist/providers/factories.js

@@ -0,0 +1,33 @@
+import { PROVIDER_REGISTRY } from "./registry.js";
+import { OllamaProvider } from "./ollama.js";
+function build(providerId, protocol, o) {
+    return PROVIDER_REGISTRY[`${providerId}:${protocol}`](o.apiKey, o.model, o.retry, o.baseURL);
+}
+/** 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);
+}
+/** Moonshot Kimi. Defaults to the OpenAI-compatible wire. */
+export function kimi(o) {
+    return build("kimi", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", 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);
+}
+/** Zhipu GLM. Defaults to the OpenAI-compatible wire. */
+export function glm(o) {
+    return build("glm", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", 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);
+}
+/** Google Gemini (single wire). */
+export function gemini(o) {
+    return PROVIDER_REGISTRY["gemini:gemini"](o.apiKey, o.model, o.retry, o.baseURL);
+}
+/** Local Ollama (single wire, no API key). */
+export function ollama(o = {}) {
+    return new OllamaProvider(o.model, o.baseURL);
+}

package/dist/providers/glm.d.ts

@@ -1,16 +1,17 @@
 import type { ProviderDescriptor, RuntimePolicy } from "../types.js";
-import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIChatProvider } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
 /**
  * GLM over its Anthropic-compatible endpoint.
+ * @deprecated Prefer `glm({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.glm`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export declare class GLMAnthropicProvider extends AnthropicProvider {
+export declare class GLMAnthropicProvider extends AnthropicCompatibleProvider {
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    protected providerName(): string;
-    runtimePolicy(): RuntimePolicy;
 }
 export declare class GLMProvider extends OpenAIChatProvider {
     constructor(apiKey: string, model?: string, retry?: {

package/dist/providers/glm.js

@@ -1,31 +1,16 @@
-import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIChatProvider } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
 import { endpointProfiles } from "./profiles.js";
-const GLM_POLICIES = {
-    "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 },
-};
+import { GLM_POLICIES, anthropicVendorProfiles } from "./vendor-profiles.js";
 /**
  * GLM over its Anthropic-compatible endpoint.
+ * @deprecated Prefer `glm({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.glm`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export class GLMAnthropicProvider extends AnthropicProvider {
-    constructor(apiKey, model = "glm-5.1", retry, baseURL = endpointProfiles["glm.anthropic"].baseURL) {
-        super(apiKey, model, retry, {
-            baseURL,
-            authMode: "api-key",
-        });
-    }
-    providerName() {
-        return "glm";
-    }
-    runtimePolicy() {
-        return GLM_POLICIES[this.model] ?? {};
+export class GLMAnthropicProvider extends AnthropicCompatibleProvider {
+    constructor(apiKey, model, retry, baseURL) {
+        super(anthropicVendorProfiles.glm, apiKey, model, retry, baseURL);
     }
 }
 export class GLMProvider extends OpenAIChatProvider {

package/dist/providers/kimi.d.ts

@@ -1,16 +1,17 @@
 import type { ProviderDescriptor, RuntimePolicy } from "../types.js";
-import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIChatProvider } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
 /**
  * Kimi over its Anthropic-compatible endpoint.
+ * @deprecated Prefer `kimi({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.kimi`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export declare class KimiAnthropicProvider extends AnthropicProvider {
+export declare class KimiAnthropicProvider extends AnthropicCompatibleProvider {
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    protected providerName(): string;
-    runtimePolicy(): RuntimePolicy;
 }
 export declare class KimiProvider extends OpenAIChatProvider {
     constructor(apiKey: string, model?: string, retry?: {