@deepstrike/wasm 0.2.20 → 0.2.22

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiPr
 export { tool, executeTools } from "./tools/index.js";
 export type { RegisteredTool } from "./tools/index.js";
 export { WorkingMemory } from "./memory/index.js";
+export { InMemoryDreamStore } from "./memory/in-memory-store.js";
 export type { DreamStore, DreamResult, SessionStore, SessionData, SessionMessage, MemoryEntry, CurationResult, CurationStats, } from "./memory/index.js";
 export type { KnowledgeSource } from "./knowledge/index.js";
 export { SinglePassHarness, HarnessLoop } from "./harness/index.js";
@@ -22,4 +23,4 @@ export { ScheduledPrompt } from "./signals/index.js";
 export type { RuntimeSignal, SignalSource } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";
 export type { PermissionDecision } from "./safety/index.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, LLMProvider, } from "./types.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, LLMProvider, CacheBreakpointStrategy, } from "./types.js";

package/dist/index.js

@@ -8,6 +8,7 @@ export { AnthropicProvider } from "./providers/anthropic.js";
 export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
 export { tool, executeTools } from "./tools/index.js";
 export { WorkingMemory } from "./memory/index.js";
+export { InMemoryDreamStore } from "./memory/in-memory-store.js";
 export { SinglePassHarness, HarnessLoop } from "./harness/index.js";
 export { ScheduledPrompt } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";

package/dist/memory/in-memory-store.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `InMemoryDreamStore` — a lightweight `DreamStore` implementation backed by per-agent `Map`s.
+ * WASM port of node/src/memory/in-memory-store.ts. See that file for the full design.
+ */
+import type { CurationResult, DreamStore, MemoryEntry, SessionData } from "./index.js";
+export declare class InMemoryDreamStore implements DreamStore {
+    private readonly initialMemories;
+    private sessions;
+    private memories;
+    readonly savedSessions: SessionData[];
+    constructor(initialMemories?: MemoryEntry[]);
+    addSession(agentId: string, session: SessionData): void;
+    addMemories(agentId: string, entries: MemoryEntry[]): void;
+    loadSessions(agentId: string): Promise<SessionData[]>;
+    loadMemories(agentId: string): Promise<MemoryEntry[]>;
+    commit(agentId: string, result: CurationResult, existing: MemoryEntry[]): Promise<void>;
+    search(agentId: string, _query: string, topK?: number): Promise<MemoryEntry[]>;
+    saveSession(data: SessionData): Promise<void>;
+}

package/dist/memory/in-memory-store.js

@@ -0,0 +1,43 @@
+export class InMemoryDreamStore {
+    initialMemories;
+    sessions = new Map();
+    memories = new Map();
+    savedSessions = [];
+    constructor(initialMemories = []) {
+        this.initialMemories = initialMemories;
+    }
+    addSession(agentId, session) {
+        const list = this.sessions.get(agentId) ?? [];
+        list.push(session);
+        this.sessions.set(agentId, list);
+    }
+    addMemories(agentId, entries) {
+        this.memories.set(agentId, [...(this.memories.get(agentId) ?? []), ...entries]);
+    }
+    async loadSessions(agentId) {
+        return this.sessions.get(agentId) ?? [];
+    }
+    async loadMemories(agentId) {
+        if (this.memories.has(agentId))
+            return this.memories.get(agentId);
+        if (this.initialMemories.length > 0) {
+            this.memories.set(agentId, [...this.initialMemories]);
+            return this.memories.get(agentId);
+        }
+        return [];
+    }
+    async commit(agentId, result, existing) {
+        const kept = existing.filter((_, i) => !result.toRemoveIndices.includes(i));
+        this.memories.set(agentId, [...kept, ...result.toAdd]);
+    }
+    async search(agentId, _query, topK = 5) {
+        const all = await this.loadMemories(agentId);
+        return all.slice(0, topK);
+    }
+    async saveSession(data) {
+        this.savedSessions.push(data);
+        const list = this.sessions.get(data.agentId) ?? [];
+        list.push(data);
+        this.sessions.set(data.agentId, list);
+    }
+}

package/dist/providers/anthropic.js

@@ -3,18 +3,26 @@ import { assistantReplayKey, collectStreamMessage, toAnthropicMessages } from ".
 const MAX_CACHE_BREAKPOINTS = 4;
 /** Rolling cache breakpoints reserved for the message history (system uses ≤2). */
 const MESSAGE_CACHE_BREAKPOINTS = 2;
