@deepstrike/sdk 0.2.5 → 0.2.7

package/README.md

@@ -222,6 +222,23 @@ const runner = new RuntimeRunner({
   timeoutMs: 60_000,
   schedulerBudget: { maxWallMs: 300_000 },
 
+  // Resource quotas (M2) — enforced at the kernel syscall trap. Opt-in; omit for unbounded.
+  resourceQuota: {
+    maxConcurrentSubagents: 4,                       // deny spawn while at cap
+    maxSpawnDepth: 2,                                // deny spawn past nesting depth
+    memoryWritesPerWindow: { maxWrites: 20, windowMs: 60_000 }, // rate-limit writeMemory
+  },
+
+  // Long-term memory policy (set_memory_policy) — opt-in, kernel-enforced; omit for defaults.
+  memoryPolicy: {
+    memoryPath: "./.memory",     // where the SDK persists/scans memories (SDK-consumed)
+    staleWarningDays: 30,        // flag recalled memories older than this (SDK-consumed)
+    retrievalTopK: 5,            // kernel caps query_memory requested_k to this
+    validationEnabled: true,     // false → admit writes without validation
+    maxContentBytes: 10_000,     // override write_memory content-size limit
+    maxNameLength: 100,          // override write_memory name-length limit
+  },
+
   // Agent OS native profile (defaults shown)
   governancePolicy: DEFAULT_NATIVE_GOVERNANCE_POLICY,
   attentionPolicy: DEFAULT_NATIVE_ATTENTION_POLICY, // SignalRouter queue size 64
@@ -260,6 +277,8 @@ const runner = new RuntimeRunner({
 |--------|---------|
 | `governancePolicy` | Declarative deny / ask_user / rate-limit / param rules loaded into the kernel before `start_run` |
 | `attentionPolicy` | In-kernel signal router queue size (default 64) |
+| `resourceQuota` | M2 declarative limits — `maxConcurrentSubagents` / `maxSpawnDepth` / `memoryWritesPerWindow` — enforced at the kernel syscall trap (`set_resource_quota`); over-quota spawns roll back, over-rate writes surface as `memory_validation_failed` |
+| `memoryPolicy` | Long-term memory config sent as `set_memory_policy` and **kernel-enforced**: `validationEnabled: false` admits writes without validation, `maxContentBytes` / `maxNameLength` override validation limits, `retrievalTopK` caps `query_memory` breadth; `memoryPath` / `staleWarningDays` are SDK-consumed (requires `dreamStore` + `agentId` to enable memory) |
 | `onPermissionRequest` | Resolves `tool_gated` + `suspended` → kernel `resume` with approved/denied call IDs |
 | `compressionStore` | Writes archived messages on `compressed` observations |
 | `asyncSummarizer` | Background LLM summary after compression; stored as `summary_upgraded` |

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
-export type { RuntimeOptions } from "./runtime/runner.js";
+export type { RuntimeOptions, SchedulerBudget } from "./runtime/runner.js";
+export type { MemoryPolicy, MemoryWriteRateLimit, ResourceQuota } from "./kernel.js";
+export { createTournament, createLoopUntilDone } from "./kernel.js";
+export type { TournamentMatch, TournamentAction, StopConditionSpec, RoundReport, LoopAction, } from "./kernel.js";
 export { KernelPrimitivesDashboard } from "./runtime/kernel-primitives-dashboard.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
@@ -8,7 +11,8 @@ 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 { DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, } from "./runtime/os-profile.js";
+export { DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, assertNativeProfile, osProfile, } from "./runtime/os-profile.js";
+export type { NativeOsProfile, OsProfileId } from "./runtime/os-profile.js";
 export { rebuildOsSnapshotFromSessionEvents, sessionLogHasRequiredCategories, } from "./runtime/os-snapshot.js";
 export type { OsSnapshot } from "./runtime/os-snapshot.js";
 export { categoryForKind, kernelObservationToSessionEvent } from "./runtime/kernel-event-log.js";
@@ -29,7 +33,7 @@ export { DeepSeekProvider } from "./providers/deepseek.js";
 export { KimiProvider } from "./providers/kimi.js";
 export { QwenProvider } from "./providers/qwen.js";
 export { GeminiProvider } from "./providers/gemini.js";
-export { MiniMaxProvider } from "./providers/minimax.js";
+export { MiniMaxAnthropicProvider, MiniMaxOpenAIProvider } from "./providers/minimax.js";
 export { OllamaProvider } from "./providers/ollama.js";
 export { CircuitBreaker, normalizeToolCall } from "./providers/base.js";
 export { OpenAIChatAdapter } from "./providers/openai-chat.js";
@@ -56,8 +60,8 @@ export type { GovernanceVerdict, GovernancePolicy, GovernanceConstraint } from "
 export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
 export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions, QualityGate } from "./harness/harness.js";
 export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, ProviderReplay, RenderedContext, } from "./types.js";
-export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, } from "./types/agent.js";
-export { agentIdentitySub, agentRunSpecToKernel, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, } from "./types/agent.js";
+export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpec, WorkflowNodeSpec, WorkflowTaskSpec, WorkflowSpawnInfo, } from "./types/agent.js";
+export { agentIdentitySub, agentRunSpecToKernel, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, workflowSpecToKernel, fanoutSynthesize, generateAndFilter, verifyRules, } from "./types/agent.js";
 export type { AcceptanceCriterion, VerificationContract, ContractCheckResult, } from "./collaboration/contract.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
 export { AgentPool } from "./collaboration/pool.js";

