@deepstrike/sdk 0.2.30 → 0.2.32

package/dist/harness/harness.d.ts

@@ -126,10 +126,11 @@ export interface HarnessLoopOptions {
 }
 export declare class HarnessLoop {
     private runner;
-    private evalProvider;
     private maxAttempts;
     private skillDir?;
-    private verdictFn?;
+    /** How each attempt is judged. Hybrid (host verdictFn → LLM eval) when a verdictFn is supplied,
+     *  otherwise the built-in LLM eval. The loop just calls `this.judge.judge(...)`. */
+    private judge;
     constructor(runner: RuntimeRunner, evalProvider: import("../types.js").LLMProvider, options?: HarnessLoopOptions);
     run(request: HarnessRequest): Promise<HarnessOutcome>;
     stream(request: HarnessRequest): AsyncIterable<HarnessEvent>;

package/dist/harness/harness.js

@@ -1,7 +1,7 @@
 import { collectText } from "../runtime/runner.js";
 import { writeFile } from "fs/promises";
 import path from "path";
-import { getKernel } from "../kernel.js";
+import { HybridJudge, VerdictFnJudge, LlmEvalJudge } from "./judge.js";
 async function runOnce(runner, req) {
     let text = "";
     let done;
@@ -58,16 +58,19 @@ export class EvalLoopHarness {
 }
 export class HarnessLoop {
     runner;
-    evalProvider;
     maxAttempts;
     skillDir;
-    verdictFn;
+    /** How each attempt is judged. Hybrid (host verdictFn → LLM eval) when a verdictFn is supplied,
+     *  otherwise the built-in LLM eval. The loop just calls `this.judge.judge(...)`. */
+    judge;
     constructor(runner, evalProvider, options = {}) {
         this.runner = runner;
-        this.evalProvider = evalProvider;
         this.maxAttempts = options.maxAttempts ?? 3;
         this.skillDir = options.skillDir;
-        this.verdictFn = options.verdictFn;
+        const llmJudge = new LlmEvalJudge(evalProvider);
+        this.judge = options.verdictFn
+            ? new HybridJudge(new VerdictFnJudge(options.verdictFn), llmJudge)
+            : llmJudge;
     }
     async run(request) {
         let last;
@@ -93,7 +96,6 @@ export class HarnessLoop {
         };
     }
     async *stream(request) {
-        const kernel = getKernel();
         const criteria = request.criteria ?? [];
         let currentGoal = request.goal;
         let lastIterations = 0;
@@ -135,35 +137,13 @@ export class HarnessLoop {
                 }
             }
             yield { type: "supervising" };
-            // I3.2 (A2/A3): host-supplied `verdictFn` short-circuits the LLM eval. When it returns a
-            // Verdict, use it; when it returns undefined, defer to the built-in eval (hybrid path).
-            let verdict;
-            let skillCandidate;
-            if (this.verdictFn) {
-                verdict = await this.verdictFn({ goal: request.goal, criteria, attempt, result: lastResult });
-            }
-            if (!verdict) {
-                // #6 (0.5.0): the eval/verdict compute is the kernel's stateless free functions (was the
-                // EvalPipeline state machine). Build the eval prompt, call the eval LLM, parse the verdict.
-                const evalMsgs = kernel.buildEvalMessages(request.goal, criteria, lastResult, attempt, true);
-                let evalText = "";
-                const evalContext = {
-                    systemText: evalMsgs.filter((m) => m.role === "system").map((m) => m.content).join("\n\n"),
-                    turns: evalMsgs.filter((m) => m.role !== "system"),
-                };
-                for await (const evt of this.evalProvider.stream(evalContext, [], undefined)) {
-                    if (evt.type === "text_delta")
-                        evalText += evt.delta;
-                }
-                const parsed = kernel.parseVerdict(evalText);
-                verdict = {
-                    passed: parsed.passed,
-                    overallScore: parsed.overallScore,
-                    feedback: parsed.feedback,
-                    details: parsed.details ?? [],
-                };
-                skillCandidate = parsed.skillCandidate;
-            }
+            // I3.2 (A2/A3): the judge Strategy encapsulates "host verdictFn short-circuit → built-in LLM
+            // eval". HarnessLoop's judge always terminates in LlmEvalJudge, so a verdict is guaranteed.
+            const judged = await this.judge.judge({ goal: request.goal, criteria, attempt, result: lastResult });
+            const verdict = judged?.verdict;
+            const skillCandidate = judged?.skillCandidate;
+            if (!verdict)
+                throw new Error("HarnessLoop: judge produced no verdict");
             if (verdict.passed) {
                 if (skillCandidate && this.skillDir) {
                     const { name, description, whenToUse, content } = skillCandidate;

package/dist/harness/judge.d.ts

@@ -0,0 +1,42 @@
+import type { LLMProvider } from "../types.js";
+import { getKernel } from "../kernel.js";
+import type { Criterion, Verdict, VerdictFn } from "./harness.js";
+export type SkillCandidate = ReturnType<ReturnType<typeof getKernel>["parseVerdict"]>["skillCandidate"];
+export interface JudgeContext {
+    goal: string;
+    criteria: Criterion[];
+    attempt: number;
+    result: string;
+}
+export interface JudgeResult {
+    verdict: Verdict;
+    /** Skill the judge proposes extracting on pass (LLM-eval path only). */
+    skillCandidate?: SkillCandidate;
+}
+/** Decides whether one attempt's result meets the criteria. Returning `undefined` defers to a
+ *  fallback judge (enables hybrid host/LLM judgment). */
+export interface AttemptJudge {
+    judge(ctx: JudgeContext): Promise<JudgeResult | undefined>;
+}
+/** Wraps a host-supplied `VerdictFn`. Returns `undefined` (defer) when the function does. */
+export declare class VerdictFnJudge implements AttemptJudge {
+    private readonly fn;
+    constructor(fn: VerdictFn);
+    judge(ctx: JudgeContext): Promise<JudgeResult | undefined>;
+}
+/** The built-in LLM eval: render the kernel eval prompt, stream the eval provider, parse the
+ *  verdict. Always produces a JudgeResult (never defers). */
+export declare class LlmEvalJudge implements AttemptJudge {
+    private readonly evalProvider;
+    private readonly extractSkillOnPass;
+    constructor(evalProvider: LLMProvider, extractSkillOnPass?: boolean);
+    judge(ctx: JudgeContext): Promise<JudgeResult>;
+}
+/** Try `primary`; if it defers (`undefined`), use `fallback`. Models HarnessLoop's
+ *  "verdictFn short-circuits, else built-in LLM eval" hybrid judgment. */
+export declare class HybridJudge implements AttemptJudge {
+    private readonly primary;
+    private readonly fallback;
+    constructor(primary: AttemptJudge, fallback: AttemptJudge);
+    judge(ctx: JudgeContext): Promise<JudgeResult | undefined>;
+}

package/dist/harness/judge.js

@@ -0,0 +1,58 @@
+import { getKernel } from "../kernel.js";
+/** Wraps a host-supplied `VerdictFn`. Returns `undefined` (defer) when the function does. */
+export class VerdictFnJudge {
+    fn;
+    constructor(fn) {
+        this.fn = fn;
+    }
+    async judge(ctx) {
+        const verdict = await this.fn({ goal: ctx.goal, criteria: ctx.criteria, attempt: ctx.attempt, result: ctx.result });
+        return verdict ? { verdict } : undefined;
+    }
+}
+/** The built-in LLM eval: render the kernel eval prompt, stream the eval provider, parse the
+ *  verdict. Always produces a JudgeResult (never defers). */
+export class LlmEvalJudge {
+    evalProvider;
+    extractSkillOnPass;
+    constructor(evalProvider, extractSkillOnPass = true) {
+        this.evalProvider = evalProvider;
+        this.extractSkillOnPass = extractSkillOnPass;
+    }
+    async judge(ctx) {
+        const kernel = getKernel();
+        const evalMsgs = kernel.buildEvalMessages(ctx.goal, ctx.criteria, ctx.result, ctx.attempt, this.extractSkillOnPass);
+        const evalContext = {
+            systemText: evalMsgs.filter((m) => m.role === "system").map((m) => m.content).join("\n\n"),
+            turns: evalMsgs.filter((m) => m.role !== "system"),
+        };
+        let evalText = "";
+        for await (const evt of this.evalProvider.stream(evalContext, [], undefined)) {
+            if (evt.type === "text_delta")
+                evalText += evt.delta;
+        }
+        const parsed = kernel.parseVerdict(evalText);
+        return {
+            verdict: {
+                passed: parsed.passed,
+                overallScore: parsed.overallScore,
+                feedback: parsed.feedback,
+                details: parsed.details ?? [],
+            },
+            skillCandidate: parsed.skillCandidate,
+        };
+    }
+}
+/** Try `primary`; if it defers (`undefined`), use `fallback`. Models HarnessLoop's
+ *  "verdictFn short-circuits, else built-in LLM eval" hybrid judgment. */
+export class HybridJudge {
+    primary;
+    fallback;
+    constructor(primary, fallback) {
+        this.primary = primary;
+        this.fallback = fallback;
+    }
+    async judge(ctx) {
+        return (await this.primary.judge(ctx)) ?? (await this.fallback.judge(ctx));
+    }
+}

package/dist/index.d.ts

@@ -6,6 +6,14 @@ export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export type { ExecutionPlane, RunContext } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
 export type { SessionLog, SessionEvent } from "./runtime/session-log.js";
+export { InMemoryGroupBudgetStore, SessionLogGroupBudgetStore } from "./runtime/run-group.js";
+export type { RunGroup, GroupBudgetStore, GroupLedger, GroupCharge, GroupMember } from "./runtime/run-group.js";
+export { InMemoryEventStream, isVisibleTo } from "./runtime/event-stream.js";
+export type { EventStream, BlackboardEvent, EventViewer } from "./runtime/event-stream.js";
+export { reactByMention, directorDriven, roundRobin, firstNonEmpty, union } from "./runtime/turn-policy.js";
+export type { TurnPolicy, PeerView } from "./runtime/turn-policy.js";
+export { ReactiveSession, readRecentTool } from "./runtime/reactive-session.js";
+export type { ReactiveSessionOptions, ReactivePeerSpec, EmitEvent, Reaction, ReactorTurn, ReactorContext } from "./runtime/reactive-session.js";
 export { tool, streamingTool } from "./tools/index.js";
 export type { RegisteredTool, ToolExecContext } from "./tools/index.js";
 export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.js";

package/dist/index.js

@@ -16,6 +16,10 @@ export { RuntimeRunner, collectText } from "./runtime/runner.js";
 // ── Execution plane + session log (the defaults) ────────────────────────────
 export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
+export { InMemoryGroupBudgetStore, SessionLogGroupBudgetStore } from "./runtime/run-group.js";
+export { InMemoryEventStream, isVisibleTo } from "./runtime/event-stream.js";
+export { reactByMention, directorDriven, roundRobin, firstNonEmpty, union } from "./runtime/turn-policy.js";
+export { ReactiveSession, readRecentTool } from "./runtime/reactive-session.js";
 // ── Tool authoring ──────────────────────────────────────────────────────────
 export { tool, streamingTool } from "./tools/index.js";
 export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.js";

package/dist/kernel.d.ts

@@ -17,8 +17,12 @@ export interface MemoryWriteRateLimit {
     windowMs: number;
 }
 export interface ResourceQuota {
-    /** Max sub-agents in the `running` state at once; further spawns are denied while at cap. */
+    /** Max sub-agents in the `running` state at once; further spawns are denied while at cap.
+     *  Instantaneous — vehicle-scoped (cannot span stateless replicas). */
     maxConcurrentSubagents?: number;
+    /** L1 (RunGroup): max sub-agents spawned *cumulatively* across the governance domain. With a
+     *  `runGroup`, this spans N stateless top-level runs (seeded/charged via the group ledger). */
+    maxTotalSubagents?: number;
     /** Max sub-agent nesting depth (direct children of the root loop are depth 1). */
     maxSpawnDepth?: number;
     /** Rolling-window memory-write rate limit: at most `maxWrites` per any `windowMs` span. */
@@ -135,6 +139,8 @@ export interface KernelRuntimeInstance {
     step(inputJson: string): string;
     isTerminal(): boolean;
     turn(): number;
+    /** L1 (RunGroup): cumulative sub-agent spawns this run, for charging the group ledger at run end. */
+    localSubagentsSpawned(): number;
     recoveryContentBytes(): number;
     render(): RenderedContext;
     drainNewMessages(): Message[];

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/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 || "{}" },
-    }));
-}