@deepstrike/sdk 0.2.6 → 0.2.7

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { RuntimeRunner, collectText } 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";
@@ -31,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";
@@ -58,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,5 +1,6 @@
 // ── 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";
@@ -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

@@ -147,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: {
@@ -160,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/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;
+}