-function buildAnthropicTools(tools, anchorCache) {
+function buildAnthropicTools(tools, anchorCache, strategy) {
+    const emitOnLastTool = anchorCache && (strategy === "default" || strategy === "tools-only");
     return tools.map((t, i) => ({
         name: t.name,
         description: t.description,
         input_schema: JSON.parse(t.parameters),
-        // Anchor a tool breakpoint only when the system blocks won't carry one;
-        // otherwise systemStable already caches the tools prefix (tools render
-        // first), and a redundant tool breakpoint would burn a slot the message
-        // history needs to stay within the 4-breakpoint budget.
-        ...(anchorCache && i === tools.length - 1 ? { cache_control: { type: "ephemeral" } } : {}),
+        ...(emitOnLastTool && i === tools.length - 1 ? { cache_control: { type: "ephemeral" } } : {}),
     }));
 }
+/** Recognised values for the `cacheBreakpointStrategy` extension; unknown → "default". */
+const CACHE_BREAKPOINT_STRATEGIES = new Set([
+    "default", "tools-only", "system-only", "frozen-prefix", "none",
+]);
+function resolveCacheBreakpointStrategy(extensions) {
+    const raw = extensions?.cacheBreakpointStrategy;
+    if (typeof raw === "string" && CACHE_BREAKPOINT_STRATEGIES.has(raw)) {
+        return raw;
+    }
+    return "default";
+}
 /**
  * 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
@@ -27,14 +35,16 @@ function buildAnthropicTools(tools, anchorCache) {
  * only the incremental `[frozen..tail]`. Otherwise fall back to the rolling
  * pair: final message + nearest preceding user turn.
  */
-function applyMessageCacheControl(msgs, frozenPrefixLen) {
+function applyMessageCacheControl(msgs, frozenPrefixLen, strategy) {
     if (!msgs.length)
         return;
+    if (strategy === "tools-only" || strategy === "system-only" || strategy === "none")
+        return;
     const targets = new Set([msgs.length - 1]);
     if (typeof frozenPrefixLen === "number" && frozenPrefixLen >= 1 && frozenPrefixLen < msgs.length) {
         targets.add(frozenPrefixLen - 1);
     }
-    else {
+    else if (strategy === "default") {
         for (let i = msgs.length - 2; i >= 0 && targets.size < MESSAGE_CACHE_BREAKPOINTS; i--) {
             if (msgs[i].role === "user")
                 targets.add(i);
@@ -110,16 +120,19 @@ export class AnthropicProvider {
         return collectStreamMessage(this.stream(context, tools, extensions));
     }
     async *stream(context, tools, extensions, _state, signal) {
+        const strategy = resolveCacheBreakpointStrategy(extensions);
+        const emitOnSystemBlocks = strategy === "default" || strategy === "system-only";
+        const cc = { type: "ephemeral" };
         const systemBlocks = [];
         if (context.systemStable) {
-            systemBlocks.push({ type: "text", text: context.systemStable, cache_control: { type: "ephemeral" } });
+            systemBlocks.push({ type: "text", text: context.systemStable, ...(emitOnSystemBlocks ? { cache_control: cc } : {}) });
         }
         if (context.systemKnowledge) {
-            systemBlocks.push({ type: "text", text: context.systemKnowledge, cache_control: { type: "ephemeral" } });
+            systemBlocks.push({ type: "text", text: context.systemKnowledge, ...(emitOnSystemBlocks ? { cache_control: cc } : {}) });
         }
         const system = systemBlocks.length ? systemBlocks : (context.systemText || undefined);
         const msgs = toAnthropicMessages(context, message => this.nativeAssistantBlocks.get(assistantReplayKey(message)));
-        applyMessageCacheControl(msgs, context.frozenPrefixLen);
+        applyMessageCacheControl(msgs, context.frozenPrefixLen, strategy);
         // 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
@@ -136,7 +149,7 @@ export class AnthropicProvider {
             messages: msgs,
             stream: true,
             ...(system ? { system } : {}),
-            ...(tools.length ? { tools: buildAnthropicTools(tools, !Array.isArray(system)) } : {}),
+            ...(tools.length ? { tools: buildAnthropicTools(tools, !Array.isArray(system), strategy) } : {}),
         };
         if (extensions?.enable_thinking) {
             body.thinking = { type: "enabled", budget_tokens: 8000 };

package/dist/types.d.ts

@@ -144,6 +144,13 @@ export interface ToolArgumentRepairedEvent extends StreamEvent {
  */
 export type ProviderRunState = Record<string, unknown>;
 export type ProviderProtocol = "anthropic-messages" | "openai-chat" | "openai-responses" | "gemini";
+/**
+ * Cache_control placement strategy for the Anthropic protocol. Pass via
+ * `extensions.cacheBreakpointStrategy` on any provider call (the runner threads
+ * `RuntimeOptions.extensions` through automatically). See the Node SDK's
+ * `CacheBreakpointStrategy` for the canonical documentation; this is the WASM mirror.
+ */
+export type CacheBreakpointStrategy = "default" | "tools-only" | "system-only" | "frozen-prefix" | "none";
 export interface ProviderDescriptor {
     provider: string;
     protocol: ProviderProtocol;

package/package.json

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