@deepstrike/sdk 0.2.7 → 0.2.9

package/dist/index.d.ts

@@ -1,8 +1,6 @@
 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";
@@ -43,6 +41,8 @@ export { endpointProfiles, modelProfiles, getModelProfile } from "./providers/pr
 export type { ModelProfileId, ProviderId } from "./providers/profiles.js";
 export { createProvider } from "./providers/catalog.js";
 export type { CreateProviderOptions, EndpointProfileId } from "./providers/catalog.js";
+export { ProviderReplayValidationError, DEGRADED_REASONING_PLACEHOLDER } from "./providers/replay-validator.js";
+export { assessProviderReplayability, peekProviderReplay, seedProviderReplayFromEvents, isReplayCompatibleWithProvider, } from "./runtime/provider-replay.js";
 export { tool, streamingTool, executeTools, readFile, validateToolArguments } from "./tools/index.js";
 export type { RegisteredTool } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
@@ -59,7 +59,7 @@ export { Governance, governancePolicyToKernelEvent } from "./governance.js";
 export type { GovernanceVerdict, GovernancePolicy, GovernanceConstraint } from "./governance.js";
 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 { 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, ReplayabilityAssessment, } from "./types.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";

package/dist/index.js

@@ -1,6 +1,5 @@
 // ── 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";
@@ -28,6 +27,8 @@ export { OpenAIChatAdapter } from "./providers/openai-chat.js";
 export { OpenAIResponsesAdapter, OpenAIResponsesProvider } from "./providers/openai-responses.js";
 export { endpointProfiles, modelProfiles, getModelProfile } from "./providers/profiles.js";
 export { createProvider } from "./providers/catalog.js";
+export { ProviderReplayValidationError, DEGRADED_REASONING_PLACEHOLDER } from "./providers/replay-validator.js";
+export { assessProviderReplayability, peekProviderReplay, seedProviderReplayFromEvents, isReplayCompatibleWithProvider, } from "./runtime/provider-replay.js";
 // ── Tools & Skills ─────────────────────────────────────────────────────────
 export { tool, streamingTool, executeTools, readFile, validateToolArguments } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";

package/dist/kernel.d.ts

