@deepstrike/wasm 0.2.13 → 0.2.15

package/dist/providers/anthropic.js

@@ -19,17 +19,26 @@ function buildAnthropicTools(tools, anchorCache) {
  * Roll cache breakpoints across the conversation tail so the message-history
  * prefix is written once and re-read on later turns (without this the cached
  * prefix stops at the end of `system` and the whole tool-result history is
- * re-billed at full input price every turn). Marks the final message plus the
- * nearest preceding user turn (read anchor); a bare string body is promoted to
- * a cache-bearing text block.
+ * re-billed at full input price every turn).
+ *
+ * When `frozenPrefixLen` marks a distinct frozen prefix (the compaction
+ * boundary), pin the deep breakpoint there — it is byte-stable across turns,
+ * so `[0..frozen]` is re-read cheaply every turn; the tail breakpoint writes
+ * only the incremental `[frozen..tail]`. Otherwise fall back to the rolling
+ * pair: final message + nearest preceding user turn.
  */
-function applyMessageCacheControl(msgs) {
+function applyMessageCacheControl(msgs, frozenPrefixLen) {
     if (!msgs.length)
         return;
     const targets = new Set([msgs.length - 1]);
-    for (let i = msgs.length - 2; i >= 0 && targets.size < MESSAGE_CACHE_BREAKPOINTS; i--) {
-        if (msgs[i].role === "user")
-            targets.add(i);
+    if (typeof frozenPrefixLen === "number" && frozenPrefixLen >= 1 && frozenPrefixLen < msgs.length) {
+        targets.add(frozenPrefixLen - 1);
+    }
+    else {
+        for (let i = msgs.length - 2; i >= 0 && targets.size < MESSAGE_CACHE_BREAKPOINTS; i--) {
+            if (msgs[i].role === "user")
+                targets.add(i);
+        }
     }
     for (const idx of targets)
         markLastBlockCacheable(msgs[idx]);
@@ -110,14 +119,15 @@ export class AnthropicProvider {
         }
         const system = systemBlocks.length ? systemBlocks : (context.systemText || undefined);
         const msgs = toAnthropicMessages(context, message => this.nativeAssistantBlocks.get(assistantReplayKey(message)));
-        applyMessageCacheControl(msgs);
+        applyMessageCacheControl(msgs, context.frozenPrefixLen);
         // Append the volatile State turn AFTER the cache breakpoints (uncached tail);
         // absent on un-rebuilt bindings, where the state is already inside `turns`.
+        // Render through toAnthropicMessages so assistant tool_use blocks are
+        // serialized correctly — raw content would silently drop toolCalls.
         if (context.stateTurn) {
-            msgs.push({
-                role: context.stateTurn.role === "assistant" ? "assistant" : "user",
-                content: context.stateTurn.content,
-            });
+            const stateCtx = { systemText: "", turns: [context.stateTurn] };
+            const stateMsgs = toAnthropicMessages(stateCtx, message => this.nativeAssistantBlocks.get(assistantReplayKey(message)));
+            msgs.push(...stateMsgs);
         }
         assertCacheBudget(system, tools.length);
         const body = {

package/dist/providers/base.js

@@ -66,7 +66,16 @@ 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 }] });
+            const parts = (msg.contentParts ?? [])
+                .filter(p => p.type === "tool_result")
+                .map(p => ({ type: "tool_result", tool_use_id: p.callId, content: p.output, is_error: p.isError ?? false }));
+            if (parts.length) {
+                result.push({ role: "user", content: parts });
+            }
+            else {
+                // Fallback for messages without structured contentParts
+                result.push({ role: "user", content: [{ type: "tool_result", tool_use_id: "", content: msg.content, is_error: false }] });
+            }
             continue;
         }
         if (msg.role === "assistant" && msg.toolCalls?.length) {
@@ -92,12 +101,6 @@ export function toAnthropicMessages(context, nativeReplay) {
             content: msg.contentParts?.length ? anthropicPartsContent(msg.contentParts) : msg.content,
         });
     }
-    if (context.systemVolatile && result.length > 0) {
-        const last = result[result.length - 1];
-        if (last.role === "user") {
-            last.content = `${String(last.content ?? "")}\n\n[SYSTEM REMINDER]\n${context.systemVolatile}`;
-        }
-    }
     return result;
 }
 /** Collect a non-streaming assistant Message from stream events. */

package/dist/runtime/sub-agent-orchestrator.js

@@ -14,11 +14,25 @@ function terminationFromStatus(status) {
     }
     return status;
 }
+/** Derive which meta-tools a child runner should expose based on permitted IDs and available sources. */
+function deriveMetaTools(permitted, opts) {
+    const metaTools = new Set();
+    if (permitted.has("skill") && opts.skillContentMap?.size)
+        metaTools.add("skill");
+    if (permitted.has("memory") && opts.dreamStore)
+        metaTools.add("memory");
+    if (permitted.has("knowledge") && opts.knowledgeSource)
+        metaTools.add("knowledge");
+    if (permitted.has("update_plan") && opts.enablePlanTool)
+        metaTools.add("update_plan");
+    return metaTools;
+}
 /** Host-side driver for kernel-isolated sub-agent runs. */
 export class SubAgentOrchestrator {
     async run(ctx) {
         const permitted = new Set(ctx.manifest.permitted_capability_ids ?? []);
-        const filteredPlane = new FilteredExecutionPlane(ctx.parentOpts.executionPlane, permitted);
+        const metaTools = deriveMetaTools(permitted, ctx.parentOpts);
+        const filteredPlane = new FilteredExecutionPlane(ctx.parentOpts.executionPlane, permitted, metaTools);
         let systemPrompt = ctx.parentOpts.systemPrompt;
         let inheritEvents;
         if (ctx.manifest.context_inheritance === "full") {
@@ -38,6 +52,10 @@ export class SubAgentOrchestrator {
             agentId: ctx.spec.identity.agentId,
             systemPrompt,
             sessionLog: ctx.sessionLog,
+            skillContentMap: metaTools.has("skill") ? ctx.parentOpts.skillContentMap : undefined,
+            dreamStore: metaTools.has("memory") ? ctx.parentOpts.dreamStore : undefined,
+            knowledgeSource: metaTools.has("knowledge") ? ctx.parentOpts.knowledgeSource : undefined,
+            enablePlanTool: metaTools.has("update_plan") ? ctx.parentOpts.enablePlanTool : undefined,
         });
         let done;
         let finalText = "";

package/dist/types.d.ts

@@ -47,11 +47,13 @@ export interface RenderedContext {
     systemText: string;
     systemStable?: string;
     systemKnowledge?: string;
-    systemVolatile?: string;
     turns: Message[];
     /** Volatile State turn (task_state + signals), rendered after the cacheable
      *  history. Absent on un-rebuilt bindings — then it's still inside turns[0]. */
     stateTurn?: Message;
+    /** Message count of the frozen history prefix (compaction boundary). When set,
+     *  Anthropic pins a deep cache breakpoint here instead of the rolling pair. */
+    frozenPrefixLen?: number;
 }
 export interface StreamEvent {
     type: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.13",
+  "version": "0.2.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.2.13"
+    "@deepstrike/wasm-kernel": "0.2.15"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",