@deepstrike/sdk 0.1.10 → 0.1.12

package/dist/collaboration/harness.js

@@ -0,0 +1,150 @@
+import { formatContractForSystemPrompt, contractToCriteriaStrings } from "./contract.js";
+import { HandoffBus } from "./handoff.js";
+/**
+ * ContractDrivenHarness — the core multi-agent execution primitive.
+ *
+ * Differs from HarnessLoop in three ways:
+ *   1. Executor and verifier are **separate Agent instances** — no shared history.
+ *   2. Verifier receives only the artifact + contract, not the implementation transcript.
+ *   3. Feedback returned to the executor is a structured list of Violations,
+ *      not a free-text LLM summary.
+ *
+ * Protocol per attempt:
+ *   executor.run(goal, contract) → artifact
+ *   verifier.runIsolated(artifact, contract) → audit text
+ *   parse audit text → ContractCheckResult[]
+ *   all required criteria pass → Done
+ *   violations remain → inject only violation list into next executor goal
+ *   maxAttempts exceeded → produce HandoffArtifact with blocked_on
+ */
+export class ContractDrivenHarness {
+    pool;
+    contract;
+    maxAttempts;
+    onViolation;
+    constructor(pool, contract, options = {}) {
+        this.pool = pool;
+        this.contract = contract;
+        this.maxAttempts = options.maxAttempts ?? 3;
+        this.onViolation = options.onViolation;
+    }
+    async run() {
+        let artifact = "";
+        let checkResults = [];
+        let attemptsUsed = 0;
+        let currentGoal = this.contract.goal;
+        for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+            attemptsUsed = attempt;
+            // ── Phase 1: Executor ──────────────────────────────────────────────────
+            // Executor sees: contract block + goal. No verifier history.
+            const contractBlock = formatContractForSystemPrompt(this.contract);
+            const violationNote = attempt > 1
+                ? `\n\n[Previous attempt failed. Violations to fix:\n${this._formatViolationsForFeedback(checkResults)}]`
+                : "";
+            const executorGoal = `${contractBlock}\n\n---\n\n${currentGoal}${violationNote}`;
+            artifact = await this.pool.get("executor").run(executorGoal, contractToCriteriaStrings(this.contract));
+            // ── Phase 2: Verifier ──────────────────────────────────────────────────
+            // Verifier sees: artifact + contract only. No executor history.
+            const auditText = await this.pool.runVerifier({ contract: this.contract, artifact });
+            // ── Phase 3: Parse audit → ContractCheckResult[] ──────────────────────
+            checkResults = this._parseAuditText(auditText);
+            const violations = this._findViolations(checkResults);
+            if (violations.length === 0) {
+                // All required criteria passed
+                return {
+                    success: true,
+                    artifact,
+                    checkResults,
+                    attemptsUsed,
+                    totalTokensConsumed: 0,
+                    handoff: HandoffBus.fromContractOutcome({
+                        contract: this.contract,
+                        checkResults,
+                        artifact,
+                        success: true,
+                    }),
+                };
+            }
+            this.onViolation?.(violations);
+        }
+        // Max attempts exhausted
+        const blockedOn = this._findViolations(checkResults).map(v => `[${v.criterionId}] ${v.text}: ${v.detail}`);
+        return {
+            success: false,
+            artifact,
+            checkResults,
+            attemptsUsed,
+            totalTokensConsumed: 0,
+            handoff: HandoffBus.fromContractOutcome({
+                contract: this.contract,
+                checkResults,
+                artifact,
+                success: false,
+                blockedOn,
+            }),
+        };
+    }
+    _findViolations(results) {
+        const violations = [];
+        for (const result of results) {
+            if (!result.passed) {
+                const criterion = this.contract.acceptance.find(c => c.id === result.criterionId);
+                if (criterion?.required) {
+                    violations.push({
+                        criterionId: result.criterionId,
+                        text: criterion.text,
+                        detail: result.evidence ?? "no evidence provided",
+                    });
+                }
+            }
+        }
+        return violations;
+    }
+    _formatViolationsForFeedback(results) {
+        return this._findViolations(results)
+            .map(v => `- [${v.criterionId}] ${v.text}: ${v.detail}`)
+            .join("\n");
+    }
+    /**
+     * Parse the verifier's free-text audit into structured ContractCheckResult[].
+     *
+     * The verifier is prompted to produce a structured PASS/FAIL per criterion.
+     * This parser handles the common patterns; callers can subclass and override
+     * for stricter parsing.
+     */
+    _parseAuditText(auditText) {
+        const results = [];
+        const lower = auditText.toLowerCase();
+        for (const criterion of this.contract.acceptance) {
+            // Look for explicit "id: PASS" or "id: FAIL" patterns from the verifier prompt
+            const idPattern = new RegExp(`\\b${criterion.id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b[^\\n]*?(pass|fail)`, "i");
+            const match = auditText.match(idPattern);
+            if (match) {
+                const passed = match[1].toLowerCase() === "pass";
+                // Extract the line as evidence
+                const lineStart = auditText.lastIndexOf("\n", match.index ?? 0) + 1;
+                const lineEnd = auditText.indexOf("\n", match.index ?? 0);
+                const evidence = auditText.slice(lineStart, lineEnd > 0 ? lineEnd : undefined).trim();
+                results.push({ criterionId: criterion.id, passed, evidence });
+            }
+            else {
+                // Fallback: search for criterion text near PASS/FAIL keywords
+                const textIdx = lower.indexOf(criterion.text.toLowerCase().slice(0, 30));
+                if (textIdx !== -1) {
+                    const window = lower.slice(textIdx, textIdx + 200);
+                    const passed = window.includes("pass") && !window.includes("fail");
+                    results.push({ criterionId: criterion.id, passed, evidence: "inferred from context" });
+                }
+                else {
+                    // No mention found — conservative: treat as failed
+                    results.push({
+                        criterionId: criterion.id,
+                        passed: false,
+                        evidence: "criterion not mentioned in audit",
+                    });
+                }
+            }
+        }
+        return results;
+    }
+}

