@deepstrike/wasm 0.2.52 → 0.2.61

package/README.md

@@ -6,7 +6,7 @@
 
 # DeepStrike WASM SDK
 
-Runtime framework built on a Rust kernel compiled to WebAssembly. Runs in browsers, Cloudflare Workers, Deno Deploy, and Vercel Edge — anywhere that supports `fetch` and WASM.
+Build browser and edge Agents with providers, typed tools, memory interfaces, Skills, governance, and durable session evidence. The WASM SDK runs wherever `fetch` and WebAssembly are available, including browsers, Cloudflare Workers, Deno Deploy, and Vercel Edge.
 
 ## Install
 
@@ -77,7 +77,7 @@ src/
 ├── types.ts          # Shared type definitions
 ├── providers/        # LLM adapters (fetch-based SSE)
 ├── tools/            # tool() helper, executeTools (no fs/shell)
-├── memory/           # WorkingMemory + DreamStore interfaces
+├── memory/           # WorkingMemory + MemoryStore interfaces
 ├── knowledge/        # KnowledgeSource interface
 ├── harness/          # AttemptLoop body/judge/carry/stop policies
 ├── signals/          # RuntimeSignal, SignalSource, ScheduledPrompt
@@ -88,7 +88,7 @@ The kernel (`@deepstrike/wasm-kernel`, Rust/wasm-bindgen) owns:
 - the Canonical Kernel ABI durable `prepare → append → commit` transition contract
 - typed effects, a single effect-resolution input, observations, and terminal disposition
 - `ContextEngine` — 4-slot context with tiered history compression
-- `Governance` — tool veto authority
+- `GovernancePolicy` — declarative tool admission policy
 - `SignalRouter` — external interrupt queue
 
 ### WASM constraints vs Node SDK
@@ -110,13 +110,14 @@ The WASM SDK ships **no `readFile` built-in**. Tools must be pure JS / serializa
 
 All providers use `fetch` — no Node.js `http` module.
 
-| Class | Backend |
+| Entry point | Backend |
 |-------|---------|
 | `AnthropicProvider` | Anthropic API (SSE) |
 | `OpenAIProvider` | OpenAI API (SSE) |
-| `QwenProvider` | DashScope |
-| `DeepSeekProvider` | DeepSeek API |
-| `MiniMaxProvider` | MiniMax API |
+| `qwen(...)` | DashScope |
+| `deepseek(...)` | DeepSeek API |
+| `minimax(...)` | MiniMax API |
+| `kimi(...)` | Moonshot Kimi API |
 
 ```typescript
 import { AnthropicProvider } from "@deepstrike/wasm"
@@ -175,7 +176,7 @@ const runner = new RuntimeRunner({
 })
 ```
 
-IndexedDB / KV can back `DreamStore` for cross-session memory. Meta-tool retrieval still lands in **history**.
+IndexedDB / KV can back `MemoryStore` for cross-session memory. Meta-tool retrieval still lands in **history**.
 
 See [docs/concepts/context-slots-compression.md](../docs/concepts/context-slots-compression.md).
 
