@deepstrike/sdk 0.1.15 → 0.2.0

package/dist/runtime/provider-replay.js

@@ -1,16 +1,50 @@
+import { effectiveProviderReplay } from "./session-repair.js";
+function sortObjectKeys(val) {
+    if (val === null || typeof val !== "object") {
+        return val;
+    }
+    if (Array.isArray(val)) {
+        return val.map(sortObjectKeys);
+    }
+    const sortedKeys = Object.keys(val).sort();
+    const result = {};
+    for (const key of sortedKeys) {
+        result[key] = sortObjectKeys(val[key]);
+    }
+    return result;
+}
 export function assistantReplayKey(message) {
+    const toolCalls = (message.toolCalls ?? []).map(tc => {
+        let normalizedArgs = tc.arguments;
+        try {
+            const parsed = typeof tc.arguments === "string" ? JSON.parse(tc.arguments) : tc.arguments;
+            normalizedArgs = JSON.stringify(sortObjectKeys(parsed));
+        }
+        catch {
+            // fallback
+        }
+        return {
+            id: tc.id,
+            name: tc.name,
+            arguments: normalizedArgs,
+        };
+    });
     return JSON.stringify({
         content: message.content,
-        toolCalls: message.toolCalls ?? [],
+        toolCalls,
     });
 }
 export function seedProviderReplayFromEvents(provider, events) {
     if (!provider.seedProviderReplay)
         return;
     for (const { event } of events) {
-        if (event.kind !== "llm_completed" || !event.provider_replay)
+        if (event.kind !== "llm_completed")
+            continue;
+        const toolCalls = event.tool_calls ?? [];
+        const replay = effectiveProviderReplay(event.content, toolCalls, event.provider_replay);
+        if (!replay)
             continue;
-        provider.seedProviderReplay({ content: event.content, toolCalls: event.tool_calls ?? [] }, event.provider_replay);
+        provider.seedProviderReplay({ content: event.content, toolCalls }, replay);
     }
 }
 export function peekProviderReplay(provider, content, toolCalls) {

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

@@ -0,0 +1,5 @@
+/** UTF-8-safe text helpers for session replay (defense in depth). */
+/** Soft cap — only snip very large llm_completed bodies before preload. */
+export declare const REPLAY_CONTENT_MAX_BYTES = 32768;
+export declare function truncateBytesAtCharBoundary(text: string, maxBytes: number): string;
+export declare function sanitizeReplayText(text: string, maxBytes?: number): string;

package/dist/runtime/replay-sanitize.js

@@ -0,0 +1,25 @@
+/** UTF-8-safe text helpers for session replay (defense in depth). */
+/** Soft cap — only snip very large llm_completed bodies before preload. */
+export const REPLAY_CONTENT_MAX_BYTES = 32_768;
+export function truncateBytesAtCharBoundary(text, maxBytes) {
+    const data = Buffer.from(text, "utf8");
+    if (data.length <= maxBytes)
+        return text;
+    let end = maxBytes;
+    while (end > 0) {
+        const slice = data.subarray(0, end).toString("utf8");
+        if (Buffer.byteLength(slice, "utf8") <= end)
+            return slice;
+        end -= 1;
+    }
+    return "";
+}
+export function sanitizeReplayText(text, maxBytes = REPLAY_CONTENT_MAX_BYTES) {
+    if (!text)
+        return text;
+    const safe = Buffer.from(text, "utf8").toString("utf8");
+    if (Buffer.byteLength(safe, "utf8") <= maxBytes)
+        return safe;
+    const prefix = truncateBytesAtCharBoundary(safe, maxBytes);
+    return `${prefix}… [replay truncated]`;
+}

package/dist/runtime/runner.d.ts

@@ -1,9 +1,12 @@
-import type { LLMProvider, StreamEvent, ToolSuspendEvent } from "../types.js";
-import type { DreamStore, DreamResult } from "../memory/protocols.js";
+import type { LLMProvider, Message, ToolSchema, StreamEvent, ToolSuspendEvent } from "../types.js";
+import type { DreamStore } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
 import type { SignalSource } from "../signals/types.js";
-import type { SessionLog } from "./session-log.js";
+import type { SessionLog, SessionEvent } from "./session-log.js";
+import type { ArchiveStore } from "./archive.js";
 import type { ExecutionPlane } from "./execution-plane.js";
+import type { AgentRunSpec, MilestoneCheckResult, MilestoneContract, MilestonePolicy } from "../types/agent.js";
+import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 export interface RuntimeOptions {
     provider: LLMProvider;
     sessionLog: SessionLog;
@@ -27,23 +30,76 @@ export interface RuntimeOptions {
             retryAfterMs?: number;
         };
     };
+    tokenizer?: string;
+    enablePlanTool?: boolean;
+    compressionStore?: ArchiveStore;
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
+    /** Default: terminate — stop with milestone_pending when a phase needs evaluation. */
+    milestonePolicy?: MilestonePolicy;
+    /** Optional external verifier when milestonePolicy is not auto_pass. */
+    onMilestoneEvaluate?: (ctx: {
+        phaseId: string;
+        criteria: string[];
+        requiredEvidence: string[];
+    }) => Promise<MilestoneCheckResult> | MilestoneCheckResult;
+    /** Passed to kernel start_run for role/isolation metadata. */
+    runSpec?: AgentRunSpec;
+    /** Loaded via load_milestone_contract before run start. */
+    milestoneContract?: MilestoneContract;
+    /** Custom sub-agent host driver; defaults to SubAgentOrchestrator. */
+    subAgentOrchestrator?: SubAgentOrchestrator;
+    /** Optional system prompt injected into the dream synthesis call. */
+    dreamSystemPrompt?: string;
 }
 export declare class RuntimeRunner {
     private readonly opts;
     private interrupted;
+    private activeKernel;
+    private pendingObservations;
+    private currentSessionId;
+    private nextArchiveStart;
     constructor(opts: RuntimeOptions);
+    /** Host configuration (for coordinator / sub-agent spawn). */
+    get hostOptions(): RuntimeOptions;
+    /** Mount a tool capability on the currently-running kernel runtime. No-op if not running. */
+    mountTool(schema: ToolSchema): void;
+    /** Mount a skill capability on the currently-running kernel runtime. No-op if not running. */
+    mountSkill(name: string, description: string): void;
+    /** Mount a generic marker capability (e.g. MCP server, agent) on the active run. No-op if not running. */
+    mountMarker(kind: string, id: string, description: string): void;
+    /** Unmount a capability by kind + id from the active run. No-op if not running. */
+    unmountCapability(kind: string, id: string): void;
+    /** Push a large artifact into the kernel artifacts partition (not inlined in history). */
+    pushArtifact(message: Message, tokens?: number): void;
+    /**
+     * Spawn an isolated sub-agent via the kernel, run it on the host, and feed the result back.
+     * Requires an active parent run (`run()` / `wake()` in progress or paused at milestone).
+     */
+    spawnSubAgent(spec: AgentRunSpec): AsyncIterable<StreamEvent>;
     interrupt(): void;
     run(req: {
         sessionId: string;
         goal: string;
         criteria?: string[];
         extensions?: Record<string, unknown>;
+        /** Parent transcript to preload (e.g. sub-agent full context inheritance). */
+        inheritEvents?: Array<{
+            seq: number;
+            event: SessionEvent;
+        }>;
     }): AsyncIterable<StreamEvent>;
     wake(sessionId: string, extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
-    dream(agentId: string, nowMs?: number): Promise<DreamResult>;
+    dream(agentId: string, nowMs?: number): AsyncIterable<StreamEvent>;
     private execute;
     private appendObservations;
 }
+export declare function replayMessages(events: Array<{
+    seq: number;
+    event: SessionEvent;
+}>, maxBytes?: number): Message[];
+export declare function replayMessagesAsync(events: Array<{
+    seq: number;
+    event: SessionEvent;
+}>, maxBytes?: number, loadArchive?: (archiveRef: string) => Promise<Message[]>): Promise<Message[]>;
 /** Collect all text_delta events from a run into a single string. */
 export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;