package/dist/collaboration/index.d.ts

@@ -0,0 +1,10 @@
+export type { AcceptanceCriterion, VerificationContract, ContractCheckResult, } from "./contract.js";
+export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./contract.js";
+export { AgentPool } from "./pool.js";
+export type { AgentRole, IsolatedVerifierContext } from "./pool.js";
+export { ContractDrivenHarness } from "./harness.js";
+export type { ContractOutcome, ContractHarnessOptions, Violation, } from "./harness.js";
+export { HandoffBus } from "./handoff.js";
+export type { HandoffArtifact, ContractOutcomeInput } from "./handoff.js";
+export { CreatorVerifierMode, OrchestrationMode } from "./modes/creator-verifier.js";
+export type { CreatorVerifierMetrics } from "./modes/creator-verifier.js";

package/dist/collaboration/index.js

@@ -0,0 +1,9 @@
+export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./contract.js";
+// AgentPool
+export { AgentPool } from "./pool.js";
+// ContractDrivenHarness
+export { ContractDrivenHarness } from "./harness.js";
+// HandoffBus
+export { HandoffBus } from "./handoff.js";
+// Collaboration modes
+export { CreatorVerifierMode, OrchestrationMode } from "./modes/creator-verifier.js";

package/dist/collaboration/modes/creator-verifier.d.ts