package/dist/index.js

@@ -1,11 +1,12 @@
 // ── Runtime (Layer 1.5) ────────────────────────────────────────────────────
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
+export { createTournament, createLoopUntilDone } from "./kernel.js";
 export { KernelPrimitivesDashboard } from "./runtime/kernel-primitives-dashboard.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
-export { DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, } from "./runtime/os-profile.js";
+export { DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, assertNativeProfile, osProfile, } from "./runtime/os-profile.js";
 export { rebuildOsSnapshotFromSessionEvents, sessionLogHasRequiredCategories, } from "./runtime/os-snapshot.js";
 export { categoryForKind, kernelObservationToSessionEvent } from "./runtime/kernel-event-log.js";
 export { NullArchiveStore, FileArchiveStore } from "./runtime/archive.js";
@@ -20,7 +21,7 @@ export { DeepSeekProvider } from "./providers/deepseek.js";
 export { KimiProvider } from "./providers/kimi.js";
 export { QwenProvider } from "./providers/qwen.js";
 export { GeminiProvider } from "./providers/gemini.js";
-export { MiniMaxProvider } from "./providers/minimax.js";
+export { MiniMaxAnthropicProvider, MiniMaxOpenAIProvider } from "./providers/minimax.js";
 export { OllamaProvider } from "./providers/ollama.js";
 export { CircuitBreaker, normalizeToolCall } from "./providers/base.js";
 export { OpenAIChatAdapter } from "./providers/openai-chat.js";
@@ -39,7 +40,7 @@ export { PermissionManager, PermissionMode } from "./safety/permissions.js";
 export { Governance, governancePolicyToKernelEvent } from "./governance.js";
 // ── Harness ────────────────────────────────────────────────────────────────
 export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
-export { agentIdentitySub, agentRunSpecToKernel, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, } from "./types/agent.js";
+export { agentIdentitySub, agentRunSpecToKernel, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, workflowSpecToKernel, fanoutSynthesize, generateAndFilter, verifyRules, } from "./types/agent.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
 export { AgentPool } from "./collaboration/pool.js";
 export { KERNEL_ROLE_MAP } from "./collaboration/pool.js";

package/dist/kernel.d.ts

@@ -4,6 +4,49 @@ export interface GovernanceVerdict {
     reason?: string;
     retryAfterMs?: number;
 }
