@deepstrike/sdk 0.1.14 → 0.1.15

package/dist/index.d.ts

@@ -43,7 +43,7 @@ export { Governance } from "./governance.js";
 export type { GovernanceVerdict } 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, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, 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, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, ProviderReplay, RenderedContext, } from "./types.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/providers/anthropic.d.ts

@@ -1,4 +1,4 @@
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+import type { Message, ProviderReplay, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
 interface AnthropicProviderOptions {
     baseURL?: string;
     authMode?: "api-key" | "bearer";
@@ -15,6 +15,8 @@ export declare class AnthropicProvider implements LLMProvider {
         baseDelay: number;
     }, options?: AnthropicProviderOptions);
     runtimePolicy(): RuntimePolicy;
+    peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
+    seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
     private buildTools;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
@@ -24,6 +26,5 @@ export declare class AnthropicProvider implements LLMProvider {
     private streamMessage;
     private buildMessages;
     private rememberNativeBlocks;
-    private assistantReplayKey;
 }
 export {};

package/dist/providers/anthropic.js

@@ -1,4 +1,5 @@
 import Anthropic from "@anthropic-ai/sdk";
+import { assistantReplayKey } from "../runtime/provider-replay.js";
 import { withServerRuntimeGuard } from "../runtime/server.js";
 import { CircuitBreaker, normalizeToolCall, omitExtensionKeys, toAnthropicMessages } from "./base.js";
 const CLAUDE_POLICIES = {
@@ -28,6 +29,15 @@ export class AnthropicProvider {
     runtimePolicy() {
         return CLAUDE_POLICIES[this.model] ?? {};
     }
+    peekProviderReplay(message) {
+        const blocks = this.nativeAssistantBlocks.get(assistantReplayKey(message));
+        return blocks?.length ? { native_blocks: blocks } : undefined;
+    }
+    seedProviderReplay(message, replay) {
+        if (replay.native_blocks?.length) {
+            this.nativeAssistantBlocks.set(assistantReplayKey(message), replay.native_blocks);
+        }
+    }
     buildTools(tools) {
         return tools.map(t => ({
             name: t.name,
@@ -161,17 +171,13 @@ export class AnthropicProvider {
             : this.client.messages.stream(params));
     }
     buildMessages(context) {
-        return toAnthropicMessages(context.turns, message => this.nativeAssistantBlocks.get(this.assistantReplayKey(message)));
+        return toAnthropicMessages(context.turns, message => this.nativeAssistantBlocks.get(assistantReplayKey(message)));
     }
     rememberNativeBlocks(message, blocks) {
-        if (!message.toolCalls?.length)
+        if (!blocks.length)
             return;
-        this.nativeAssistantBlocks.set(this.assistantReplayKey(message), blocks);
-    }
-    assistantReplayKey(message) {
-        return JSON.stringify({
-            content: message.content,
-            toolCalls: message.toolCalls ?? [],
-        });
+        if (!message.toolCalls?.length && !blocks.some(b => b.type === "thinking"))
+            return;
+        this.nativeAssistantBlocks.set(assistantReplayKey(message), blocks);
     }
 }

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

@@ -23,5 +23,5 @@ export declare class OpenAIChatAdapter {
         arguments: string;
     }>;
     rememberReplayFields(message: Pick<Message, "content" | "toolCalls">, fields: Record<string, unknown>): void;
-    private assistantReplayKey;
+    peekReplayFields(message: Pick<Message, "content" | "toolCalls">): Record<string, unknown> | undefined;
 }

package/dist/providers/openai-chat.js

@@ -1,3 +1,4 @@
+import { assistantReplayKey } from "../runtime/provider-replay.js";
 import { normalizeToolCall, toOpenAIMessageParams } from "./base.js";
 export class OpenAIChatAdapter {
     replayFields = new Map();
@@ -18,7 +19,7 @@ export class OpenAIChatAdapter {
                 continue;
             }
             if (source.role === "assistant") {
-                const replay = this.replayFields.get(this.assistantReplayKey(source));
+                const replay = this.replayFields.get(assistantReplayKey(source));
                 if (replay)
                     serialized[cursor] = { ...serialized[cursor], ...replay };
             }
@@ -32,12 +33,9 @@ export class OpenAIChatAdapter {
             .filter(Boolean);
     }
     rememberReplayFields(message, fields) {
-        this.replayFields.set(this.assistantReplayKey(message), fields);
+        this.replayFields.set(assistantReplayKey(message), fields);
     }
-    assistantReplayKey(message) {
-        return JSON.stringify({
-            content: message.content,
-            toolCalls: message.toolCalls ?? [],
-        });
+    peekReplayFields(message) {
+        return this.replayFields.get(assistantReplayKey(message));
     }
 }

package/dist/providers/openai.d.ts

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+import type { Message, ProviderReplay, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
 export declare class OpenAIChatProvider implements LLMProvider {
@@ -14,6 +14,8 @@ export declare class OpenAIChatProvider implements LLMProvider {
         baseDelay: number;
     }, baseURL?: string);
     runtimePolicy(): RuntimePolicy;
+    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>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
     protected requestExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;

package/dist/providers/openai.js

@@ -33,6 +33,17 @@ export class OpenAIChatProvider {
     runtimePolicy() {
         return OPENAI_POLICIES[this.model] ?? {};
     }
+    peekProviderReplay(message) {
+        const fields = this.chat.peekReplayFields(message);
+        if (!fields?.reasoning_content)
+            return undefined;
+        return { reasoning_content: String(fields.reasoning_content) };
+    }
+    seedProviderReplay(message, replay) {
+        if (replay.reasoning_content) {
+            this.chat.rememberReplayFields(message, { reasoning_content: replay.reasoning_content });
+        }
+    }
     async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");

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

@@ -0,0 +1,7 @@
+import type { LLMProvider, Message, ProviderReplay, ToolCall } from "../types.js";
+import type { SessionEvent } from "./session-log.js";
+export declare function assistantReplayKey(message: Pick<Message, "content" | "toolCalls">): string;
+export declare function seedProviderReplayFromEvents(provider: LLMProvider, events: Array<{
+    event: SessionEvent;
+}>): void;
+export declare function peekProviderReplay(provider: LLMProvider, content: string, toolCalls: ToolCall[]): ProviderReplay | undefined;

package/dist/runtime/provider-replay.js

@@ -0,0 +1,18 @@
+export function assistantReplayKey(message) {
+    return JSON.stringify({
+        content: message.content,
+        toolCalls: message.toolCalls ?? [],
+    });
+}
+export function seedProviderReplayFromEvents(provider, events) {
+    if (!provider.seedProviderReplay)
+        return;
+    for (const { event } of events) {
+        if (event.kind !== "llm_completed" || !event.provider_replay)
+            continue;
+        provider.seedProviderReplay({ content: event.content, toolCalls: event.tool_calls ?? [] }, event.provider_replay);
+    }
+}
+export function peekProviderReplay(provider, content, toolCalls) {
+    return provider.peekProviderReplay?.({ content, toolCalls });
+}

package/dist/runtime/runner.js

@@ -1,4 +1,5 @@
 import { getKernel } from "../kernel.js";
+import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-replay.js";
 export class RuntimeRunner {
     opts;
     interrupted = false;
@@ -128,6 +129,7 @@ export class RuntimeRunner {
         if (this.opts.knowledgeSource)
             sm.setKnowledgeEnabled(true);
         if (priorEvents && priorEvents.length > 0) {
+            seedProviderReplayFromEvents(this.opts.provider, priorEvents);
             sm.preloadHistory(replayMessages(priorEvents));
         }
         const sessionStart = Date.now();
@@ -202,12 +204,14 @@ export class RuntimeRunner {
                     toolCalls: finalToolCalls,
                     tokenCount: turnTokens || undefined,
                 });
+                const providerReplay = peekProviderReplay(this.opts.provider, finalText, finalToolCalls);
                 await this.opts.sessionLog.append(sessionId, {
                     kind: "llm_completed",
                     turn: sm.turn,
                     content: finalText,
                     token_count: turnTokens || undefined,
                     tool_calls: finalToolCalls,
+                    ...(providerReplay ? { provider_replay: providerReplay } : {}),
                 });
             }
             else if (action.kind === "execute_tools") {

package/dist/runtime/session-log.d.ts

@@ -1,4 +1,4 @@
-import type { ToolCall } from "../types.js";
+import type { ProviderReplay, ToolCall } from "../types.js";
 export type SessionEvent = {
     kind: "run_started";
     run_id: string;
@@ -12,6 +12,7 @@ export type SessionEvent = {
     content: string;
     token_count?: number;
     tool_calls: ToolCall[];
+    provider_replay?: ProviderReplay;
 } | {
     kind: "tool_requested";
     turn: number;

package/dist/types.d.ts

@@ -152,6 +152,13 @@ export interface RetryConfig {
  * Responses `previous_response_id` without leaking those semantics into the kernel.
  */
 export type ProviderRunState = Record<string, unknown>;
+/** Provider-native fields required to replay a turn across requests (thinking blocks, reasoning_content, etc.). */
+export interface ProviderReplay {
+    /** Anthropic-style assistant content blocks (thinking, text, tool_use). */
+    native_blocks?: Array<Record<string, unknown>>;
+    /** OpenAI-compatible reasoning field (DeepSeek, etc.). */
+    reasoning_content?: string;
+}
 /** Structured render output produced by the kernel for each LLM call. */
 export interface RenderedContext {
     /** Combined system text: system partition + dashboard (when non-empty).
@@ -180,6 +187,10 @@ export interface LLMProvider {
      * maxTurns / timeoutMs in RuntimeOptions.
      */
     runtimePolicy?(): RuntimePolicy;
+    /** Read provider-native replay fields captured after the most recent assistant turn. */
+    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;
     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.1.14",
+  "version": "0.1.15",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
-    "@deepstrike/core": "0.1.14",
+    "@deepstrike/core": "0.1.15",
     "@google/generative-ai": "^0.24.1",
     "openai": "^4.77.0"
   },