@@ -0,0 +1,69 @@
+import type { AgentPool } from "../pool.js";
+import type { VerificationContract } from "../contract.js";
+import type { ContractOutcome } from "../harness.js";
+export interface CreatorVerifierMetrics {
+    total: number;
+    failed: number;
+    driftRate: number;
+}
+/**
+ * CreatorVerifierMode — the simplest multi-agent collaboration pattern.
+ *
+ * Wires an executor + verifier from an AgentPool into a ContractDrivenHarness.
+ * The executor creates, the verifier audits. Contexts are fully isolated.
+ *
+ * Usage:
+ * ```ts
+ * const pool = new AgentPool()
+ *   .add("executor", new Agent(provider, { maxTokens: 32_000, skillDir }))
+ *   .add("verifier", new Agent(provider, { maxTokens: 8_000 }))
+ *
+ * const mode = new CreatorVerifierMode(pool)
+ * const result = await mode.run(contract)
+ *
+ * if (HandoffBus.requiresEscalation(result.handoff)) {
+ *   // drift > 5% or blocked_on is non-empty → pause autonomous delegation
+ * }
+ * ```
+ */
+export declare class CreatorVerifierMode {
+    private pool;
+    private options;
+    private _total;
+    private _failed;
+    constructor(pool: AgentPool, options?: {
+        maxAttempts?: number;
+    });
+    run(contract: VerificationContract): Promise<ContractOutcome>;
+    /** Aggregate drift metrics across all runs through this mode instance. */
+    getMetrics(): CreatorVerifierMetrics;
+    /**
+     * True when accumulated drift rate exceeds threshold.
+     * When true, pause autonomous delegation and surface to human or orchestrator.
+     */
+    isDrifting(threshold?: number): boolean;
+    /** Reset accumulated metrics (e.g. at the start of a new sprint). */
+    resetMetrics(): void;
+}
+/**
+ * OrchestrationMode — three-role collaboration: orchestrator → executor → verifier.
+ *
+ * The orchestrator produces a VerificationContract from a raw goal, then
+ * CreatorVerifierMode executes it.
+ *
+ * Requires all three roles in the pool: orchestrator, executor, verifier.
+ */
+export declare class OrchestrationMode {
+    private pool;
+    private options;
+    private inner;
+    constructor(pool: AgentPool, options?: {
+        maxAttempts?: number;
+    });
+    run(goal: string): Promise<ContractOutcome & {
+        contract: VerificationContract;
+    }>;
+    getMetrics(): CreatorVerifierMetrics;
+    isDrifting(threshold?: number): boolean;
+    private _parseContract;
+}

package/dist/collaboration/modes/creator-verifier.js