@@ -147,54 +147,6 @@ 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: {
@@ -208,12 +160,6 @@ 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,14 +2,6 @@ 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/base.d.ts

@@ -9,6 +9,12 @@ export declare class CircuitBreaker {
     recordSuccess(): void;
     recordFailure(): void;
 }
+/**
+ * Internal control flags that steer DeepStrike's own serialization/validation
+ * and must never be forwarded to any provider's wire request, regardless of the
+ * per-call omit list.
+ */
+export declare const INTERNAL_EXTENSION_KEYS: readonly string[];
 export declare function omitExtensionKeys(extensions: Record<string, unknown> | undefined, keys: readonly string[]): Record<string, unknown>;
 export declare function normalizeToolCall(id: string, name: string, args: unknown): {
     id: string;

package/dist/providers/base.js

@@ -26,10 +26,19 @@ export class CircuitBreaker {
             this.openedAt = Date.now();
     }
 }
+/**
+ * Internal control flags that steer DeepStrike's own serialization/validation
+ * and must never be forwarded to any provider's wire request, regardless of the
+ * per-call omit list.
+ */
+export const INTERNAL_EXTENSION_KEYS = [
+    "__deepstrikeThinkingEnabled",
+    "degradeMissingReasoningReplay",
+];
 export function omitExtensionKeys(extensions, keys) {
     if (!extensions)
         return {};
-    const blocked = new Set(keys);
+    const blocked = new Set([...keys, ...INTERNAL_EXTENSION_KEYS]);
     return Object.fromEntries(Object.entries(extensions).filter(([key]) => !blocked.has(key)));
 }
 export function normalizeToolCall(id, name, args) {

package/dist/providers/deepseek.js

@@ -43,6 +43,9 @@ export class DeepSeekProvider extends OpenAIChatProvider {
         const requestExtensions = {
             ...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.
+            ...(extensions?.degradeMissingReasoningReplay === true ? { degradeMissingReasoningReplay: true } : {}),
             reasoning_effort: reasoningEffort,
             extra_body: { thinking: { type: thinking } },
         };

package/dist/providers/minimax.js

@@ -70,6 +70,9 @@ export class MiniMaxOpenAIProvider extends OpenAIChatProvider {
         return {
             ...omitExtensionKeys(extensions, ["reasoning_split", "exposeReasoning"]),
             __deepstrikeThinkingEnabled: reasoningSplit,
+            // Re-thread the degrade control flag (omitExtensionKeys strips internal
+            // keys) so buildChatMessages can honor it; the wire-request omit drops it.
+            ...(extensions?.degradeMissingReasoningReplay === true ? { degradeMissingReasoningReplay: true } : {}),
             reasoning_split: reasoningSplit,
         };
     }

package/dist/providers/openai-chat.d.ts

@@ -1,8 +1,15 @@
 import type OpenAI from "openai";
 import type { Message, ProviderDescriptor, RenderedContext, ToolSchema } from "../types.js";
+import { type ReplayabilityAssessment } from "./replay-validator.js";
 export interface OpenAIChatBuildMessageOptions {
     descriptor?: ProviderDescriptor;
     requireNonEmptyReasoningForToolCalls?: boolean;
+    /**
+     * Degrade (rather than throw) when a reasoning-requiring tool-call turn has
+     * no stored reasoning replay: a placeholder reasoning is injected so the
+     * request still goes out in degraded form.
+     */
+    degradeMissingReasoning?: boolean;
 }
 export declare class OpenAIChatAdapter {
     private replayFields;
@@ -15,6 +22,11 @@ export declare class OpenAIChatAdapter {
         };
     }[];
     buildMessages(context: RenderedContext, options?: OpenAIChatBuildMessageOptions): OpenAI.ChatCompletionMessageParam[];
+    /**
+     * Throw-free pre-flight check: which assistant tool-call turns in `context`
+     * lack the non-empty reasoning replay a reasoning-requiring provider needs.
+     */
+    assessReasoning(context: RenderedContext): ReplayabilityAssessment;
     normalizeToolCalls(toolCalls?: OpenAI.ChatCompletionMessageToolCall[]): Array<{
         id: string;
         name: string;

package/dist/providers/openai-chat.js

@@ -1,6 +1,6 @@
 import { assistantReplayKey } from "../runtime/provider-replay.js";
 import { normalizeToolCall, toOpenAIMessageParams } from "./base.js";
-import { validateOpenAIChatReplay } from "./replay-validator.js";
+import { DEGRADED_REASONING_PLACEHOLDER, assessReasoningReplay, validateOpenAIChatReplay, } from "./replay-validator.js";
 export class OpenAIChatAdapter {
     replayFields = new Map();
     buildTools(tools) {
@@ -13,8 +13,10 @@ export class OpenAIChatAdapter {
         validateOpenAIChatReplay(context, {
             descriptor: options.descriptor,
             requireNonEmptyReasoningForToolCalls: options.requireNonEmptyReasoningForToolCalls,
+            degradeMissingReasoning: options.degradeMissingReasoning,
             replayForAssistant: message => this.replayFields.get(assistantReplayKey(message)),
         });
+        const degradeReasoning = Boolean(options.requireNonEmptyReasoningForToolCalls && options.degradeMissingReasoning);
         // toOpenAIMessageParams prepends systemText as messages[0], then turns.
         const serialized = toOpenAIMessageParams(context);
         // Cursor starts at 1 to skip the system message injected by toOpenAIMessageParams.
@@ -26,7 +28,13 @@ export class OpenAIChatAdapter {
             }
             if (source.role === "assistant") {
                 const replay = this.replayFields.get(assistantReplayKey(source));
-                const wireReplay = openAIChatWireReplayFields(replay);
+                let wireReplay = openAIChatWireReplayFields(replay);
+                if (!wireReplay && degradeReasoning && source.toolCalls?.length) {
+                    // Reasoning-requiring provider, no stored reasoning for this tool-call
+                    // turn, caller opted into degradation: inject a placeholder so the
+                    // wire message stays well-formed instead of failing the whole request.
+                    wireReplay = { reasoning_content: DEGRADED_REASONING_PLACEHOLDER };
+                }
                 if (wireReplay)
                     serialized[cursor] = { ...serialized[cursor], ...wireReplay };
             }
@@ -34,6 +42,15 @@ export class OpenAIChatAdapter {
         }
         return serialized;
     }
+    /**
+     * Throw-free pre-flight check: which assistant tool-call turns in `context`
+     * lack the non-empty reasoning replay a reasoning-requiring provider needs.
+     */
+    assessReasoning(context) {
+        return assessReasoningReplay(context.turns, {
+            replayForAssistant: message => this.replayFields.get(assistantReplayKey(message)),
+        });
+    }
     normalizeToolCalls(toolCalls = []) {
         return toolCalls
             .filter((tc) => tc.type === "function")

package/dist/providers/openai.d.ts

@@ -2,6 +2,7 @@ import OpenAI from "openai";
 import type { Message, ProviderDescriptor, ProviderReplay, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
+import type { ReplayabilityAssessment } from "./replay-validator.js";
 export declare class OpenAIChatProvider implements LLMProvider {
     protected readonly model: string;
     protected client: OpenAI;
@@ -16,7 +17,16 @@ export declare class OpenAIChatProvider implements LLMProvider {
     runtimePolicy(): RuntimePolicy;
     descriptor(): ProviderDescriptor;
     protected requireNonEmptyReasoningReplayForToolTurns(_extensions?: Record<string, unknown>): boolean;
+    protected degradeMissingReasoningReplay(extensions?: Record<string, unknown>): boolean;
     protected buildChatMessages(context: RenderedContext, extensions?: Record<string, unknown>): OpenAI.Chat.Completions.ChatCompletionMessageParam[];
+    /**
+     * Pre-flight query: would this history validate against this provider with the
+     * given extensions, without sending the request? Lets an embedder route around
+     * a reasoning-replay failure (keep thinking on, disable it, or skip this
+     * candidate) before issuing the request. `ok: true` when this provider does
+     * not require reasoning replay for the current extensions.
+     */
+    assessReplayability(context: RenderedContext, extensions?: Record<string, unknown>): ReplayabilityAssessment;
     peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
     seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;

package/dist/providers/openai.js

@@ -60,12 +60,29 @@ export class OpenAIChatProvider {
     requireNonEmptyReasoningReplayForToolTurns(_extensions) {
         return false;
     }
+    degradeMissingReasoningReplay(extensions) {
+        return extensions?.degradeMissingReasoningReplay === true;
+    }
     buildChatMessages(context, extensions) {
         return this.chat.buildMessages(context, {
             descriptor: this.descriptor(),
             requireNonEmptyReasoningForToolCalls: this.requireNonEmptyReasoningReplayForToolTurns(extensions),
+            degradeMissingReasoning: this.degradeMissingReasoningReplay(extensions),
         });
     }
+    /**
+     * Pre-flight query: would this history validate against this provider with the
+     * given extensions, without sending the request? Lets an embedder route around
+     * a reasoning-replay failure (keep thinking on, disable it, or skip this
+     * candidate) before issuing the request. `ok: true` when this provider does
+     * not require reasoning replay for the current extensions.
+     */
+    assessReplayability(context, extensions) {
+        if (!this.requireNonEmptyReasoningReplayForToolTurns(extensions)) {
+            return { ok: true, offendingCallIds: [] };
+        }
+        return this.chat.assessReasoning(context);
+    }
     peekProviderReplay(message) {
         const fields = this.chat.peekReplayFields(message);
         if (!fields || !("reasoning_content" in fields || "reasoning_details" in fields))

package/dist/providers/replay-validator.d.ts

@@ -1,10 +1,32 @@
-import type { Message, ProviderDescriptor, ProviderReplay, RenderedContext } from "../types.js";
+import type { Message, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment } from "../types.js";
+export type { ReplayabilityAssessment };
 export declare class ProviderReplayValidationError extends Error {
     constructor(message: string);
 }
+/**
+ * Placeholder reasoning injected for an assistant tool-call turn that has no
+ * stored reasoning replay when the caller opted into graceful degradation
+ * (`degradeMissingReasoning`). It keeps the wire message well-formed for a
+ * thinking-on provider without fabricating substantive reasoning.
+ */
+export declare const DEGRADED_REASONING_PLACEHOLDER = "[reasoning unavailable on replay]";
 export interface OpenAIChatReplayValidationOptions {
     descriptor?: ProviderDescriptor;
     requireNonEmptyReasoningForToolCalls?: boolean;
+    /**
+     * When true, an assistant tool-call turn that lacks reasoning replay is
+     * degraded (serialized without/with a placeholder reasoning) instead of
+     * throwing. Lets a recovery/fallback request succeed in degraded form
+     * rather than fail outright.
+     */
+    degradeMissingReasoning?: boolean;
     replayForAssistant?: (message: Pick<Message, "content" | "toolCalls">) => ProviderReplay | Record<string, unknown> | undefined;
 }
 export declare function validateOpenAIChatReplay(context: RenderedContext, options?: OpenAIChatReplayValidationOptions): void;
+/**
+ * Pure, throw-free assessment: which assistant tool-call turns lack the
+ * non-empty reasoning replay a reasoning-requiring provider needs. Lets an
+ * embedder decide per-candidate whether to keep thinking on, disable it, or
+ * skip the candidate — before sending.
+ */
+export declare function assessReasoningReplay(turns: Message[], options: Pick<OpenAIChatReplayValidationOptions, "replayForAssistant">): ReplayabilityAssessment;

package/dist/providers/replay-validator.js

@@ -4,12 +4,48 @@ export class ProviderReplayValidationError extends Error {
         this.name = "ProviderReplayValidationError";
     }
 }
+/**
+ * Placeholder reasoning injected for an assistant tool-call turn that has no
+ * stored reasoning replay when the caller opted into graceful degradation
+ * (`degradeMissingReasoning`). It keeps the wire message well-formed for a
+ * thinking-on provider without fabricating substantive reasoning.
+ */
+export const DEGRADED_REASONING_PLACEHOLDER = "[reasoning unavailable on replay]";
 export function validateOpenAIChatReplay(context, options = {}) {
     validateStrictToolResultPairing(context.turns);
-    if (options.requireNonEmptyReasoningForToolCalls) {
-        validateReasoningReplayForAssistantToolCalls(context.turns, options);
+    if (options.requireNonEmptyReasoningForToolCalls && !options.degradeMissingReasoning) {
+        const assessment = assessReasoningReplay(context.turns, options);
+        if (!assessment.ok) {
+            throw reasoningReplayError(assessment.offendingCallIds, options.descriptor);
+        }
     }
 }
+/**
+ * Pure, throw-free assessment: which assistant tool-call turns lack the
+ * non-empty reasoning replay a reasoning-requiring provider needs. Lets an
+ * embedder decide per-candidate whether to keep thinking on, disable it, or
+ * skip the candidate — before sending.
+ */
+export function assessReasoningReplay(turns, options) {
+    const offendingCallIds = [];
+    for (const message of turns) {
+        if (message.role !== "assistant" || !message.toolCalls?.length)
+            continue;
+        const replay = options.replayForAssistant?.(message);
+        const reasoning = typeof replay?.reasoning_content === "string" ? replay.reasoning_content.trim() : "";
+        if (!reasoning) {
+            for (const tc of message.toolCalls)
+                offendingCallIds.push(tc.id);
+        }
+    }
+    return { ok: offendingCallIds.length === 0, offendingCallIds };
+}
+function reasoningReplayError(callIds, descriptor) {
+    const provider = descriptor ? `${descriptor.provider}/${descriptor.model}` : "provider";
+    return new ProviderReplayValidationError(`${provider} replay requires non-empty reasoning_content for assistant tool call turn ${callIds.join(", ")}. ` +
+        "Disable thinking, rebuild this history with provider replay, switch to a provider that can replay this turn, " +
+        "or pass extensions.degradeMissingReasoningReplay to send a degraded turn.");
+}
 function toolResultParts(message) {
     return (message.contentParts ?? [])
         .filter((part) => part.type === "tool_result");
@@ -17,14 +53,25 @@ function toolResultParts(message) {
 function validateStrictToolResultPairing(turns) {
     let pendingIds;
     let completedIds = new Set();
+    const assertAllCompleted = () => {
+        if (!pendingIds)
+            return;
+        const missing = [...pendingIds].filter(id => !completedIds.has(id));
+        if (missing.length) {
+            throw new ProviderReplayValidationError(`OpenAI-compatible replay has assistant tool_calls with no tool result for ${missing.join(", ")}: ` +
+                "every tool_call must be answered by a tool message before the next assistant or user turn.");
+        }
+    };
     for (const message of turns) {
         if (message.role === "assistant") {
+            assertAllCompleted();
             const toolCalls = message.toolCalls ?? [];
             pendingIds = toolCalls.length ? new Set(toolCalls.map(tc => tc.id)) : undefined;
             completedIds = new Set();
             continue;
         }
         if (message.role !== "tool") {
+            assertAllCompleted();
             pendingIds = undefined;
             completedIds = new Set();
             continue;
@@ -39,19 +86,5 @@ function validateStrictToolResultPairing(turns) {
             completedIds.add(part.callId);
         }
     }
-}
-function validateReasoningReplayForAssistantToolCalls(turns, options) {
-    const descriptor = options.descriptor;
-    for (const message of turns) {
-        if (message.role !== "assistant" || !message.toolCalls?.length)
-            continue;
-        const replay = options.replayForAssistant?.(message);
-        const reasoning = typeof replay?.reasoning_content === "string" ? replay.reasoning_content.trim() : "";
-        if (!reasoning) {
-            const callIds = message.toolCalls.map(tc => tc.id).join(", ");
-            const provider = descriptor ? `${descriptor.provider}/${descriptor.model}` : "provider";
-            throw new ProviderReplayValidationError(`${provider} replay requires non-empty reasoning_content for assistant tool call turn ${callIds}. ` +
-                "Disable thinking, rebuild this history with provider replay, or switch to a provider that can replay this turn.");
-        }
-    }
+    assertAllCompleted();
 }

package/dist/runtime/provider-replay.d.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, Message, ProviderDescriptor, ProviderReplay, ToolCall } from "../types.js";
+import type { LLMProvider, Message, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment, ToolCall } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
 export declare function assistantReplayKey(message: Pick<Message, "content" | "toolCalls">): string;
 /**
@@ -12,3 +12,11 @@ export declare function seedProviderReplayFromEvents(provider: LLMProvider, even
     event: SessionEvent;
 }>): void;
 export declare function peekProviderReplay(provider: LLMProvider, content: string, toolCalls: ToolCall[]): ProviderReplay | undefined;
+/**
+ * Pre-flight query for fallback routing: would `context` validate against
+ * `provider` (with `extensions`) before the request is sent? Seed any persisted
+ * replay (via `seedProviderReplayFromEvents`) first so the assessment reflects
+ * what the provider can actually replay. Providers that do not implement
+ * `assessReplayability` (no reasoning-replay requirement) are reported as ok.
+ */
+export declare function assessProviderReplayability(provider: LLMProvider, context: RenderedContext, extensions?: Record<string, unknown>): ReplayabilityAssessment;

package/dist/runtime/provider-replay.js

@@ -83,3 +83,13 @@ export function seedProviderReplayFromEvents(provider, events) {
 export function peekProviderReplay(provider, content, toolCalls) {
     return provider.peekProviderReplay?.({ content, toolCalls });
 }
+/**
+ * Pre-flight query for fallback routing: would `context` validate against
+ * `provider` (with `extensions`) before the request is sent? Seed any persisted
+ * replay (via `seedProviderReplayFromEvents`) first so the assessment reflects
+ * what the provider can actually replay. Providers that do not implement
+ * `assessReplayability` (no reasoning-replay requirement) are reported as ok.
+ */
+export function assessProviderReplayability(provider, context, extensions) {
+    return provider.assessReplayability?.(context, extensions) ?? { ok: true, offendingCallIds: [] };
+}

package/dist/runtime/runner.js

@@ -276,15 +276,17 @@ export class RuntimeRunner {
             // W0-ABI resume: skip nodes already completed before an interruption.
             ...(opts?.resumedCompleted?.length ? { resumed_completed: opts.resumedCompleted } : {}),
         });
+        const collectNodes = (obs) => obs.find(o => o.kind === "workflow_batch_spawned")
+            ?.nodes ?? [];
+        const findDone = (obs) => obs.find(o => o.kind === "workflow_completed");
+        let done = findDone(observations);
+        if (done)
+            return { completed: done.completed ?? [], failed: done.failed ?? [] };
+        let nodes = collectNodes(observations);
         for (;;) {
-            const done = observations.find(o => o.kind === "workflow_completed");
-            if (done)
-                return { completed: done.completed ?? [], failed: done.failed ?? [] };
-            const batch = observations.find(o => o.kind === "workflow_batch_spawned");
-            const nodes = batch?.nodes ?? [];
             if (nodes.length === 0)
                 return { completed: [], failed: [] }; // nothing to run (e.g. all gated)
-            // Run the batch's nodes in parallel — each is independent within a round.
+            // Run the currently-runnable nodes in parallel — each is independent within a round.
             const results = await Promise.all(nodes.map(node => orchestrator.run({
                 parentOpts: this.opts,
                 parentSessionId,
@@ -293,13 +295,23 @@ export class RuntimeRunner {
                 sessionLog: this.opts.sessionLog,
                 ...(this.opts.subAgentHarness ? { harness: this.opts.subAgentHarness } : {}),
             })));
-            // Feed completions back; the draining feed yields the next batch or completion.
-            observations = [];
+            // Feed completions back one at a time. The kernel's run-queue executor may spawn a node's
+            // dependents the moment *that* node completes (per-node unblock), so each feed can emit its
+            // own `workflow_batch_spawned`; ACCUMULATE them across the round rather than keeping only the
+            // last feed's (the old code overwrote `observations` per feed and dropped nodes unblocked by
+            // earlier completions — stalling uneven DAGs). Completion and new spawns are mutually
+            // exclusive per feed, so a `workflow_completed` only arrives once nothing remains to run.
+            const nextNodes = [];
+            done = undefined;
             for (const result of results) {
-                observations = kernelApply(runtime, this.pendingObservations, {
+                const obs = kernelApply(runtime, this.pendingObservations, {
                     kind: "sub_agent_completed",
                     result: subAgentResultToKernel(result),
                 });
+                nextNodes.push(...collectNodes(obs));
+                const d = findDone(obs);
+                if (d)
+                    done = d;
                 // Persist node completion for resume recovery.
                 await this.opts.sessionLog.append(parentSessionId, buildWorkflowNodeCompletedEvent({
                     turn: runtime.turn(),
@@ -307,6 +319,10 @@ export class RuntimeRunner {
                     termination: result.result.termination,
                 }));
             }
+            if (done && nextNodes.length === 0) {
+                return { completed: done.completed ?? [], failed: done.failed ?? [] };
+            }
+            nodes = nextNodes;
         }
     }
     /**

package/dist/types.d.ts

@@ -213,6 +213,13 @@ export interface ProviderReplay {
     native_message?: unknown;
     tool_calls?: unknown[];
 }
+/** Result of a pre-flight reasoning-replay assessment for a target provider. */
+export interface ReplayabilityAssessment {
+    /** True when every reasoning-requiring tool-call turn has replay available. */
+    ok: boolean;
+    /** Tool-call ids whose turn lacks the required non-empty reasoning replay. */
+    offendingCallIds: string[];
+}
 /** Structured render output produced by the kernel for each LLM call. */
 export interface RenderedContext {
     /** Identity + Knowledge combined — for providers with a single system slot (OpenAI). */
@@ -247,6 +254,14 @@ export interface LLMProvider {
     peekProviderReplay?(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
     /** Restore provider-native replay fields when rebuilding history from SessionLog. */
     seedProviderReplay?(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
+    /**
+     * Pre-flight query: would this history validate against this provider with the
+     * given extensions, without sending the request? Returns the tool-call ids
+     * whose turn lacks the reasoning replay this provider requires, so an embedder
+     * can route around the failure (keep thinking on, disable it, or skip this
+     * candidate) before issuing the request. Seed any persisted replay first.
+     */
+    assessReplayability?(context: RenderedContext, extensions?: Record<string, unknown>): ReplayabilityAssessment;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -20,7 +20,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.99.0",
-    "@deepstrike/core": "0.2.7",
+    "@deepstrike/core": "0.2.9",
     "@google/generative-ai": "^0.24.1",
     "openai": "^5.23.2"
   },