@deepstrike/sdk 0.1.13 → 0.1.15

package/dist/index.js

@@ -1,4 +1,12 @@
-export { Agent } from "./agent.js";
+// ── Runtime (Layer 1.5) ────────────────────────────────────────────────────
+export { RuntimeRunner, collectText } from "./runtime/runner.js";
+export { LocalExecutionPlane } from "./runtime/execution-plane.js";
+export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
+export { EnvCredentialVault, InMemoryCredentialVault, ChainedCredentialVault } from "./runtime/credential-vault.js";
+export { ProcessSandboxPlane } from "./runtime/process-sandbox-plane.js";
+export { McpProxyPlane } from "./runtime/mcp-proxy-plane.js";
+export { RemoteVpcPlane } from "./runtime/remote-vpc-plane.js";
+// ── Providers ─────────────────────────────────────────────────────────────
 export { AnthropicProvider } from "./providers/anthropic.js";
 export { OpenAIChatProvider, OpenAIProvider } from "./providers/openai.js";
 export { DeepSeekProvider } from "./providers/deepseek.js";
@@ -12,14 +20,18 @@ 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";
+// ── Tools & Skills ─────────────────────────────────────────────────────────
 export { tool, streamingTool, executeTools, readFile, validateToolArguments } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
+// ── Memory ─────────────────────────────────────────────────────────────────
 export { WorkingMemory } from "./memory/working.js";
-export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
 export { ScheduledPrompt } from "./signals/scheduled.js";
 export { SignalGateway } from "./signals/gateway.js";
+// ── Safety & Governance ────────────────────────────────────────────────────
 export { PermissionManager, PermissionMode } from "./safety/permissions.js";
 export { Governance } from "./governance.js";
+// ── Harness ────────────────────────────────────────────────────────────────
+export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
 export { AgentPool } from "./collaboration/pool.js";
 export { ContractDrivenHarness } from "./collaboration/harness.js";

package/dist/kernel.d.ts

@@ -54,6 +54,7 @@ interface LoopStateMachineInstance {
         goal: string;
         criteria: string[];
     }): LoopAction;
+    resumeAfterPreload(): LoopAction;
     feedLlmResponse(message: Message): LoopAction;
     feedToolResults(results: ToolResult[]): LoopAction;
     feedTimeout(): LoopAction;

package/dist/kernel.js

@@ -1,9 +1,18 @@
 import { createRequire } from "module";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 const cjsRequire = createRequire(import.meta.url);
 let cachedKernel;
+function resolveCoreModule() {
+    const localCore = join(dirname(fileURLToPath(import.meta.url)), "../../../crates/deepstrike-node");
+    if (existsSync(join(localCore, "index.js")))
+        return localCore;
+    return "@deepstrike/core";
+}
 export function getKernel() {
     if (!cachedKernel) {
-        cachedKernel = cjsRequire("@deepstrike/core");
+        cachedKernel = cjsRequire(resolveCoreModule());
     }
     return cachedKernel;
 }

package/dist/memory/protocols.d.ts

@@ -46,10 +46,6 @@ export interface DreamStore {
     saveSession(data: SessionData): Promise<void>;
 }
 /** Durable transcript storage for same-session conversational continuity. */