@@ -0,0 +1,124 @@
+import { ContractDrivenHarness } from "../harness.js";
+/**
+ * CreatorVerifierMode — the simplest multi-agent collaboration pattern.
+ *
+ * Wires an executor + verifier from an AgentPool into a ContractDrivenHarness.
+ * The executor creates, the verifier audits. Contexts are fully isolated.
+ *
+ * Usage:
+ * ```ts
+ * const pool = new AgentPool()
+ *   .add("executor", new Agent(provider, { maxTokens: 32_000, skillDir }))
+ *   .add("verifier", new Agent(provider, { maxTokens: 8_000 }))
+ *
+ * const mode = new CreatorVerifierMode(pool)
+ * const result = await mode.run(contract)
+ *
+ * if (HandoffBus.requiresEscalation(result.handoff)) {
+ *   // drift > 5% or blocked_on is non-empty → pause autonomous delegation
+ * }
+ * ```
+ */
+export class CreatorVerifierMode {
+    pool;
+    options;
+    _total = 0;
+    _failed = 0;
+    constructor(pool, options = {}) {
+        this.pool = pool;
+        this.options = options;
+    }
+    async run(contract) {
+        this._total++;
+        const harness = new ContractDrivenHarness(this.pool, contract, {
+            maxAttempts: this.options.maxAttempts ?? 3,
+        });
+        const outcome = await harness.run();
+        if (!outcome.success) {
+            this._failed++;
+        }
+        return outcome;
+    }
+    /** Aggregate drift metrics across all runs through this mode instance. */
+    getMetrics() {
+        return {
+            total: this._total,
+            failed: this._failed,
+            driftRate: this._total > 0 ? this._failed / this._total : 0,
+        };
+    }
+    /**
+     * True when accumulated drift rate exceeds threshold.
+     * When true, pause autonomous delegation and surface to human or orchestrator.
+     */
+    isDrifting(threshold = 0.05) {
+        return this.getMetrics().driftRate > threshold;
+    }
+    /** Reset accumulated metrics (e.g. at the start of a new sprint). */
+    resetMetrics() {
+        this._total = 0;
+        this._failed = 0;
+    }
+}
+/**
+ * OrchestrationMode — three-role collaboration: orchestrator → executor → verifier.
+ *
+ * The orchestrator produces a VerificationContract from a raw goal, then
+ * CreatorVerifierMode executes it.
+ *
+ * Requires all three roles in the pool: orchestrator, executor, verifier.
+ */
+export class OrchestrationMode {
+    pool;
+    options;
+    inner;
+    constructor(pool, options = {}) {
+        this.pool = pool;
+        this.options = options;
+        this.inner = new CreatorVerifierMode(pool, options);
+    }
+    async run(goal) {
+        // Step 1: orchestrator produces a VerificationContract
+        const contractJson = await this.pool.runOrchestrator(goal);
+        const contract = this._parseContract(contractJson, goal);
+        // Step 2: CreatorVerifierMode executes against the contract
+        const outcome = await this.inner.run(contract);
+        return { ...outcome, contract };
+    }
+    getMetrics() {
+        return this.inner.getMetrics();
+    }
+    isDrifting(threshold = 0.05) {
+        return this.inner.isDrifting(threshold);
+    }
+    _parseContract(json, fallbackGoal) {
+        try {
+            // Extract JSON block from markdown fences if present
+            const match = json.match(/```(?:json)?\s*([\s\S]*?)```/) ?? [null, json];
+            const raw = JSON.parse(match[1] ?? json);
+            return {
+                id: raw.id ?? "orchestrated",
+                goal: raw.goal ?? fallbackGoal,
+                acceptance: (raw.acceptance ?? []).map((c) => ({
+                    id: String(c.id ?? "criterion"),
+                    text: String(c.text ?? ""),
+                    required: c.required !== false,
+                    weight: Number(c.weight ?? 1.0),
+                    machineCheckable: Boolean(c.machineCheckable ?? false),
+                })),
+                antiPatterns: (raw.antiPatterns ?? []).map(String),
+                evidenceRequired: (raw.evidenceRequired ?? []).map(String),
+            };
+        }
+        catch {
+            // Orchestrator produced unparseable output — return a minimal contract
+            return {
+                id: "fallback",
+                goal: fallbackGoal,
+                acceptance: [{ id: "complete", text: "Goal is satisfactorily completed", required: true, weight: 1.0, machineCheckable: false }],
+                antiPatterns: [],
+                evidenceRequired: [],
+            };
+        }
+    }
+}

package/dist/collaboration/pool.d.ts

