@deepstrike/sdk 0.1.13 → 0.1.15

package/dist/runtime/runner.js

@@ -0,0 +1,368 @@
+import { getKernel } from "../kernel.js";
+import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-replay.js";
+export class RuntimeRunner {
+    opts;
+    interrupted = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    interrupt() { this.interrupted = true; }
+    async *run(req) {
+        const prior = await this.opts.sessionLog.read(req.sessionId);
+        const midRun = isMidRun(prior);
+        if (!midRun) {
+            await this.opts.sessionLog.append(req.sessionId, {
+                kind: "run_started",
+                run_id: crypto.randomUUID(),
+                goal: req.goal,
+                criteria: req.criteria ?? [],
+                agent_id: this.opts.agentId,
+                system_prompt: this.opts.systemPrompt,
+            });
+        }
+        yield* this.execute(req.sessionId, req.goal, req.criteria ?? [], req.extensions, prior.length > 0 ? prior : undefined, midRun);
+    }
+    async *wake(sessionId, extensions) {
+        const events = await this.opts.sessionLog.read(sessionId);
+        if (events.some(e => e.event.kind === "run_terminal"))
+            return;
+        const startEntry = [...events].reverse().find(e => e.event.kind === "run_started");
+        if (!startEntry)
+            throw new Error(`No run_started event for session: ${sessionId}`);
+        const start = startEntry.event;
+        yield* this.execute(sessionId, start.goal, start.criteria, extensions, events, true);
+    }
+    async dream(agentId, nowMs = Date.now()) {
+        if (!this.opts.dreamStore)
+            throw new Error("dreamStore not configured");
+        const kernel = getKernel();
+        const sessions = await this.opts.dreamStore.loadSessions(agentId);
+        const existingMemories = await this.opts.dreamStore.loadMemories(agentId);
+        if (!sessions.length)
+            return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
+        const pipeline = new kernel.IdlePipeline(agentId);
+        const action1 = pipeline.feedTrigger(sessions.map(s => ({
+            sessionId: s.sessionId, agentId: s.agentId,
+            messages: s.messages.map(m => ({
+                role: m.role, content: m.content, tokenCount: m.tokenCount,
+                toolCalls: (m.toolCalls ?? []).map(tc => ({ id: tc.id, name: tc.name, arguments: tc.arguments })),
+            })),
+            metadata: JSON.stringify(s.metadata ?? null),
+            createdAtMs: s.createdAtMs, updatedAtMs: s.updatedAtMs,
+        })), existingMemories.map(e => ({ text: e.text, score: e.score, metadata: JSON.stringify(e.metadata ?? null) })), nowMs);
+        if (action1.kind === "noop" || action1.kind === "aborted") {
+            return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
+        }
+        if (action1.kind !== "synthesize_insights")
+            throw new Error(`unexpected: ${action1.kind}`);
+        let synthesisText = "";
+        const providerState = this.opts.provider.createRunState?.();
+        const synthMsgs = (action1.messages ?? []);
+        const synthContext = {
+            systemText: synthMsgs.filter(m => m.role === "system").map(m => m.content).join("\n\n"),
+            turns: synthMsgs.filter(m => m.role !== "system"),
+        };
+        for await (const evt of this.opts.provider.stream(synthContext, [], undefined, providerState)) {
+            if (evt.type === "text_delta")
+                synthesisText += evt.delta;
+        }
+        const action2 = pipeline.feedSynthesisResult(synthesisText);
+        if (action2.kind !== "commit_memories")
+            throw new Error(`unexpected: ${action2.kind}`);
+        const cr = action2.curationResult;
+        const rr = action2.runResult;
+        const dsResult = {
+            toAdd: (cr.toAdd ?? []).map((e) => ({
+                text: e.text, score: e.score, metadata: tryParseJson(e.metadata),
+            })),
+            toRemoveIndices: (cr.toRemoveIndices ?? []).map(Number),
+            stats: {
+                insightsProcessed: cr.stats?.insightsProcessed ?? 0,
+                duplicatesRemoved: cr.stats?.duplicatesRemoved ?? 0,
+                conflictsResolved: cr.stats?.conflictsResolved ?? 0,
+                entriesAdded: cr.stats?.entriesAdded ?? 0,
+            },
+        };
+        await this.opts.dreamStore.commit(agentId, dsResult, existingMemories);
+        return {
+            sessionsProcessed: rr.sessionsProcessed,
+            insightsExtracted: rr.insightsExtracted,
+            entriesAdded: cr.stats?.entriesAdded ?? 0,
+            entriesRemoved: (cr.toRemoveIndices ?? []).length,
+        };
+    }
+    async *execute(sessionId, goal, criteria, extensions, priorEvents, resumeMidRun = false) {
+        this.interrupted = false;
+        const kernel = getKernel();
+        const ext = { ...this.opts.extensions, ...(extensions ?? {}) };
+        const providerState = this.opts.provider.createRunState?.();
+        let nextCompressedArchiveStart = nextArchivedSeqStart(priorEvents);
+        // Three-layer policy merge: explicit RuntimeOptions > provider.runtimePolicy() > defaults
+        const providerPolicy = this.opts.provider.runtimePolicy?.() ?? {};
+        const effectiveMaxTurns = this.opts.maxTurns ?? providerPolicy.maxTurns ?? 25;
+        const effectiveTimeoutMs = this.opts.timeoutMs ?? providerPolicy.timeoutMs;
+        const sm = new kernel.LoopStateMachine({
+            maxTokens: this.opts.maxTokens,
+            maxTurns: effectiveMaxTurns,
+            timeoutMs: effectiveTimeoutMs !== undefined ? BigInt(effectiveTimeoutMs) : undefined,
+        });
+        const router = new kernel.SignalRouter(256);
+        sm.setTools(this.opts.executionPlane.schemas());
+        if (this.opts.systemPrompt) {
+            sm.addSystemMessage(this.opts.systemPrompt, Math.max(1, Math.ceil(this.opts.systemPrompt.length / 4)));
+        }
+        if (this.opts.initialMemory) {
+            for (const mem of this.opts.initialMemory) {
+                sm.addMemoryMessage(mem, Math.max(1, Math.ceil(mem.length / 4)));
+            }
+        }
+        if (this.opts.skillDir) {
+            const { scanSkillDir } = await import("../skills/loader.js");
+            const metas = await scanSkillDir(this.opts.skillDir);
+            sm.setAvailableSkills(metas.map((m) => ({
+                name: m.name, description: m.description, whenToUse: m.whenToUse,
+                effort: m.effort, estimatedTokens: m.estimatedTokens ?? 0,
+            })));
+        }
+        if (this.opts.dreamStore && this.opts.agentId)
+            sm.setMemoryEnabled(true);
+        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();
+        let action = resumeMidRun
+            ? sm.resumeAfterPreload()
+            : sm.start({ goal, criteria });
+        while (!sm.isTerminal()) {
+            nextCompressedArchiveStart = await this.appendObservations(sessionId, sm, nextCompressedArchiveStart);
+            if (this.interrupted) {
+                action = sm.feedTimeout();
+                break;
+            }
+            if (this.opts.signalSource) {
+                const sig = await this.opts.signalSource.nextSignal();
+                if (sig) {
+                    const kernelSig = {
+                        id: crypto.randomUUID(),
+                        source: sig.source ?? "custom",
+                        signalType: sig.signalType ?? "event",
+                        urgency: sig.urgency ?? "normal",
+                        summary: String(sig.payload?.goal ?? sig.kind ?? "signal"),
+                        payload: JSON.stringify(sig.payload ?? {}),
+                        dedupeKey: sig.dedupeKey,
+                        timestampMs: Date.now(),
+                    };
+                    const disposition = router.ingest(kernelSig, action.kind === "execute_tools");
+                    if (disposition === "interrupt_now") {
+                        action = sm.feedTimeout();
+                        break;
+                    }
+                }
+            }
+            let queued = router.next();
+            while (queued) {
+                if (queued.urgency === "critical") {
+                    action = sm.feedTimeout();
+                    break;
+                }
+                queued = router.next();
+            }
+            if (sm.isTerminal())
+                break;
+            if (action.kind === "call_llm") {
+                const finalToolCalls = [];
+                let finalText = "";
+                const context = action.context;
+                const tools = (action.tools ?? []);
+                let turnTokens = 0;
+                try {
+                    for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState)) {
+                        if (evt.type === "usage") {
+                            turnTokens = evt.totalTokens;
+                            continue;
+                        }
+                        yield evt;
+                        if (evt.type === "text_delta")
+                            finalText += evt.delta;
+                        else if (evt.type === "tool_call") {
+                            const tc = evt;
+                            finalToolCalls.push({ id: tc.id, name: tc.name, arguments: JSON.stringify(tc.arguments) });
+                        }
+                    }
+                }
+                catch (err) {
+                    yield { type: "error", message: String(err) };
+                    action = sm.feedTimeout();
+                    break;
+                }
+                action = sm.feedLlmResponse({
+                    role: "assistant",
+                    content: finalText,
+                    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") {
+                const allCalls = action.calls ?? [];
+                await this.opts.sessionLog.append(sessionId, { kind: "tool_requested", turn: sm.turn, calls: allCalls });
+                const runCtx = {
+                    agentId: this.opts.agentId,
+                    skillDir: this.opts.skillDir,
+                    dreamStore: this.opts.dreamStore,
+                    knowledgeSource: this.opts.knowledgeSource,
+                    governance: this.opts.governance,
+                    onToolSuspend: this.opts.onToolSuspend,
+                };
+                const toolResults = [];
+                for await (const evt of this.opts.executionPlane.executeAll(allCalls, runCtx)) {
+                    yield evt;
+                    if (evt.type === "tool_result") {
+                        const tre = evt;
+                        toolResults.push({ callId: tre.callId, output: tre.content, isError: tre.isError });
+                    }
+                }
+                await this.opts.sessionLog.append(sessionId, {
+                    kind: "tool_completed",
+                    turn: sm.turn,
+                    results: toolResults.map(r => ({
+                        call_id: r.callId,
+                        output: r.output,
+                        is_error: r.isError,
+                        token_count: r.tokenCount,
+                    })),
+                });
+                action = sm.feedToolResults(toolResults);
+            }
+            else if (action.kind === "done") {
+                break;
+            }
+        }
+        const result = action.result;
+        const status = result?.termination ?? "error";
+        const turnsUsed = result ? Math.max(1, result.turnsUsed) : 0;
+        const totalTokens = result?.totalTokensUsed ? Number(result.totalTokensUsed) : 0;
+        nextCompressedArchiveStart = await this.appendObservations(sessionId, sm, nextCompressedArchiveStart);
+        await this.opts.sessionLog.append(sessionId, { kind: "run_terminal", reason: status, turns_used: turnsUsed, total_tokens: totalTokens });
+        if (this.opts.dreamStore && this.opts.agentId) {
+            const newMsgs = sm.drainNewMessages().map(m => ({
+                role: m.role,
+                content: m.content,
+                contentParts: m.contentParts,
+                tokenCount: m.tokenCount,
+                toolCalls: m.toolCalls?.length ? m.toolCalls : undefined,
+            }));
+            if (newMsgs.length > 0) {
+                try {
+                    await this.opts.dreamStore.saveSession({
+                        sessionId: crypto.randomUUID(),
+                        agentId: this.opts.agentId,
+                        messages: newMsgs,
+                        metadata: null,
+                        createdAtMs: sessionStart,
+                        updatedAtMs: Date.now(),
+                    });
+                }
+                catch { /* non-fatal */ }
+            }
+        }
+        yield { type: "done", iterations: turnsUsed, totalTokens, status };
+    }
+    async appendObservations(sessionId, sm, nextArchiveStart) {
+        const observations = sm.takeObservations();
+        for (const obs of observations) {
+            if (obs.kind !== "compressed")
+                continue;
+            const latest = await this.opts.sessionLog.latestSeq(sessionId);
+            if (latest < nextArchiveStart)
+                continue;
+            const end = latest;
+            const compressedSeq = await this.opts.sessionLog.append(sessionId, {
+                kind: "compressed",
+                turn: sm.turn,
+                archived_seq_range: [nextArchiveStart, end],
+            });
+            nextArchiveStart = compressedSeq + 1;
+        }
+        return nextArchiveStart;
+    }
+}
+function isMidRun(events) {
+    return events.length > 0 && !events.some(e => e.event.kind === "run_terminal");
+}
+/**
+ * Replay session events into Message[] for preloadHistory.
+ * run_started → user turn; llm_completed → assistant; tool_completed → tool messages.
+ */
+function replayMessages(events) {
+    const messages = [];
+    for (const { event: e } of events) {
+        if (e.kind === "run_started") {
+            const userText = e.criteria.length
+                ? `${e.goal}\n\nCriteria:\n${e.criteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}`
+                : e.goal;
+            messages.push({
+                role: "user",
+                content: userText,
+                toolCalls: [],
+                tokenCount: Math.max(1, Math.ceil(userText.length / 4)),
+            });
+        }
+        else if (e.kind === "llm_completed") {
+            messages.push({
+                role: "assistant",
+                content: e.content,
+                toolCalls: e.tool_calls ?? [],
+                tokenCount: e.token_count,
+            });
+        }
+        else if (e.kind === "tool_completed") {
+            for (const r of e.results) {
+                messages.push({
+                    role: "tool",
+                    content: "",
+                    toolCalls: [],
+                    contentParts: [{ type: "tool_result", callId: r.call_id, output: r.output, isError: r.is_error ?? false }],
+                    tokenCount: r.token_count,
+                });
+            }
+        }
+    }
+    return messages;
+}
+function nextArchivedSeqStart(events) {
+    let next = 0;
+    for (const { event } of events ?? []) {
+        if (event.kind === "compressed")
+            next = Math.max(next, event.archived_seq_range[1] + 1);
+    }
+    return next;
+}
+function tryParseJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}
+/** Collect all text_delta events from a run into a single string. */
+export async function collectText(stream) {
+    let text = "";
+    for await (const evt of stream) {
+        if (evt.type === "text_delta")
+            text += evt.delta;
+    }
+    return text;
+}