@@ -184,17 +185,17 @@ See [docs/concepts/context-slots-compression.md](../docs/concepts/context-slots-
 ## Governance
 
 ```typescript
-import { RuntimeRunner, AnthropicProvider, Governance } from "@deepstrike/wasm"
-
-const gov = new Governance()
-gov.blockTool("dangerous_tool")
+import { RuntimeRunner, AnthropicProvider } from "@deepstrike/wasm"
 
 const runner = new RuntimeRunner({
   provider: new AnthropicProvider(apiKey),
   sessionLog: new InMemorySessionLog(),
   executionPlane: new LocalExecutionPlane(),
   maxTokens: 32_000,
-  governance: gov,
+  governancePolicy: {
+    defaultAction: "allow",
+    rules: [{ pattern: "dangerous_tool", action: "deny" }],
+  },
 })
 ```
 
@@ -212,7 +213,7 @@ mem.set("step", 1)
 mem.get("step")   // 1
 ```
 
-For cross-session recall, implement `DreamStore` and set `agentId` on `RuntimeRunner`. In-session `memory(query)` results appear in **history**; preload durable blocks with `initialMemory` → Slot 2.
+For cross-session recall, implement `MemoryStore` and set `agentId` on `RuntimeRunner`. In-session `memory(query)` results appear in **history**; preload durable blocks with `initialMemory` → Slot 2.
 
 ---
 

package/dist/agent-ir.d.ts

@@ -0,0 +1,81 @@
+import { Agent, type AgentOptions, type AgentToolDefinition, type Guardrail, type Handoff, type Knowledge, type MCPServer, type ModelRef, type Skill } from "./agent.js";
+import type { AgentCapabilityFilter } from "./runtime/types/agent.js";
+import type { RegisteredTool } from "./tools/index.js";
+type JsonSchema = Record<string, unknown>;
+export interface AgentDefinition extends Omit<AgentOptions, "tools"> {
+    tools?: Array<RegisteredTool | AgentToolDefinition>;
+}
+export interface AgentToolIR {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+}
+export interface AgentMemoryIR {
+    kind: "durable" | "working";
+    namespace?: string;
+}
+export type AgentCapabilityIR = {
+    kind: "tool";
+    id: string;
+    description: string;
+} | {
+    kind: "mcp_server";
+    id: string;
+    description: string;
+} | {
+    kind: "skill";
+    id: string;
+    description: string;
+};
+export interface AgentLoweringInputs {
+    run: {
+        name: string;
+        model?: ModelRef;
+    };
+    context: {
+        description?: string;
+        instructions?: string;
+        outputSchema?: JsonSchema;
+        knowledge: Knowledge[];
+    };
+    capabilities: {
+        tools: AgentToolIR[];
+        mcpServers: MCPServer[];
+        skills: Skill[];
+        effective: AgentCapabilityIR[];
+    };
+    memory?: AgentMemoryIR;
+    delegation: {
+        handoffs: Handoff[];
+    };
+    governance: {
+        guardrails: Guardrail[];
+    };
+}
+/** Provider-neutral host descriptor. This is neither an execution plan nor a Kernel wire DTO. */
+export interface AgentSpec {
+    name: string;
+    description?: string;
+    instructions?: string;
+    model?: ModelRef;
+    tools: AgentToolIR[];
+    outputSchema?: JsonSchema;
+    mcpServers?: MCPServer[];
+    skills?: Skill[];
+    memory?: AgentMemoryIR;
+    knowledge?: Knowledge[];
+    handoffs?: Handoff[];
+    guardrails?: Guardrail[];
+    metadata?: Record<string, unknown>;
+    capabilities: AgentCapabilityIR[];
+    capabilityFilter?: AgentCapabilityFilter;
+    effectiveCapabilities: AgentCapabilityIR[];
+    extensions: Record<string, unknown>;
+    inputs: AgentLoweringInputs;
+}
+/** Native Agents need no normalization; JSON-safe declarations remain schema-only capabilities. */
+export declare function normalizeAgent(agent: Agent | AgentDefinition): Agent;
+/** Pure lowering only: providers, Kernel scheduling, persistence, and grants remain outside it. */
+export declare function lowerAgent(agent: Agent): AgentSpec;
+export {};

package/dist/agent-ir.js

@@ -0,0 +1,115 @@
+import { Agent, } from "./agent.js";
+import { WorkingMemory } from "./memory/index.js";
+function clone(value) {
+    if (value === undefined || value === null || typeof value !== "object")
+        return value;
+    if (Array.isArray(value))
+        return value.map(clone);
+    const copy = {};
+    for (const [key, nested] of Object.entries(value))
+        copy[key] = clone(nested);
+    return copy;
+}
+function isRegisteredTool(tool) {
+    return "schema" in tool && "execute" in tool;
+}
+/** Native Agents need no normalization; JSON-safe declarations remain schema-only capabilities. */
+export function normalizeAgent(agent) {
+    if (agent instanceof Agent)
+        return agent;
+    return new Agent({ ...agent, ...(agent.tools ? { tools: clone(agent.tools) } : {}) });
+}
+function lowerTool(tool) {
+    if (!isRegisteredTool(tool)) {
+        const parameters = clone(tool.parameters ?? { type: "object", properties: {} });
+        if (parameters.type !== "object") {
+            throw new Error(`tool "${tool.name}": parameters must be a JSON Schema with root type "object"`);
+        }
+        return {
+            name: tool.name,
+            description: tool.description ?? "",
+            parameters,
+            ...(tool.providerOptions ? { providerOptions: clone(tool.providerOptions) } : {}),
+        };
+    }
+    let parameters;
+    try {
+        parameters = JSON.parse(tool.schema.parameters);
+    }
+    catch {
+        throw new Error(`tool "${tool.schema.name}" has invalid JSON Schema parameters`);
+    }
+    if (!parameters || typeof parameters !== "object" || Array.isArray(parameters) || parameters.type !== "object") {
+        throw new Error(`tool "${tool.schema.name}" parameters must decode to an object`);
+    }
+    return { name: tool.schema.name, description: tool.schema.description, parameters: clone(parameters) };
+}
+function lowerMemory(memory) {
+    if (!memory)
+        return undefined;
+    if (memory instanceof WorkingMemory)
+        return { kind: "working" };
+    const reference = memory;
+    return { kind: "durable", ...(reference.namespace ? { namespace: reference.namespace } : {}) };
+}
+function capabilityAllowed(capability, filter) {
+    if (!filter)
+        return true;
+    const kindAllowed = !filter.allowedKinds?.length || filter.allowedKinds.includes(capability.kind);
+    const idAllowed = !filter.allowedIds?.length || filter.allowedIds.includes(capability.id);
+    return kindAllowed && idAllowed;
+}
+/** Pure lowering only: providers, Kernel scheduling, persistence, and grants remain outside it. */
+export function lowerAgent(agent) {
+    const tools = (agent.tools ?? []).map(lowerTool);
+    const mcpServers = clone(agent.mcpServers ?? []);
+    const skills = clone(agent.skills ?? []);
+    const knowledge = clone(agent.knowledge ?? []);
+    const handoffs = clone(agent.handoffs ?? []);
+    const guardrails = clone(agent.guardrails ?? []);
+    const memory = lowerMemory(agent.memory);
+    const extensions = clone(agent.providerOptions ?? {});
+    const capabilities = [
+        ...tools.map(tool => ({ kind: "tool", id: tool.name, description: tool.description })),
+        ...mcpServers.map(server => ({
+            kind: "mcp_server",
+            id: server.name ?? server.transport.kind,
+            description: server.name ?? `${server.transport.kind} MCP server`,
+        })),
+        ...skills.map(skill => ({ kind: "skill", id: skill.name, description: skill.description ?? "" })),
+    ];
+    const capabilityFilter = agent.capabilityFilter ? clone(agent.capabilityFilter) : undefined;
+    const effectiveCapabilities = capabilities.filter(capability => capabilityAllowed(capability, capabilityFilter));
+    return {
+        name: agent.name,
+        ...(agent.description ? { description: agent.description } : {}),
+        ...(agent.instructions ? { instructions: agent.instructions } : {}),
+        ...(agent.model ? { model: clone(agent.model) } : {}),
+        tools,
+        ...(agent.outputSchema ? { outputSchema: clone(agent.outputSchema) } : {}),
+        ...(mcpServers.length ? { mcpServers } : {}),
+        ...(skills.length ? { skills } : {}),
+        ...(memory ? { memory } : {}),
+        ...(knowledge.length ? { knowledge } : {}),
+        ...(handoffs.length ? { handoffs } : {}),
+        ...(guardrails.length ? { guardrails } : {}),
+        ...(agent.metadata ? { metadata: clone(agent.metadata) } : {}),
+        capabilities,
+        ...(capabilityFilter ? { capabilityFilter } : {}),
+        effectiveCapabilities,
+        extensions,
+        inputs: {
+            run: { name: agent.name, ...(agent.model ? { model: clone(agent.model) } : {}) },
+            context: {
+                ...(agent.description ? { description: agent.description } : {}),
+                ...(agent.instructions ? { instructions: agent.instructions } : {}),
+                ...(agent.outputSchema ? { outputSchema: clone(agent.outputSchema) } : {}),
+                knowledge,
+            },
+            capabilities: { tools, mcpServers, skills, effective: effectiveCapabilities },
+            ...(memory ? { memory } : {}),
+            delegation: { handoffs },
+            governance: { guardrails },
+        },
+    };
+}

package/dist/agent.d.ts

@@ -0,0 +1,140 @@
+import type { AgentCapabilityFilter } from "./runtime/types/agent.js";
+import type { Memory, WorkingMemory } from "./memory/index.js";
+import type { RegisteredTool } from "./tools/index.js";
+type JsonSchema = Record<string, unknown>;
+export interface MemoryReference {
+    kind?: "durable";
+    namespace?: string;
+}
+export type AgentMemory = Memory | WorkingMemory | MemoryReference;
+export type ModelRef = string | ModelRequirement;
+export interface ModelRequirement {
+    capability?: {
+        reasoning?: boolean;
+        vision?: boolean;
+        toolUse?: boolean;
+    };
+    contextWindow?: number;
+    latencyClass?: string;
+    costClass?: string;
+}
+export interface AgentToolDefinition {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+}
+export type McpTransport = {
+    kind: "stdio";
+    command: string;
+    args?: string[];
+} | {
+    kind: "http";
+    url: string;
+} | {
+    kind: "sse";
+    url: string;
+} | {
+    kind: "custom";
+    [key: string]: unknown;
+};
+export interface MCPServer {
+    name?: string;
+    transport: McpTransport;
+    tools?: string[];
+    resources?: boolean;
+    prompts?: boolean;
+    auth?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+}
+export interface Skill {
+    name: string;
+    description?: string;
+    instructions?: string;
+    resources?: unknown[];
+    scripts?: unknown[];
+    tools?: unknown[];
+    mcpServers?: unknown[];
+    knowledge?: unknown[];
+    metadata?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+}
+export type KnowledgeSourceRef = {
+    kind: "file";
+    path: string;
+} | {
+    kind: "directory";
+    path: string;
+} | {
+    kind: "text";
+    content: string;
+} | {
+    kind: "url";
+    url: string;
+} | {
+    kind: "vector";
+    retriever: unknown;
+} | {
+    kind: "custom";
+    [key: string]: unknown;
+};
+export interface Knowledge {
+    id?: string;
+    name?: string;
+    source: KnowledgeSourceRef;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+}
+export type AgentRef = string | {
+    name: string;
+};
+export interface Handoff {
+    agent: AgentRef;
+    description?: string;
+    inputSchema?: JsonSchema;
+    metadata?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+}
+export interface Guardrail {
+    name: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentOptions {
+    name: string;
+    description?: string;
+    instructions?: string;
+    model?: ModelRef;
+    capabilityFilter?: AgentCapabilityFilter;
+    tools?: Array<RegisteredTool | AgentToolDefinition>;
+    mcpServers?: MCPServer[];
+    skills?: Skill[];
+    memory?: AgentMemory;
+    knowledge?: Knowledge[];
+    handoffs?: Handoff[];
+    providerOptions?: Record<string, unknown>;
+    outputSchema?: JsonSchema;
+    metadata?: Record<string, unknown>;
+    guardrails?: Guardrail[];
+}
+export declare class Agent {
+    readonly name: string;
+    readonly description?: string;
+    readonly instructions?: string;
+    readonly model?: ModelRef;
+    readonly capabilityFilter?: AgentCapabilityFilter;
+    readonly tools?: Array<RegisteredTool | AgentToolDefinition>;
+    readonly mcpServers?: MCPServer[];
+    readonly skills?: Skill[];
+    readonly memory?: AgentMemory;
+    readonly knowledge?: Knowledge[];
+    readonly handoffs?: Handoff[];
+    readonly providerOptions?: Record<string, unknown>;
+    readonly outputSchema?: JsonSchema;
+    readonly metadata?: Record<string, unknown>;
+    readonly guardrails?: Guardrail[];
+    constructor(options: AgentOptions);
+}
+export {};

package/dist/agent.js

@@ -0,0 +1,34 @@
+export class Agent {
+    name;
+    description;
+    instructions;
+    model;
+    capabilityFilter;
+    tools;
+    mcpServers;
+    skills;
+    memory;
+    knowledge;
+    handoffs;
+    providerOptions;
+    outputSchema;
+    metadata;
+    guardrails;
+    constructor(options) {
+        this.name = options.name;
+        this.description = options.description;
+        this.instructions = options.instructions;
+        this.model = options.model;
+        this.capabilityFilter = options.capabilityFilter;
+        this.tools = options.tools;
+        this.mcpServers = options.mcpServers;
+        this.skills = options.skills;
+        this.memory = options.memory;
+        this.knowledge = options.knowledge;
+        this.handoffs = options.handoffs;
+        this.providerOptions = options.providerOptions;
+        this.outputSchema = options.outputSchema;
+        this.metadata = options.metadata;
+        this.guardrails = options.guardrails;
+    }
+}

package/dist/governance.d.ts

@@ -1,28 +1,3 @@
-export interface GovernanceVerdict {
-    kind: "allow" | "deny" | "rate_limited" | "ask_user";
-    reason?: string;
-    retryAfterMs?: number;
-}
-type DefaultAction = "allow" | "deny" | "ask_user";
-type RuleAction = "allow" | "deny" | "ask_user";
-export declare class Governance {
-    private _inner;
-    private _defaultAction;
-    private _pendingCalls;
-    constructor(defaultAction?: DefaultAction);
-    /** Called by Agent after the WASM kernel module is loaded. */
-    _attach(kernel: typeof import("@deepstrike/wasm-kernel")): void;
-    private _apply;
-    setIdentity(agentId: string, sessionId: string): this;
-    addPermissionRule(pattern: string, action: RuleAction): this;
-    blockTool(name: string): this;
-    setRateLimit(toolName: string, maxCalls: number, windowMs: number): this;
-    requireParam(toolName: string, paramPath: string): this;
-    allowParamValues(toolName: string, paramPath: string, allowedValues: string[]): this;
-    limitParamRange(toolName: string, paramPath: string, min?: number, max?: number): this;
-    setTime(nowMs: number): this;
-    evaluate(toolName: string, argsJson: string): GovernanceVerdict;
-}
 type GovernancePolicyAction = "allow" | "deny" | "ask_user";
 export interface GovernancePolicy {
     defaultAction?: GovernancePolicyAction;

package/dist/governance.js

@@ -1,56 +1,4 @@
-export class Governance {
-    _inner = null;
-    _defaultAction;
-    _pendingCalls = [];
-    constructor(defaultAction = "allow") {
-        this._defaultAction = defaultAction;
-    }
-    /** Called by Agent after the WASM kernel module is loaded. */
-    _attach(kernel) {
-        if (this._inner)
-            return;
-        this._inner = new kernel.Governance(this._defaultAction);
-        for (const fn_ of this._pendingCalls)
-            fn_(this._inner);
-        this._pendingCalls = [];
-    }
-    _apply(fn) {
-        if (this._inner)
-            fn(this._inner);
-        else
-            this._pendingCalls.push(fn);
-        return this;
-    }
-    setIdentity(agentId, sessionId) {
-        return this._apply(g => g.setIdentity(agentId, sessionId));
-    }
-    addPermissionRule(pattern, action) {
-        return this._apply(g => g.addPermissionRule(pattern, action));
-    }
-    blockTool(name) {
-        return this._apply(g => g.blockTool(name));
-    }
-    setRateLimit(toolName, maxCalls, windowMs) {
-        return this._apply(g => g.setRateLimit(toolName, maxCalls, windowMs));
-    }
-    requireParam(toolName, paramPath) {
-        return this._apply(g => g.requireParam(toolName, paramPath));
-    }
-    allowParamValues(toolName, paramPath, allowedValues) {
-        return this._apply(g => g.allowParamValues(toolName, paramPath, allowedValues));
-    }
-    limitParamRange(toolName, paramPath, min, max) {
-        return this._apply(g => g.limitParamRange(toolName, paramPath, min, max));
-    }
-    setTime(nowMs) {
-        return this._apply(g => g.setTime(nowMs));
-    }
-    evaluate(toolName, argsJson) {
-        if (!this._inner)
-            return { kind: "allow" };
-        return this._inner.evaluate(toolName, argsJson);
-    }
-}
+// ─── Declarative policy (in-kernel gate) ──────────────────────────────────────
 /** I5: bucket tools into allowed/denied per the policy. Pure. Mirrors Node. */
 export function governanceFilterSchema(tools, policy) {
     if (!policy)

package/dist/index.d.ts

@@ -7,30 +7,45 @@ export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";
-export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpec, WorkflowNodeSpec, WorkflowDependencyPolicy, WorkflowNodeStatus, WorkflowNodeOutcome, WorkflowOutcome, WorkflowTaskSpec, WorkflowSpawnInfo, } from "./runtime/types/agent.js";
+export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpec, WorkflowNodeSpec, SchedulingFactors, WorkflowDependencyPolicy, WorkflowNodeStatus, WorkflowNodeOutcome, WorkflowOutcome, WorkflowTaskSpec, WorkflowSpawnInfo, } from "./runtime/types/agent.js";
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
-export { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
-export { Governance } from "./governance.js";
-export type { GovernanceVerdict } from "./governance.js";
+export { loopInstruction, classifyInstruction, judgeGoal, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
+export { Agent } from "./agent.js";
+export type { AgentMemory, AgentOptions, AgentToolDefinition, AgentRef, Guardrail, Handoff, Knowledge, KnowledgeSourceRef, MCPServer, McpTransport, MemoryReference, ModelRef, ModelRequirement, Skill, } from "./agent.js";
+export { lowerAgent, normalizeAgent } from "./agent-ir.js";
+export type { AgentCapabilityIR, AgentDefinition, AgentLoweringInputs, AgentMemoryIR, AgentSpec, AgentToolIR, } from "./agent-ir.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
-export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
+export { OpenAIProvider, qwen, deepseek, minimax, kimi } from "./providers/openai.js";
+export type { OpenAIProviderOptions, BackendProviderOptions } from "./providers/openai.js";
+export { ProviderError, classifyProviderError } from "./providers/provider-error.js";
+export type { ProviderErrorKind, ProviderErrorOptions } from "./providers/provider-error.js";
+export type { GovernancePolicy, GovernanceConstraint } from "./governance.js";
 export { tool, executeTools } from "./tools/index.js";
 export type { RegisteredTool, ToolExecContext } from "./tools/index.js";
 export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.js";
 export type { ToolEnvelope, ToolEnvelopeOk, ToolEnvelopeFail } from "./tools/errors.js";
 export { WorkingMemory } from "./memory/index.js";
-export { InMemoryDreamStore } from "./memory/in-memory-store.js";
-export type { InMemoryDreamStoreOptions } from "./memory/in-memory-store.js";
+export { DurableMemory } from "./memory/durable.js";
+export { InMemoryMemoryStore } from "./memory/in-memory-store.js";
+export type { InMemoryMemoryStoreOptions } from "./memory/in-memory-store.js";
 export { memoryRetentionScore } from "./memory/retention.js";
 export { rankMemories } from "./memory/ranking.js";
 export type { RankableMemory, RankedMemory, RankOptions } from "./memory/ranking.js";
 export { extractSessionMemories, parseExtractedMemories } from "./memory/extraction.js";
-export type { DreamStore, SessionStore, SessionData, SessionMessage, MemoryRecord, MemoryRecall, MemoryRecallLifecycle, MemoryQuery, MemoryScope, MemoryProvenance, MemoryKind, MemoryAuthor, MemoryTrustLevel, } from "./memory/index.js";
+export type { MemoryStore, Memory, MemorySearchOptions, SessionStore, SessionData, SessionMessage, MemoryRecord, MemoryRecall, MemoryRecallLifecycle, MemoryQuery, MemoryScope, MemoryProvenance, MemoryKind, MemoryAuthor, MemoryTrustLevel, } from "./memory/index.js";
 export type { KnowledgeSource } from "./knowledge/index.js";
 export { AttemptLoop, RuntimeAttemptBody, VerdictFnJudge, LlmEvalJudge, HybridJudge, continueSession, freshWithFeedback, freshWithDigest, } from "./harness/index.js";
 export type { AttemptBody, AttemptBodyContext, AttemptBodyEvent, AttemptBodyTerminal, AttemptJudge, AttemptLoopEvent, AttemptLoopOptions, AttemptOutcome, AttemptOutcomeKind, AttemptProgressEvent, AttemptRequest, CarryPolicy, JudgeContext, JudgeResult, PreparedAttempt, StopPolicy, VerdictFn, } from "./harness/index.js";
 export { ScheduledPrompt } from "./signals/index.js";
 export type { RuntimeSignal, SignalSource } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";
+export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement } from "./providers/request-plan.js";
+export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, ProviderUsage, RecordedPromptMeasurement } from "./providers/request-plan.js";
+export { decodeCanonicalStopReason, normalizeProviderStopReason } from "./providers/stop-reason.js";
+export type { CanonicalStopReason } from "./providers/stop-reason.js";
+export { ContentPolicyError, contentDispositionFor, requireContentDisposition } from "./providers/content-policy.js";
+export type { ContentDisposition, ContentPlacement, InputModality } from "./providers/content-policy.js";
 export type { PermissionDecision } from "./safety/index.js";
 export type { Message, ToolCall, ToolResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, CacheBreakpointStrategy, } from "./types.js";
+export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput } from "./runtime/durable-content.js";
+export type { DurableContent, DurableContentBlock, DurableSource, DurableToolResult } from "./runtime/durable-content.js";

package/dist/index.js

@@ -5,17 +5,24 @@ export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
-export { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
-export { Governance } from "./governance.js";
+export { loopInstruction, classifyInstruction, judgeGoal, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
+export { Agent } from "./agent.js";
+export { lowerAgent, normalizeAgent } from "./agent-ir.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
-export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
+export { OpenAIProvider, qwen, deepseek, minimax, kimi } from "./providers/openai.js";
+export { ProviderError, classifyProviderError } from "./providers/provider-error.js";
 export { tool, executeTools } from "./tools/index.js";
 export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.js";
 export { WorkingMemory } from "./memory/index.js";
-export { InMemoryDreamStore } from "./memory/in-memory-store.js";
+export { DurableMemory } from "./memory/durable.js";
+export { InMemoryMemoryStore } from "./memory/in-memory-store.js";
 export { memoryRetentionScore } from "./memory/retention.js";
 export { rankMemories } from "./memory/ranking.js";
 export { extractSessionMemories, parseExtractedMemories } from "./memory/extraction.js";
 export { AttemptLoop, RuntimeAttemptBody, VerdictFnJudge, LlmEvalJudge, HybridJudge, continueSession, freshWithFeedback, freshWithDigest, } from "./harness/index.js";
 export { ScheduledPrompt } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";
+export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement } from "./providers/request-plan.js";
+export { decodeCanonicalStopReason, normalizeProviderStopReason } from "./providers/stop-reason.js";
+export { ContentPolicyError, contentDispositionFor, requireContentDisposition } from "./providers/content-policy.js";
+export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput } from "./runtime/durable-content.js";

package/dist/memory/durable.d.ts

@@ -0,0 +1,13 @@
+import type { Memory, MemoryRecord, MemoryScope, MemorySearchOptions, MemoryStore } from "./index.js";
+/** Binds host storage to the public durable Memory contract for one agent and namespace. */
+export declare class DurableMemory implements Memory {
+    private readonly store;
+    private readonly agentId;
+    private readonly scope;
+    readonly namespace: string;
+    constructor(store: MemoryStore, agentId: string, scope: MemoryScope);
+    search(query: string, options?: MemorySearchOptions): Promise<MemoryRecord[]>;
+    get(recordId: string): Promise<MemoryRecord | null>;
+    put(record: MemoryRecord): Promise<void>;
+    delete(recordId: string): Promise<void>;
+}