@@ -0,0 +1,46 @@
+import type { Agent } from "../agent.js";
+import type { VerificationContract } from "./contract.js";
+/**
+ * Roles in a multi-agent collaboration.
+ *
+ * - orchestrator: strong-reasoning, produces VerificationContracts; no tools beyond planning
+ * - executor:     code/task execution, full tool access, sees goal + contract only
+ * - verifier:     adversarial auditor, no tools, low temperature, sees artifact + contract only
+ */
+export type AgentRole = "orchestrator" | "executor" | "verifier";
+/** Context passed to a verifier run — intentionally minimal. */
+export interface IsolatedVerifierContext {
+    contract: VerificationContract;
+    /** The artifact produced by the executor. */
+    artifact: string;
+}
+/**
+ * AgentPool manages a set of role-specific Agent instances.
+ *
+ * Each role runs in its own Agent instance with an independent history partition,
+ * ensuring that the verifier never sees the executor's implementation transcript.
+ *
+ * Usage:
+ * ```ts
+ * const pool = new AgentPool()
+ *   .add("executor", executorAgent)
+ *   .add("verifier", verifierAgent)
+ * ```
+ */
+export declare class AgentPool {
+    private agents;
+    add(role: AgentRole, agent: Agent): this;
+    has(role: AgentRole): boolean;
+    get(role: AgentRole): Agent;
+    /**
+     * Run the verifier with an isolated context — only the artifact and contract.
+     * The verifier does NOT receive the executor's conversation history.
+     * Returns a structured audit response as a plain string.
+     */
+    runVerifier(ctx: IsolatedVerifierContext): Promise<string>;
+    /**
+     * Run the orchestrator to decompose a high-level goal into a VerificationContract.
+     * The orchestrator receives the goal and must produce a structured contract in JSON.
+     */
+    runOrchestrator(goal: string): Promise<string>;
+}

package/dist/collaboration/pool.js

@@ -0,0 +1,80 @@
+import { formatContractForSystemPrompt } from "./contract.js";
+/**
+ * AgentPool manages a set of role-specific Agent instances.
+ *
+ * Each role runs in its own Agent instance with an independent history partition,
+ * ensuring that the verifier never sees the executor's implementation transcript.
+ *
+ * Usage:
+ * ```ts
+ * const pool = new AgentPool()
+ *   .add("executor", executorAgent)
+ *   .add("verifier", verifierAgent)
+ * ```
+ */
+export class AgentPool {
+    agents = new Map();
+    add(role, agent) {
+        this.agents.set(role, agent);
+        return this;
+    }
+    has(role) {
+        return this.agents.has(role);
+    }
+    get(role) {
+        const agent = this.agents.get(role);
+        if (!agent)
+            throw new Error(`AgentPool: no agent registered for role "${role}"`);
+        return agent;
+    }
+    /**
+     * Run the verifier with an isolated context — only the artifact and contract.
+     * The verifier does NOT receive the executor's conversation history.
+     * Returns a structured audit response as a plain string.
+     */
+    async runVerifier(ctx) {
+        const agent = this.get("verifier");
+        const contractBlock = formatContractForSystemPrompt(ctx.contract);
+        const auditGoal = [
+            contractBlock,
+            "",
+            "---",
+            "",
+            "## Artifact to Audit",
+            "",
+            ctx.artifact,
+            "",
+            "---",
+            "",
+            "Audit the artifact against every criterion in the contract above.",
+            "For each criterion, state whether it PASSED or FAILED and cite specific evidence.",
+            "List any anti-patterns you detected.",
+            "Conclude with an overall PASS or FAIL verdict.",
+        ].join("\n");
+        return agent.run(auditGoal);
+    }
+    /**
+     * Run the orchestrator to decompose a high-level goal into a VerificationContract.
+     * The orchestrator receives the goal and must produce a structured contract in JSON.
+     */
+    async runOrchestrator(goal) {
+        const agent = this.get("orchestrator");
+        const orchestratorGoal = [
+            `You are a planning orchestrator. Decompose the following goal into a VerificationContract.`,
+            ``,
+            `Goal: ${goal}`,
+            ``,
+            `Produce a JSON object with this schema:`,
+            `{`,
+            `  "id": "<kebab-case-id>",`,
+            `  "goal": "<restated goal>",`,
+            `  "acceptance": [{ "id": "<id>", "text": "<criterion>", "required": true, "weight": 0.x, "machineCheckable": false }],`,
+            `  "antiPatterns": ["<pattern>"],`,
+            `  "evidenceRequired": ["<evidence item>"]`,
+            `}`,
+            ``,
+            `Output ONLY the JSON object, no prose.`,
+        ].join("\n");
+        return agent.run(orchestratorGoal);
+    }
+}

package/dist/harness/harness.js

