@deepstrike/wasm 0.1.14 → 0.1.15

package/dist/providers/anthropic.d.ts

@@ -1,9 +1,13 @@
-import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, Message } from "../types.js";
+import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, Message, ProviderReplay } from "../types.js";
 export declare class AnthropicProvider implements LLMProvider {
     private readonly apiKey;
     private readonly model;
     private readonly maxTokens;
+    private nativeAssistantBlocks;
     constructor(apiKey: string, model?: string, maxTokens?: number);
+    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>;
+    private rememberNativeBlocks;
 }

package/dist/providers/anthropic.js

@@ -1,4 +1,4 @@
-import { collectStreamMessage, toAnthropicMessages } from "./base.js";
+import { assistantReplayKey, collectStreamMessage, toAnthropicMessages } from "./base.js";
 function buildAnthropicTools(tools) {
     return tools.map(t => ({ name: t.name, description: t.description, input_schema: JSON.parse(t.parameters) }));
 }
@@ -6,17 +6,27 @@ export class AnthropicProvider {
     apiKey;
     model;
     maxTokens;
+    nativeAssistantBlocks = new Map();
     constructor(apiKey, model = "claude-sonnet-4-6", maxTokens = 8096) {
         this.apiKey = apiKey;
         this.model = model;
         this.maxTokens = maxTokens;
     }
+    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);
+        }
+    }
     async complete(context, tools, extensions) {
         return collectStreamMessage(this.stream(context, tools, extensions));
     }
     async *stream(context, tools, extensions) {
         const system = context.systemText || undefined;
-        const msgs = toAnthropicMessages(context);
+        const msgs = toAnthropicMessages(context, message => this.nativeAssistantBlocks.get(assistantReplayKey(message)));
         const body = {
             model: this.model,
             max_tokens: this.maxTokens,
@@ -40,6 +50,9 @@ export class AnthropicProvider {
         if (!resp.ok)
             throw new Error(`Anthropic ${resp.status}: ${await resp.text()}`);
         const toolBlocks = {};
+        const nativeBlocks = {};
+        let finalText = "";
+        const finalToolCalls = [];
         const reader = resp.body.getReader();
         const decoder = new TextDecoder();
         let buf = "";
@@ -68,35 +81,59 @@ export class AnthropicProvider {
                         }
                     }
                     else if (evt.type === "content_block_start") {
+                        const idx = evt.index;
+                        nativeBlocks[idx] = { ...evt.content_block };
                         const cb = evt.content_block;
                         if (cb.type === "tool_use")
-                            toolBlocks[evt.index] = { id: cb.id, name: cb.name, argsBuf: "" };
+                            toolBlocks[idx] = { id: cb.id, name: cb.name, argsBuf: "" };
                     }
                     else if (evt.type === "content_block_delta") {
                         const d = evt.delta;
                         const idx = evt.index;
-                        if (d.type === "text_delta")
+                        if (d.type === "text_delta") {
+                            finalText += String(d.text);
+                            nativeBlocks[idx] = { ...nativeBlocks[idx], text: String(nativeBlocks[idx]?.text ?? "") + d.text };
                             yield { type: "text_delta", delta: d.text };
-                        else if (d.type === "thinking_delta")
+                        }
+                        else if (d.type === "thinking_delta") {
+                            nativeBlocks[idx] = { ...nativeBlocks[idx], thinking: String(nativeBlocks[idx]?.thinking ?? "") + d.thinking };
                             yield { type: "thinking_delta", delta: d.thinking };
-                        else if (d.type === "input_json_delta" && toolBlocks[idx])
+                        }
+                        else if (d.type === "signature_delta") {
+                            nativeBlocks[idx] = { ...nativeBlocks[idx], signature: String(nativeBlocks[idx]?.signature ?? "") + d.signature };
+                        }
+                        else if (d.type === "input_json_delta" && toolBlocks[idx]) {
                             toolBlocks[idx].argsBuf += d.partial_json;
-                    }
-                    else if (evt.type === "content_block_stop" && toolBlocks[evt.index]) {
-                        const tb = toolBlocks[evt.index];
-                        delete toolBlocks[evt.index];
-                        let args = {};
-                        try {
-                            args = JSON.parse(tb.argsBuf || "{}");
                         }
-                        catch {
-                            args = {};
+                    }
+                    else if (evt.type === "content_block_stop") {
+                        const idx = evt.index;
+                        if (toolBlocks[idx]) {
+                            const tb = toolBlocks[idx];
+                            delete toolBlocks[idx];
+                            let args = {};
+                            try {
+                                args = JSON.parse(tb.argsBuf || "{}");
+                            }
+                            catch {
+                                args = {};
+                            }
+                            nativeBlocks[idx] = { ...nativeBlocks[idx], input: args };
+                            finalToolCalls.push({ id: tb.id, name: tb.name, arguments: JSON.stringify(args) });
+                            yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
                         }
-                        yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
                     }
                 }
                 catch { /* skip malformed */ }
             }
         }
+        this.rememberNativeBlocks({ content: finalText, toolCalls: finalToolCalls }, Object.keys(nativeBlocks).map(Number).sort((a, b) => a - b).map(index => nativeBlocks[index]));
+    }
+    rememberNativeBlocks(message, blocks) {
+        if (!blocks.length)
+            return;
+        if (!message.toolCalls?.length && !blocks.some(b => b.type === "thinking"))
+            return;
+        this.nativeAssistantBlocks.set(assistantReplayKey(message), blocks);
     }
 }