package/dist/runtime/session-log.d.ts

@@ -0,0 +1,68 @@
+import type { ProviderReplay, ToolCall } from "../types.js";
+export type SessionEvent = {
+    kind: "run_started";
+    run_id: string;
+    goal: string;
+    criteria: string[];
+    agent_id?: string;
+    system_prompt?: string;
+} | {
+    kind: "llm_completed";
+    turn: number;
+    content: string;
+    token_count?: number;
+    tool_calls: ToolCall[];
+    provider_replay?: ProviderReplay;
+} | {
+    kind: "tool_requested";
+    turn: number;
+    calls: ToolCall[];
+} | {
+    kind: "tool_completed";
+    turn: number;
+    results: Array<{
+        call_id: string;
+        output: string;
+        is_error?: boolean;
+        token_count?: number;
+    }>;
+} | {
+    kind: "compressed";
+    turn: number;
+    archived_seq_range: [number, number];
+} | {
+    kind: "run_terminal";
+    reason: string;
+    turns_used: number;
+    total_tokens: number;
+};
+export interface SessionLog {
+    append(sessionId: string, event: SessionEvent): Promise<number>;
+    read(sessionId: string, fromSeq?: number): Promise<Array<{
+        seq: number;
+        event: SessionEvent;
+    }>>;
+    latestSeq(sessionId: string): Promise<number>;
+}
+export declare class InMemorySessionLog implements SessionLog {
+    private store;
+    append(sessionId: string, event: SessionEvent): Promise<number>;
+    read(sessionId: string, fromSeq?: number): Promise<Array<{
+        seq: number;
+        event: SessionEvent;
+    }>>;
+    latestSeq(sessionId: string): Promise<number>;
+}
+export declare class FileSessionLog implements SessionLog {
+    private dir;
+    private seqCounters;
+    constructor(dir: string);
+    private path;
+    private nextSeq;
+    append(sessionId: string, event: SessionEvent): Promise<number>;
+    read(sessionId: string, fromSeq?: number): Promise<Array<{
+        seq: number;
+        event: SessionEvent;
+    }>>;
+    latestSeq(sessionId: string): Promise<number>;
+}