@@ -92,7 +92,13 @@ export class HarnessLoop {
             if (evalAction.kind !== "evaluate")
                 break;
             let evalText = "";
-            for await (const evt of this.evalProvider.stream(evalAction.messages ?? [], [], undefined)) {
+            // Wrap harness eval messages in a RenderedContext (system messages → systemText, rest → turns).
+            const evalMsgs = evalAction.messages ?? [];
+            const evalContext = {
+                systemText: evalMsgs.filter((m) => m.role === "system").map((m) => m.content).join("\n\n"),
+                turns: evalMsgs.filter((m) => m.role !== "system"),
+            };
+            for await (const evt of this.evalProvider.stream(evalContext, [], undefined)) {
                 if (evt.type === "text_delta")
                     evalText += evt.delta;
             }

package/dist/index.d.ts

@@ -20,7 +20,7 @@ export type { RegisteredTool } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
 export type { SkillMetadata } from "./skills/loader.js";
 export { WorkingMemory } from "./memory/working.js";
-export type { DreamStore, DreamResult, SessionData, SessionMessage, MemoryEntry, CurationResult, CurationStats, } from "./memory/protocols.js";
+export type { DreamStore, DreamResult, SessionStore, SessionData, SessionMessage, MemoryEntry, CurationResult, CurationStats, } from "./memory/protocols.js";
 export type { KnowledgeSource } from "./knowledge/source.js";
 export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
 export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions, QualityGate } from "./harness/harness.js";
@@ -31,4 +31,14 @@ export { PermissionManager, PermissionMode } from "./safety/permissions.js";
 export type { PermissionDecision, Permission } from "./safety/permissions.js";
 export { Governance } from "./governance.js";
 export type { GovernanceVerdict } from "./governance.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, } from "./types.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, RenderedContext, } from "./types.js";
+export type { AcceptanceCriterion, VerificationContract, ContractCheckResult, } from "./collaboration/contract.js";
+export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
+export { AgentPool } from "./collaboration/pool.js";
+export type { AgentRole, IsolatedVerifierContext } from "./collaboration/pool.js";
+export { ContractDrivenHarness } from "./collaboration/harness.js";
+export type { ContractOutcome, ContractHarnessOptions, Violation } from "./collaboration/harness.js";
+export { HandoffBus } from "./collaboration/handoff.js";
+export type { HandoffArtifact, ContractOutcomeInput } from "./collaboration/handoff.js";
+export { CreatorVerifierMode, OrchestrationMode } from "./collaboration/modes/creator-verifier.js";
+export type { CreatorVerifierMetrics } from "./collaboration/modes/creator-verifier.js";

package/dist/index.js

@@ -20,3 +20,8 @@ export { ScheduledPrompt } from "./signals/scheduled.js";
 export { SignalGateway } from "./signals/gateway.js";
 export { PermissionManager, PermissionMode } from "./safety/permissions.js";
 export { Governance } from "./governance.js";
+export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
+export { AgentPool } from "./collaboration/pool.js";
+export { ContractDrivenHarness } from "./collaboration/harness.js";
+export { HandoffBus } from "./collaboration/handoff.js";
+export { CreatorVerifierMode, OrchestrationMode } from "./collaboration/modes/creator-verifier.js";