-export interface SessionStore {
-    loadSession(sessionId: string): Promise<SessionData | undefined>;
-    saveSession(data: SessionData): Promise<void>;
-}
 export interface DreamResult {
     sessionsProcessed: number;
     insightsExtracted: number;

package/dist/providers/anthropic.d.ts

@@ -1,4 +1,4 @@
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+import type { Message, ProviderReplay, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
 interface AnthropicProviderOptions {
     baseURL?: string;
     authMode?: "api-key" | "bearer";
@@ -14,6 +14,9 @@ export declare class AnthropicProvider implements LLMProvider {
         maxRetries: number;
         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>;
@@ -23,6 +26,5 @@ export declare class AnthropicProvider implements LLMProvider {
     private streamMessage;
     private buildMessages;
     private rememberNativeBlocks;
-    private assistantReplayKey;
 }
 export {};

package/dist/providers/anthropic.js

@@ -1,6 +1,14 @@
 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 = {
+    "claude-opus-4-7": { maxTurns: 50 },
+    "claude-opus-4-6": { maxTurns: 50 },
+    "claude-sonnet-4-6": { maxTurns: 25 },
+    "claude-haiku-4-5": { maxTurns: 15 },
+    "claude-haiku-4-5-20251001": { maxTurns: 15 },
+};
 export class AnthropicProvider {
     model;
     client;
@@ -18,6 +26,18 @@ export class AnthropicProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
+    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,
@@ -83,8 +103,16 @@ export class AnthropicProvider {
             messages: msgs,
             ...(tools.length ? { tools: this.buildTools(tools) } : {}),
         }, extensions);
+        let totalTokens = 0;
         for await (const evt of stream) {
-            if (evt.type === "content_block_start") {
+            if (evt.type === "message_start" || evt.type === "message_delta") {
+                const usage = evt.usage ?? evt.message?.usage;
+                if (usage) {
+                    totalTokens = usage.input_tokens + (usage.output_tokens ?? 0);
+                    yield { type: "usage", totalTokens };
+                }
+            }
+            else if (evt.type === "content_block_start") {
                 nativeBlocks[evt.index] = { ...evt.content_block };
                 if (evt.content_block.type === "tool_use") {
                     toolBlocks[evt.index] = { id: evt.content_block.id, name: evt.content_block.name, argsBuf: "" };
@@ -143,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/deepseek.d.ts

@@ -1,10 +1,11 @@
-import type { Message, RenderedContext, ToolSchema, StreamEvent } from "../types.js";
+import type { Message, RenderedContext, ToolSchema, StreamEvent, RuntimePolicy } from "../types.js";
 import { OpenAIChatProvider } from "./openai.js";
 export declare class DeepSeekProvider extends OpenAIChatProvider {
-    constructor(apiKey: string, model?: "deepseek-v4-flash" | "deepseek-v4-pro", retry?: {
+    constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
+    runtimePolicy(): RuntimePolicy;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }

package/dist/providers/deepseek.js

@@ -2,10 +2,19 @@ import { OpenAIChatProvider } from "./openai.js";
 import { endpointProfiles } from "./profiles.js";
 import { omitExtensionKeys } from "./base.js";
 const DEEPSEEK_BASE = endpointProfiles["deepseek.openai"].baseURL;
+const DEEPSEEK_POLICIES = {
+    "deepseek-chat": { maxTurns: 25 },
+    "deepseek-reasoner": { maxTurns: 50 },
+    "deepseek-v4-flash": { maxTurns: 20 },
+    "deepseek-v4-pro": { maxTurns: 35 },
+};
 export class DeepSeekProvider extends OpenAIChatProvider {
     constructor(apiKey, model = "deepseek-v4-flash", retry, baseURL = DEEPSEEK_BASE) {
         super(apiKey, model, retry, baseURL);
     }
+    runtimePolicy() {
+        return DEEPSEEK_POLICIES[this.model] ?? {};
+    }
     async complete(context, tools, extensions) {
         const thinking = extensions?.thinking === false ? "disabled" : "enabled";
         const reasoningEffort = extensions?.reasoningEffort === "max" ? "max" : "high";

package/dist/providers/gemini.d.ts

@@ -1,4 +1,4 @@
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
 export declare class GeminiProvider implements LLMProvider {
     private readonly model;
     private genAI;
@@ -9,6 +9,7 @@ export declare class GeminiProvider implements LLMProvider {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
+    runtimePolicy(): RuntimePolicy;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
     private modelExtensions;

package/dist/providers/gemini.js

@@ -3,6 +3,14 @@ import { withServerRuntimeGuard } from "../runtime/server.js";
 import { CircuitBreaker, normalizeToolCall } from "./base.js";
 import { endpointProfiles } from "./profiles.js";
 const GEMINI_BASE = endpointProfiles["gemini.google"].baseURL;
+const GEMINI_POLICIES = {
+    "gemini-2.5-pro": { maxTurns: 35 },
+    "gemini-2.5-flash": { maxTurns: 20 },
+    "gemini-2.0-flash": { maxTurns: 15 },
+    "gemini-2.0-flash-lite": { maxTurns: 10 },
+    "gemini-1.5-pro": { maxTurns: 30 },
+    "gemini-1.5-flash": { maxTurns: 15 },
+};
 function buildContents(turns) {
     const contents = [];
     for (const msg of turns) {
@@ -61,6 +69,9 @@ export class GeminiProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
+    runtimePolicy() {
+        return GEMINI_POLICIES[this.model] ?? {};
+    }
     async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");

package/dist/providers/kimi.d.ts

@@ -1,7 +1,9 @@
+import type { RuntimePolicy } from "../types.js";
 import { OpenAIChatProvider } from "./openai.js";
 export declare class KimiProvider extends OpenAIChatProvider {
-    constructor(apiKey: string, model?: "kimi-k2.5" | "kimi-k2.6", retry?: {
+    constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
+    runtimePolicy(): RuntimePolicy;
 }

package/dist/providers/kimi.js

@@ -1,8 +1,18 @@
 import { OpenAIChatProvider } from "./openai.js";
 import { endpointProfiles } from "./profiles.js";
 const MOONSHOT_BASE = endpointProfiles["kimi.openai"].baseURL;
+const KIMI_POLICIES = {
+    "moonshot-v1-8k": { maxTurns: 15 },
+    "moonshot-v1-32k": { maxTurns: 20 },
+    "moonshot-v1-128k": { maxTurns: 30 },
+    "kimi-k2.5": { maxTurns: 30 },
+    "kimi-k2.6": { maxTurns: 35 },
+};
 export class KimiProvider extends OpenAIChatProvider {
     constructor(apiKey, model = "kimi-k2.6", retry, baseURL = MOONSHOT_BASE) {
         super(apiKey, model, retry, baseURL);
     }
+    runtimePolicy() {
+        return KIMI_POLICIES[this.model] ?? {};
+    }
 }

package/dist/providers/minimax.d.ts

@@ -1,7 +1,9 @@
+import type { RuntimePolicy } from "../types.js";
 import { AnthropicProvider } from "./anthropic.js";
 export declare class MiniMaxProvider extends AnthropicProvider {
-    constructor(apiKey: string, model?: "MiniMax-M2.7" | "MiniMax-M2.5", retry?: {
+    constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
+    runtimePolicy(): RuntimePolicy;
 }

package/dist/providers/minimax.js

@@ -1,5 +1,10 @@
 import { AnthropicProvider } from "./anthropic.js";
 import { endpointProfiles } from "./profiles.js";
+const MINIMAX_POLICIES = {
+    "MiniMax-M2.7": { maxTurns: 35 },
+    "MiniMax-M2.5": { maxTurns: 25 },
+    "MiniMax-Text-01": { maxTurns: 20 },
+};
 export class MiniMaxProvider extends AnthropicProvider {
     constructor(apiKey, model = "MiniMax-M2.7", retry, baseURL = endpointProfiles["minimax.anthropic"].baseURL) {
         super(apiKey, model, retry, {
@@ -7,4 +12,7 @@ export class MiniMaxProvider extends AnthropicProvider {
             authMode: "api-key",
         });
     }
+    runtimePolicy() {
+        return MINIMAX_POLICIES[this.model] ?? {};
+    }
 }

package/dist/providers/ollama.d.ts

@@ -1,8 +1,9 @@
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
 export declare class OllamaProvider implements LLMProvider {
     private readonly model;
     private readonly baseUrl;
     constructor(model?: string, baseUrl?: string);
+    runtimePolicy(): RuntimePolicy;
     private toOllamaMessages;
     private buildTools;
     private requestExtensions;

package/dist/providers/ollama.js

@@ -1,4 +1,18 @@
 import { normalizeToolCall, omitExtensionKeys } from "./base.js";
+// Prefix-based policy for local models (first match wins)
+const OLLAMA_PREFIX_POLICIES = [
+    ["deepseek-r1", { maxTurns: 40 }],
+    ["qwq", { maxTurns: 35 }],
+    ["llama3.3", { maxTurns: 25 }],
+    ["llama3.2", { maxTurns: 20 }],
+    ["llama3.1", { maxTurns: 20 }],
+    ["llama3", { maxTurns: 20 }],
+    ["mistral", { maxTurns: 20 }],
+    ["gemma2", { maxTurns: 20 }],
+    ["phi4", { maxTurns: 20 }],
+    ["phi3", { maxTurns: 15 }],
+    ["codellama", { maxTurns: 20 }],
+];
 export class OllamaProvider {
     model;
     baseUrl;
@@ -6,6 +20,14 @@ export class OllamaProvider {
         this.model = model;
         this.baseUrl = baseUrl;
     }
+    runtimePolicy() {
+        const m = this.model.toLowerCase();
+        for (const [prefix, policy] of OLLAMA_PREFIX_POLICIES) {
+            if (m.startsWith(prefix))
+                return policy;
+        }
+        return { maxTurns: 20 };
+    }
     toOllamaMessages(context) {
         const result = [];
         if (context.systemText)

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-responses.d.ts

@@ -35,6 +35,7 @@ export declare class OpenAIResponsesProvider implements LLMProvider {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
+    runtimePolicy(): import("../types.js").RuntimePolicy;
     createRunState(): OpenAIResponsesRunState;
     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/dist/providers/openai-responses.js

@@ -113,6 +113,19 @@ export class OpenAIResponsesProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
+    runtimePolicy() {
+        const table = {
+            "gpt-4.1": { maxTurns: 35 },
+            "gpt-4.1-mini": { maxTurns: 20 },
+            "gpt-4.1-nano": { maxTurns: 15 },
+            "gpt-5": { maxTurns: 50 },
+            "gpt-5-mini": { maxTurns: 25 },
+            "o3": { maxTurns: 50 },
+            "o3-mini": { maxTurns: 25 },
+            "o4-mini": { maxTurns: 25 },
+        };
+        return table[this.model] ?? {};
+    }
     createRunState() {
         return { coveredMessageCount: 0 };
     }

package/dist/providers/openai.d.ts

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider } 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 {
@@ -13,6 +13,9 @@ export declare class OpenAIChatProvider implements LLMProvider {
         maxRetries: number;
         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

@@ -2,6 +2,20 @@ import OpenAI from "openai";
 import { withServerRuntimeGuard } from "../runtime/server.js";
 import { CircuitBreaker, omitExtensionKeys } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
+const OPENAI_POLICIES = {
+    "gpt-4o": { maxTurns: 25 },
+    "gpt-4o-mini": { maxTurns: 15 },
+    "gpt-4.1": { maxTurns: 35 },
+    "gpt-4.1-mini": { maxTurns: 20 },
+    "gpt-4.1-nano": { maxTurns: 15 },
+    "gpt-5": { maxTurns: 50 },
+    "gpt-5-mini": { maxTurns: 25 },
+    "o1": { maxTurns: 50 },
+    "o1-mini": { maxTurns: 25 },
+    "o3": { maxTurns: 50 },
+    "o3-mini": { maxTurns: 25 },
+    "o4-mini": { maxTurns: 25 },
+};
 export class OpenAIChatProvider {
     model;
     client;
@@ -16,6 +30,20 @@ export class OpenAIChatProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
+    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");