package/dist/runtime/session-log.js

@@ -0,0 +1,84 @@
+import { createWriteStream, createReadStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+export class InMemorySessionLog {
+    store = new Map();
+    async append(sessionId, event) {
+        if (!this.store.has(sessionId))
+            this.store.set(sessionId, []);
+        const entries = this.store.get(sessionId);
+        const seq = entries.length;
+        entries.push({ seq, event });
+        return seq;
+    }
+    async read(sessionId, fromSeq = 0) {
+        return (this.store.get(sessionId) ?? []).filter(e => e.seq >= fromSeq);
+    }
+    async latestSeq(sessionId) {
+        const entries = this.store.get(sessionId);
+        return entries ? entries.length - 1 : -1;
+    }
+}
+// Single-writer per session. Safe for concurrent appends within one instance.
+// Cross-instance (multi-process) safety requires an external lock.
+export class FileSessionLog {
+    dir;
+    // Lazy-initialized per-session counter. Avoids re-reading the file on every append.
+    seqCounters = new Map();
+    constructor(dir) {
+        this.dir = dir;
+    }
+    path(sessionId) {
+        return join(this.dir, `${sessionId}.jsonl`);
+    }
+    async nextSeq(sessionId) {
+        if (!this.seqCounters.has(sessionId)) {
+            const existing = await this.read(sessionId);
+            this.seqCounters.set(sessionId, existing.length);
+        }
+        const seq = this.seqCounters.get(sessionId);
+        this.seqCounters.set(sessionId, seq + 1);
+        return seq;
+    }
+    async append(sessionId, event) {
+        await mkdir(this.dir, { recursive: true });
+        const seq = await this.nextSeq(sessionId);
+        await new Promise((resolve, reject) => {
+            const ws = createWriteStream(this.path(sessionId), { flags: "a" });
+            ws.write(JSON.stringify({ seq, event }) + "\n", err => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+            ws.end();
+        });
+        return seq;
+    }
+    async read(sessionId, fromSeq = 0) {
+        const results = [];
+        try {
+            const rl = createInterface({
+                input: createReadStream(this.path(sessionId)),
+                crlfDelay: Infinity,
+            });
+            for await (const line of rl) {
+                if (!line.trim())
+                    continue;
+                const entry = JSON.parse(line);
+                if (entry.seq >= fromSeq)
+                    results.push(entry);
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+        return results;
+    }
+    async latestSeq(sessionId) {
+        const entries = await this.read(sessionId);
+        return entries.length - 1;
+    }
+}

package/dist/types.d.ts

@@ -152,6 +152,13 @@ export interface RetryConfig {
  * Responses `previous_response_id` without leaking those semantics into the kernel.
  */
 export type ProviderRunState = Record<string, unknown>;
+/** Provider-native fields required to replay a turn across requests (thinking blocks, reasoning_content, etc.). */
+export interface ProviderReplay {
+    /** Anthropic-style assistant content blocks (thinking, text, tool_use). */
+    native_blocks?: Array<Record<string, unknown>>;
+    /** OpenAI-compatible reasoning field (DeepSeek, etc.). */
+    reasoning_content?: string;
+}
 /** Structured render output produced by the kernel for each LLM call. */
 export interface RenderedContext {
     /** Combined system text: system partition + dashboard (when non-empty).
@@ -162,8 +169,28 @@ export interface RenderedContext {
      *  Working-partition signals are already folded into the first user turn. */
     turns: Message[];
 }
+/**
+ * Runtime execution policy advertised by a provider.
+ * RuntimeRunner merges these with RuntimeOptions — explicit options always win.
+ */
+export interface RuntimePolicy {
+    /** Maximum agent turns before termination. */
+    maxTurns?: number;
+    /** Per-run wall-clock timeout in ms. */
+    timeoutMs?: number;
+}
 export interface LLMProvider {
     createRunState?(): ProviderRunState;
+    /**
+     * Optional: return the recommended runtime policy for this provider's model.
+     * RuntimeRunner uses this as a fallback when the caller has not specified
+     * maxTurns / timeoutMs in RuntimeOptions.
+     */
+    runtimePolicy?(): RuntimePolicy;
+    /** Read provider-native replay fields captured after the most recent assistant turn. */
+    peekProviderReplay?(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
+    /** Restore provider-native replay fields when rebuilding history from SessionLog. */
+    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/sdk",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -12,11 +12,12 @@
   "scripts": {
     "build": "tsc",
     "test": "node --experimental-vm-modules node_modules/.bin/jest",
+    "test:local-core": "cd ../crates/deepstrike-node && napi build --platform && cd ../../node && npm test",
     "smoke:providers": "node ../scripts/smoke-node-provider-loops.mjs"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
-    "@deepstrike/core": "0.1.13",
+    "@deepstrike/core": "0.1.15",
     "@google/generative-ai": "^0.24.1",
     "openai": "^4.77.0"
   },

package/dist/agent.d.ts

@@ -1,90 +0,0 @@
-import type { LLMProvider, StreamEvent, ToolSuspendEvent } from "./types.js";
-import type { RegisteredTool } from "./tools/index.js";
-import type { DreamStore, DreamResult, SessionStore } from "./memory/protocols.js";
-import type { KnowledgeSource } from "./knowledge/source.js";
-import type { SignalSource } from "./signals/types.js";
-export interface AgentOptions {
-    maxTokens: number;
-    maxTurns?: number;
-    timeoutMs?: number;
-    extensions?: Record<string, unknown>;
-    /**
-     * System-level instructions prepended to every context render.
-     * Passed to the kernel's `system` partition before the first LLM call.
-     */
-    systemPrompt?: string;
-    /**
-     * Directory containing skill `.md` files. The kernel auto-injects a `skill`
-     * meta-tool so the model can load any skill by name on demand.
-     */
-    skillDir?: string;
-    knowledgeSource?: KnowledgeSource;
-    signalSource?: SignalSource;
-    /** Backing store for the idle dreaming pipeline. Required to call `Agent.dream()`. */
-    dreamStore?: DreamStore;
-    /** Optional durable transcript store for same-session conversational continuity. */
-    sessionStore?: SessionStore;
-    /**
-     * Stable identifier for this agent. Required to enable in-session memory retrieval
-     * when `dreamStore` is configured.
-     */
-    agentId?: string;
-    /**
-     * SDK Governance instance or any object implementing
-     * `evaluate(toolName: string, argsJson: string): { kind: string; reason?: string; retryAfterMs?: number }`.
-     * When provided, every tool call is evaluated through the full pipeline.
-     */
-    onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
-    governance?: {
-        setTime?(nowMs: bigint): void;
-        evaluate(toolName: string, argsJson: string): {
-            kind: string;
-            reason?: string;
-            retryAfterMs?: number;
-        };
-    };
-}
-export declare class Agent {
-    private readonly provider;
-    private readonly options;
-    private tools;
-    private extensions;
-    private skillDir?;
-    private knowledgeSource?;
-    private signalSource?;
-    private dreamStore?;
-    private readonly inMemorySessions;
-    private interrupted;
-    private pendingInterrupt;
-    private _turn;
-    private _pressure;
-    constructor(provider: LLMProvider, options: AgentOptions);
-    /** Current turn index within the active run (0 before a run starts). */
-    get turn(): number;
-    /** Context pressure ratio [0–1] from the kernel. Values > 0.8 trigger compression. */
-    get pressure(): number;
-    interrupt(): void;
-    register(...tools: RegisteredTool[]): this;
-    unregister(name: string): this;
-    /**
-     * Collect the full text response and return it.
-     * For richer control (streaming, tool events, token counts) use `runStreaming`.
-     */
-    run(goal: string, criteria?: string[], extensions?: Record<string, unknown>, sessionId?: string): Promise<string>;
-    runStreaming(goal: string, criteria?: string[], extensions?: Record<string, unknown>, sessionId?: string): AsyncIterable<StreamEvent>;
-    private runRegularTool;
-    private loadSession;
-    private saveSession;
-    private toMessage;
-    private kernelMsgToSessionMsg;
-    /**
-     * Trigger the idle dreaming cycle for this agent.
-     * Requires `dreamStore` and `agentId` to be configured.
-     *
-     * Phase 1 — kernel rule-based analysis + LLM prompt assembly
-     * Phase 2 — LLM synthesis call (I/O)
-     * Phase 3 — kernel parses + curates results
-     * Phase 4 — commit delta to DreamStore (I/O)
-     */
-    dream(agentId: string, nowMs?: number): Promise<DreamResult>;
-}