package/dist/kernel.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ToolCall, ToolResult, ToolSchema } from "./types.js";
+import type { Message, RenderedContext, ToolCall, ToolResult, ToolSchema } from "./types.js";
 import type { SkillMetadata } from "./skills/loader.js";
 export interface GovernanceVerdict {
     kind: "allow" | "deny" | "rate_limited" | "ask_user";
@@ -28,7 +28,7 @@ export interface RuntimeSignal {
 }
 export interface LoopAction {
     kind: "call_llm" | "execute_tools" | "done";
-    messages?: Message[];
+    context?: RenderedContext;
     tools?: ToolSchema[];
     calls?: ToolCall[];
     result?: {
@@ -48,6 +48,7 @@ interface LoopStateMachineInstance {
     setKnowledgeEnabled(enabled: boolean): void;
     addSystemMessage(content: string, tokens: number): void;
     addMemoryMessage(content: string, tokens: number): void;
+    addHistoryMessage(message: Message, tokens: number): void;
     setTools(tools: ToolSchema[]): void;
     start(task: {
         goal: string;
@@ -57,6 +58,8 @@ interface LoopStateMachineInstance {
     feedToolResults(results: ToolResult[]): LoopAction;
     feedTimeout(): LoopAction;
     isTerminal(): boolean;
+    preloadHistory(messages: Message[]): void;
+    drainNewMessages(): Message[];
     readonly turn: number;
     pressure(): number;
     takeObservations(): LoopObservation[];

package/dist/memory/protocols.d.ts

@@ -1,7 +1,9 @@
-import type { Message } from "../types.js";
+import type { Message, ContentPart } from "../types.js";
 export interface SessionMessage {
     role: Message["role"];
     content: string;
+    /** Structured multimodal parts. Preserved for round-trip fidelity (e.g. tool result messages). */
+    contentParts?: ContentPart[];
     tokenCount?: number;
     toolCalls?: Array<{
         id: string;
@@ -43,6 +45,11 @@ export interface DreamStore {
     /** Persist a completed session for future consolidation via `Agent.dream()`. */
     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, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
 interface AnthropicProviderOptions {
     baseURL?: string;
     authMode?: "api-key" | "bearer";
@@ -15,8 +15,8 @@ export declare class AnthropicProvider implements LLMProvider {
         baseDelay: number;
     }, options?: AnthropicProviderOptions);
     private buildTools;
-    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    complete(context: RenderedContext, tools: ToolSchema[]): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
     private buildMessages;
     private rememberNativeBlocks;
     private assistantReplayKey;

package/dist/providers/anthropic.js

@@ -1,6 +1,6 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { withServerRuntimeGuard } from "../runtime/server.js";
-import { CircuitBreaker, normalizeToolCall, splitAnthropicSystem, toAnthropicMessages } from "./base.js";
+import { CircuitBreaker, normalizeToolCall, toAnthropicMessages } from "./base.js";
 export class AnthropicProvider {
     model;
     client;
@@ -25,11 +25,11 @@ export class AnthropicProvider {
             input_schema: JSON.parse(t.parameters),
         }));
     }
-    async complete(messages, tools) {
+    async complete(context, tools) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
-        const system = splitAnthropicSystem(messages);
-        const msgs = this.buildMessages(messages);
+        const system = context.systemText || undefined;
+        const msgs = this.buildMessages(context);
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
@@ -65,9 +65,9 @@ export class AnthropicProvider {
         }
         throw lastErr;
     }
-    async *stream(messages, tools, extensions) {
-        const system = splitAnthropicSystem(messages);
-        const msgs = this.buildMessages(messages);
+    async *stream(context, tools, extensions) {
+        const system = context.systemText || undefined;
+        const msgs = this.buildMessages(context);
         const toolBlocks = {};
         const nativeBlocks = {};
         let finalText = "";
@@ -121,8 +121,8 @@ export class AnthropicProvider {
         }
         this.rememberNativeBlocks({ content: finalText, toolCalls: finalToolCalls }, Object.keys(nativeBlocks).map(Number).sort((a, b) => a - b).map(index => nativeBlocks[index]));
     }
-    buildMessages(messages) {
-        return toAnthropicMessages(messages, message => this.nativeAssistantBlocks.get(this.assistantReplayKey(message)));
+    buildMessages(context) {
+        return toAnthropicMessages(context.turns, message => this.nativeAssistantBlocks.get(this.assistantReplayKey(message)));
     }
     rememberNativeBlocks(message, blocks) {
         if (!message.toolCalls?.length)