+/**
+ * M2 资源配额 — declarative resource limits enforced at the kernel's single syscall trap.
+ *
+ * Installed through the versioned JSON event ABI (`set_resource_quota`), not a side-channel
+ * setter, so quota config is replayable and session-loggable like governance/scheduler config.
+ * Every field is optional; an omitted field imposes no limit, and omitting the quota entirely
+ * preserves the pre-M2 behavior of admitting all spawn / memory-write syscalls.
+ */
+export interface MemoryWriteRateLimit {
+    maxWrites: number;
+    windowMs: number;
+}
+export interface ResourceQuota {
+    /** Max sub-agents in the `running` state at once; further spawns are denied while at cap. */
+    maxConcurrentSubagents?: 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. */
+    memoryWritesPerWindow?: MemoryWriteRateLimit;
+}
+/**
+ * Long-term memory policy — declarative knobs for the kernel's memory subsystem.
+ *
+ * Installed through the versioned JSON event ABI (`set_memory_policy`), the same channel as
+ * governance / scheduler / quota config, so memory configuration is replayable and
+ * session-loggable rather than a side-channel setter. Installing the policy is opt-in and
+ * kernel-enforced; omitted fields fall back to the kernel defaults (empty path, 2-day stale
+ * warning, top-5 retrieval, validation on). Enabling memory is still `dreamStore` + `agentId`.
+ */
+export interface MemoryPolicy {
+    /** Filesystem root the SDK uses to persist/scan memories; carried for SDK recall I/O. */
+    memoryPath?: string;
+    /** Age after which a recalled memory is flagged stale (days); consumed SDK-side. */
+    staleWarningDays?: number;
+    /** Upper bound on retrieval breadth: the kernel clamps `query_memory` top-k to this. */
+    retrievalTopK?: number;
+    /** When false, the kernel admits every `write_memory` without validation. */
+    validationEnabled?: boolean;
+    /** Override the kernel's `write_memory` content-size limit (bytes). */
+    maxContentBytes?: number;
+    /** Override the kernel's `write_memory` name-length limit. */
+    maxNameLength?: number;
+}
 export interface GovernanceInstance {
     setIdentity(agentId: string, sessionId: string): void;
     addPermissionRule(pattern: string, action: "allow" | "deny" | "ask_user"): void;
@@ -104,6 +147,54 @@ export interface KernelRuntimeInstance {
     drainNewMessages(): Message[];
     preservedRefs(): string[];
 }
+/** One pairwise match-up in a tournament round. */
+export interface TournamentMatch {
+    id: number;
+    left: string;
+    right: string;
+}
+/** Discriminated action returned by {@link TournamentInstance} methods. */
+export interface TournamentAction {
+    kind: "judgeRound" | "done";
+    /** `judgeRound`: 1-based round number. */
+    round?: number;
+    /** `judgeRound`: run one fresh-context judge per match (parallelisable). */
+    matches?: TournamentMatch[];
+    /** `done`: the winning entrant id. */
+    winner?: string;
+    /** `done`: number of rounds played. */
+    roundsUsed?: number;
+}
+interface TournamentInstance {
+    start(): TournamentAction;
+    feedRound(winners: string[]): TournamentAction;
+    isDone(): boolean;
+}
+/** A single loop stop predicate. `maxRounds` is required when `kind === "maxRounds"`. */
+export interface StopConditionSpec {
+    kind: "noNewFindings" | "noErrors" | "maxRounds";
+    maxRounds?: number;
+}
+/** What the SDK reports after running a loop round's worker. */
+export interface RoundReport {
+    newFindings: number;
+    errors: number;
+}
+/** Discriminated action returned by {@link LoopUntilDoneInstance} methods. */
+export interface LoopAction {
+    kind: "spawn" | "done";
+    /** `spawn`: 1-based round number to run. */
+    round?: number;
+    /** `done`: number of rounds run. */
+    roundsUsed?: number;
+    /** `done`: which condition fired. */
+    reason?: "noNewFindings" | "noErrors" | "maxRounds";
+}
+interface LoopUntilDoneInstance {
+    start(): LoopAction;
+    feed(report: RoundReport): LoopAction;
+    isDone(): boolean;
+}
 interface KernelModule {
     Governance: new (defaultAction?: "allow" | "deny" | "ask_user") => GovernanceInstance;
     KernelRuntime: new (policy: {
@@ -117,6 +208,12 @@ interface KernelModule {
         extractSkillOnPass?: boolean;
     }) => EvalPipelineInstance;
     IdlePipeline: new (agentId: string) => IdlePipelineInstance;
+    Tournament: new (entrants: string[]) => TournamentInstance;
+    LoopUntilDone: new (conditions: StopConditionSpec[]) => LoopUntilDoneInstance;
 }
+/** Create a single-elimination tournament (pairwise comparative judging). Throws if `entrants` is empty. */
+export declare function createTournament(entrants: string[]): TournamentInstance;
+/** Create a loop-until-done state machine. A `maxRounds` backstop is injected if none is given. */
+export declare function createLoopUntilDone(conditions: StopConditionSpec[]): LoopUntilDoneInstance;
 export declare function getKernel(): KernelModule;
 export {};

package/dist/kernel.js

@@ -2,6 +2,14 @@ import { createRequire } from "module";
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+/** Create a single-elimination tournament (pairwise comparative judging). Throws if `entrants` is empty. */
+export function createTournament(entrants) {
+    return new (getKernel().Tournament)(entrants);
+}
+/** Create a loop-until-done state machine. A `maxRounds` backstop is injected if none is given. */
+export function createLoopUntilDone(conditions) {
+    return new (getKernel().LoopUntilDone)(conditions);
+}
 const cjsRequire = createRequire(import.meta.url);
 let cachedKernel;
 function resolveCoreModule() {

package/dist/memory/agent.d.ts

@@ -10,53 +10,8 @@
  * - SDK performs I/O and selection
  * - LLM (Sonnet) acts as selector, not vector similarity
  */
-import type { SessionData, MemoryEntry } from "./protocols.js";
-/**
- * Memory metadata (matches kernel MemoryMetadata structure).
- */
-export interface MemoryMetadata {
-    name: string;
-    description: string;
-    kind?: MemoryKind;
-    created_at: number;
-    updated_at: number;
-    session_id?: string;
-    user_role?: string;
-    expertise_level?: string;
-    preference_rule?: string;
-    approved_pattern?: string;
-    project_phase?: string;
-    relative_date?: string;
-    external_url?: string;
-    ticket_ref?: string;
-}
-/**
- * Memory kind (4 types, mirroring Claude Code).
- */
-export type MemoryKind = "user" | "feedback" | "project" | "reference";
-/**
- * Memory write request (SDK → kernel).
- */
-export interface MemoryWriteRequest {
-    metadata: MemoryMetadata;
-    content: string;
-}
-/**
- * Memory query request (kernel → SDK).
- */
-export interface MemoryQuery {
-    current_context: string;
-    active_tools: string[];
-    already_surfaced: string[];
-    top_k: number;
-}
-/**
- * Memory retrieval response (SDK → kernel).
- */
-export interface MemoryRetrieval {
-    selected_memory_ids: string[];
-    selection_rationale: string;
-}
+import type { SessionData, MemoryEntry, MemoryKind, MemoryMetadata, MemoryWriteRequest, MemoryQuery, MemoryRetrieval } from "./protocols.js";
+export type { MemoryKind, MemoryMetadata, MemoryWriteRequest, MemoryQuery, MemoryRetrieval, } from "./protocols.js";
 /**
  * Memory index entry (from MEMORY.md).
  */

package/dist/providers/anthropic.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ProviderReplay, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+import type { Message, ProviderDescriptor, ProviderReplay, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
 interface AnthropicProviderOptions {
     baseURL?: string;
     authMode?: "api-key" | "bearer";
@@ -15,6 +15,9 @@ export declare class AnthropicProvider implements LLMProvider {
         baseDelay: number;
     }, options?: AnthropicProviderOptions);
     runtimePolicy(): RuntimePolicy;
+    /** Identity advertised in the descriptor; overridden by Anthropic-compatible vendors (e.g. MiniMax). */
+    protected providerName(): string;
+    descriptor(): ProviderDescriptor;
     peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
     seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
     private buildTools;

package/dist/providers/anthropic.js

@@ -34,6 +34,26 @@ export class AnthropicProvider {
     runtimePolicy() {
         return CLAUDE_POLICIES[this.model] ?? {};
     }
+    /** Identity advertised in the descriptor; overridden by Anthropic-compatible vendors (e.g. MiniMax). */
+    providerName() {
+        return "anthropic";
+    }
+    descriptor() {
+        return {
+            provider: this.providerName(),
+            protocol: "anthropic-messages",
+            model: this.model,
+            reasoning: {
+                supported: true,
+                preserveAcrossToolTurns: true,
+                requiresReplayForToolTurns: true,
+            },
+            toolCalls: {
+                supported: true,
+                requiresStrictPairing: true,
+            },
+        };
+    }
     peekProviderReplay(message) {
         const blocks = this.nativeAssistantBlocks.get(assistantReplayKey(message));
         return blocks?.length ? { native_blocks: blocks } : undefined;
@@ -41,7 +61,14 @@ export class AnthropicProvider {
     seedProviderReplay(message, replay) {
         if (replay.native_blocks?.length) {
             this.nativeAssistantBlocks.set(assistantReplayKey(message), replay.native_blocks);
+            return;
         }
+        // Legacy log without persisted native blocks: reconstruct neutral
+        // text + tool_use blocks from the transcript so a tool-use turn can be
+        // replayed. Thinking blocks were never persisted, so they are not recovered.
+        const blocks = reconstructAnthropicBlocks(message);
+        if (blocks.length)
+            this.nativeAssistantBlocks.set(assistantReplayKey(message), blocks);
     }
     buildTools(tools) {
         return tools.map((t, i) => ({
@@ -206,3 +233,27 @@ export class AnthropicProvider {
         this.nativeAssistantBlocks.set(assistantReplayKey(message), blocks);
     }
 }
+/**
+ * Reconstruct Anthropic assistant content blocks from a neutral transcript when
+ * no provider replay was persisted. Only meaningful for tool-use turns: a plain
+ * text turn needs no native blocks to replay.
+ */
+function reconstructAnthropicBlocks(message) {
+    const toolCalls = message.toolCalls ?? [];
+    if (!toolCalls.length)
+        return [];
+    const blocks = [];
+    if (message.content)
+        blocks.push({ type: "text", text: message.content });
+    for (const tc of toolCalls) {
+        let input = {};
+        try {
+            input = JSON.parse(tc.arguments || "{}");
+        }
+        catch {
+            input = {};
+        }
+        blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input });
+    }
+    return blocks;
+}

package/dist/providers/catalog.js

@@ -3,7 +3,7 @@ import { OpenAIChatProvider } from "./openai.js";
 import { DeepSeekProvider } from "./deepseek.js";
 import { KimiProvider } from "./kimi.js";
 import { OpenAIResponsesProvider } from "./openai-responses.js";
-import { MiniMaxProvider } from "./minimax.js";
+import { MiniMaxAnthropicProvider, MiniMaxOpenAIProvider } from "./minimax.js";
 import { QwenProvider } from "./qwen.js";
 import { GeminiProvider } from "./gemini.js";
 import { GLMProvider } from "./glm.js";
@@ -43,7 +43,10 @@ export function createProvider(options) {
         }
     }
     if (providerId === "minimax" && endpoint.protocol === "anthropic-messages") {
-        return new MiniMaxProvider(options.apiKey, model, options.retry, baseURL);
+        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 === "openai-chat") {
         return new DeepSeekProvider(options.apiKey, model, options.retry, baseURL);

package/dist/providers/deepseek.d.ts

@@ -1,4 +1,4 @@
-import type { Message, RenderedContext, ToolSchema, StreamEvent, RuntimePolicy } from "../types.js";
+import type { Message, ProviderDescriptor, RenderedContext, ToolSchema, StreamEvent, RuntimePolicy } from "../types.js";
 import { OpenAIChatProvider } from "./openai.js";
 export declare class DeepSeekProvider extends OpenAIChatProvider {
     constructor(apiKey: string, model?: string, retry?: {
@@ -6,6 +6,9 @@ export declare class DeepSeekProvider extends OpenAIChatProvider {
         baseDelay: number;
     }, baseURL?: string);
     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>;
+    private rememberDeepSeekReplay;
 }

package/dist/providers/deepseek.js

@@ -15,20 +15,71 @@ export class DeepSeekProvider extends OpenAIChatProvider {
     runtimePolicy() {
         return DEEPSEEK_POLICIES[this.model] ?? {};
     }
+    descriptor() {
+        return {
+            provider: "deepseek",
+            protocol: "openai-chat",
+            model: this.model,
+            reasoning: {
+                supported: true,
+                preserveAcrossToolTurns: true,
+                requiresReplayForToolTurns: true,
+            },
+            toolCalls: {
+                supported: true,
+                requiresStrictPairing: true,
+            },
+        };
+    }
+    requireNonEmptyReasoningReplayForToolTurns(extensions) {
+        if (extensions?.__deepstrikeThinkingEnabled === false)
+            return false;
+        return extensions?.thinking !== false;
+    }
     async complete(context, tools, extensions) {
         const thinking = extensions?.thinking === false ? "disabled" : "enabled";
+        const thinkingEnabled = thinking !== "disabled";
         const reasoningEffort = extensions?.reasoningEffort === "max" ? "max" : "high";
-        return super.complete(context, tools, {
+        const requestExtensions = {
             ...omitExtensionKeys(extensions, ["thinking", "reasoningEffort", "exposeReasoning", "extra_body", "reasoning_effort"]),
+            __deepstrikeThinkingEnabled: thinkingEnabled,
             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.chat.buildMessages(context);
+        const msgs = this.buildChatMessages(context, extensions);
         const toolCallBufs = {};
         const emittedToolCallIndexes = new Set();
         let reasoningContent = "";
@@ -36,7 +87,7 @@ export class DeepSeekProvider extends OpenAIChatProvider {
         const stream = await this.client.chat.completions.create({
             ...omitExtensionKeys(extensions, [
                 "model", "messages", "tools", "stream", "stream_options", "extra_body", "reasoning_effort",
-                "exposeReasoning", "thinking", "reasoningEffort",
+                "exposeReasoning", "thinking", "reasoningEffort", "__deepstrikeThinkingEnabled",
             ]),
             model: this.model,
             messages: msgs,
@@ -83,7 +134,7 @@ export class DeepSeekProvider extends OpenAIChatProvider {
                 const toolCalls = Object.values(toolCallBufs).map(tb => ({
                     id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
                 }));
-                this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
+                this.rememberDeepSeekReplay(finalText, toolCalls, reasoningContent, nativeToolCallsFromBuffers(toolCallBufs));
                 for (const [index, tb] of Object.entries(toolCallBufs)) {
                     const idx = Number(index);
                     if (emittedToolCallIndexes.has(idx))
@@ -103,9 +154,7 @@ export class DeepSeekProvider extends OpenAIChatProvider {
         const toolCalls = Object.values(toolCallBufs).map(tb => ({
             id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
         }));
-        if (toolCalls.length || reasoningContent) {
-            this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
-        }
+        this.rememberDeepSeekReplay(finalText, toolCalls, reasoningContent, nativeToolCallsFromBuffers(toolCallBufs));
         for (const [index, tb] of Object.entries(toolCallBufs)) {
             const idx = Number(index);
             if (emittedToolCallIndexes.has(idx))
@@ -123,4 +172,23 @@ export class DeepSeekProvider extends OpenAIChatProvider {
         if (totalTokens > 0)
             yield { type: "usage", totalTokens, inputTokens, outputTokens };
     }
+    rememberDeepSeekReplay(content, toolCalls, reasoningContent, nativeToolCalls) {
+        if (typeof reasoningContent !== "string" || !reasoningContent.trim())
+            return;
+        this.chat.rememberReplayFields({ content, toolCalls }, {
+            schema_version: 2,
+            provider: "deepseek",
+            protocol: "openai-chat",
+            model: this.model,
+            reasoning_content: reasoningContent,
+            ...(nativeToolCalls.length ? { tool_calls: nativeToolCalls } : {}),
+        });
+    }
+}
+function nativeToolCallsFromBuffers(toolCallBufs) {
+    return Object.values(toolCallBufs).map(tb => ({
+        id: tb.id,
+        type: "function",
+        function: { name: tb.name, arguments: tb.argsBuf || "{}" },
+    }));
 }

package/dist/providers/glm.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimePolicy } from "../types.js";
+import type { ProviderDescriptor, RuntimePolicy } from "../types.js";
 import { OpenAIChatProvider } from "./openai.js";
 export declare class GLMProvider extends OpenAIChatProvider {
     constructor(apiKey: string, model?: string, retry?: {
@@ -6,4 +6,5 @@ export declare class GLMProvider extends OpenAIChatProvider {
         baseDelay: number;
     }, baseURL?: string);
     runtimePolicy(): RuntimePolicy;
+    descriptor(): ProviderDescriptor;
 }

package/dist/providers/glm.js

@@ -18,4 +18,11 @@ export class GLMProvider extends OpenAIChatProvider {
     runtimePolicy() {
         return GLM_POLICIES[this.model] ?? {};
     }
+    descriptor() {
+        return {
+            ...super.descriptor(),
+            provider: "glm",
+            model: this.model,
+        };
+    }
 }

package/dist/providers/kimi.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimePolicy } from "../types.js";
+import type { ProviderDescriptor, RuntimePolicy } from "../types.js";
 import { OpenAIChatProvider } from "./openai.js";
 export declare class KimiProvider extends OpenAIChatProvider {
     constructor(apiKey: string, model?: string, retry?: {
@@ -6,4 +6,5 @@ export declare class KimiProvider extends OpenAIChatProvider {
         baseDelay: number;
     }, baseURL?: string);
     runtimePolicy(): RuntimePolicy;
+    descriptor(): ProviderDescriptor;
 }

package/dist/providers/kimi.js

@@ -17,4 +17,11 @@ export class KimiProvider extends OpenAIChatProvider {
     runtimePolicy() {
         return KIMI_POLICIES[this.model] ?? {};
     }
+    descriptor() {
+        return {
+            ...super.descriptor(),
+            provider: "kimi",
+            model: this.model,
+        };
+    }
 }

package/dist/providers/minimax.d.ts

@@ -1,9 +1,35 @@
-import type { RuntimePolicy } from "../types.js";
+import type { Message, ProviderDescriptor, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
 import { AnthropicProvider } from "./anthropic.js";
-export declare class MiniMaxProvider extends AnthropicProvider {
+import { OpenAIChatProvider } from "./openai.js";
+/**
+ * MiniMax over its Anthropic-compatible endpoint. Replay is carried as Anthropic
+ * `native_blocks` (thinking/text/tool_use), identical to the first-party
+ * Anthropic provider.
+ */
+export declare class MiniMaxAnthropicProvider extends AnthropicProvider {
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
+    protected providerName(): string;
     runtimePolicy(): RuntimePolicy;
 }
+/**
+ * MiniMax over its OpenAI-compatible endpoint. Replay is carried as
+ * `reasoning_content` / `reasoning_details` (split reasoning), and requests
+ * default to `reasoning_split: true` so reasoning is returned out-of-band rather
+ * than embedded in the message content.
+ */
+export declare class MiniMaxOpenAIProvider extends OpenAIChatProvider {
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+    runtimePolicy(): RuntimePolicy;
+    descriptor(): ProviderDescriptor;
+    protected requireNonEmptyReasoningReplayForToolTurns(extensions?: Record<string, unknown>): boolean;
+    private buildRequestExtensions;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    private rememberMiniMaxReplay;
+}