package/dist/providers/base.d.ts

@@ -1,11 +1,8 @@
 import type { Message, RenderedContext } from "../types.js";
+import { assistantReplayKey } from "../runtime/provider-replay.js";
 /** Build OpenAI-compatible chat messages from a RenderedContext. */
 export declare function toOpenAIMessages(context: RenderedContext): Array<Record<string, unknown>>;
-/** Anthropic messages array (system is a separate top-level param). */
-export declare function toAnthropicMessages(context: RenderedContext): Array<{
-    role: string;
-    content: string;
-}>;
+export declare function toAnthropicMessages(context: RenderedContext, nativeReplay?: (message: Message) => Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
 /** Collect a non-streaming assistant Message from stream events. */
 export declare function collectStreamMessage(stream: AsyncIterable<{
     type: string;
@@ -14,3 +11,4 @@ export declare function collectStreamMessage(stream: AsyncIterable<{
     name?: string;
     arguments?: Record<string, unknown>;
 }>): Promise<Message>;
+export { assistantReplayKey };

package/dist/providers/base.js

@@ -1,3 +1,12 @@
+import { assistantReplayKey } from "../runtime/provider-replay.js";
+function parseToolArguments(args) {
+    try {
+        return JSON.parse(args || "{}");
+    }
+    catch {
+        return {};
+    }
+}
 /** Build OpenAI-compatible chat messages from a RenderedContext. */
 export function toOpenAIMessages(context) {
     const messages = [];
@@ -21,11 +30,34 @@ export function toOpenAIMessages(context) {
     }
     return messages;
 }
-/** Anthropic messages array (system is a separate top-level param). */
-export function toAnthropicMessages(context) {
-    return context.turns
-        .filter(m => m.role !== "system")
-        .map(m => ({ role: m.role, content: m.content }));
+export function toAnthropicMessages(context, nativeReplay) {
+    const result = [];
+    for (const msg of context.turns) {
+        if (msg.role === "tool") {
+            result.push({ role: "user", content: [{ type: "tool_result", tool_use_id: msg.content ? undefined : "", content: msg.content, is_error: false }] });
+            continue;
+        }
+        if (msg.role === "assistant" && msg.toolCalls?.length) {
+            const replay = nativeReplay?.(msg);
+            if (replay) {
+                result.push({ role: "assistant", content: replay });
+                continue;
+            }
+            const blocks = [];
+            if (msg.content)
+                blocks.push({ type: "text", text: msg.content });
+            blocks.push(...msg.toolCalls.map(tc => ({
+                type: "tool_use",
+                id: tc.id,
+                name: tc.name,
+                input: parseToolArguments(tc.arguments),
+            })));
+            result.push({ role: "assistant", content: blocks });
+            continue;
+        }
+        result.push({ role: msg.role, content: msg.content });
+    }
+    return result;
 }
 /** Collect a non-streaming assistant Message from stream events. */
 export async function collectStreamMessage(stream) {
@@ -40,3 +72,4 @@ export async function collectStreamMessage(stream) {
     }
     return { role: "assistant", content, ...(toolCalls.length ? { toolCalls } : {}) };
 }
+export { assistantReplayKey };

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;
@@ -129,6 +130,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();
@@ -203,12 +205,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

@@ -75,12 +75,18 @@ export interface PermissionRequestEvent extends StreamEvent {
  * The framework creates and threads this object; providers may read/write it.
  */
 export type ProviderRunState = Record<string, unknown>;
+export interface ProviderReplay {
+    native_blocks?: Array<Record<string, unknown>>;
+    reasoning_content?: string;
+}
 export interface LLMProvider {
     createRunState?(): ProviderRunState;
     runtimePolicy?(): {
         maxTurns?: number;
         timeoutMs?: number;
     };
+    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>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "test": "node --experimental-vm-modules node_modules/.bin/jest"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.1.14"
+    "@deepstrike/wasm-kernel": "0.1.15"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",