@deepstrike/wasm 0.2.73 → 0.2.74

package/dist/agent.d.ts

@@ -1,8 +1,12 @@
-import type { AgentCapabilityFilter } from "./runtime/types/agent.js";
-import type { Memory, WorkingMemory } from "./memory/index.js";
+import type { AgentCapabilityFilter, WorkflowOutcome, WorkflowSpec } from "./runtime/types/agent.js";
+import type { Memory, WorkingMemory, MemoryRecord, MemoryRecall, MemoryKind } from "./memory/index.js";
 import type { RegisteredTool } from "./tools/index.js";
-import type { LLMProvider, StreamEvent } from "./types.js";
-import { type RuntimeOptions } from "./runtime/runner.js";
+import type { LLMProvider, StreamEvent, ContentPart } from "./types.js";
+import { RuntimeRunner } from "./runtime/runner.js";
+import { type ExecutionPlane } from "./runtime/execution-plane.js";
+import { type SessionEvent, type SessionLog } from "./runtime/session-log.js";
+import type { SignalSource } from "./signals/index.js";
+import type { McpExecutionPlane } from "./runtime/mcp-transport.js";
 type JsonSchema = Record<string, unknown>;
 export interface MemoryReference {
     kind?: "durable";
@@ -31,10 +35,7 @@ export type McpTransport = {
     command: string;
     args?: string[];
 } | {
-    kind: "http";
-    url: string;
-} | {
-    kind: "sse";
+    kind: "http" | "sse";
     url: string;
 } | {
     kind: "custom";
@@ -63,22 +64,7 @@ export interface Skill {
     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";
+    kind: "file" | "directory" | "text" | "url" | "vector" | "custom";
     [key: string]: unknown;
 };
 export interface Knowledge {
@@ -104,6 +90,16 @@ export interface Guardrail {
     description?: string;
     metadata?: Record<string, unknown>;
 }
+export interface AgentRuntimeBinding {
+    provider?: LLMProvider;
+    providerFor?: (model: string) => LLMProvider | undefined;
+    runtimeOptions?: Partial<import("./runtime/runner.js").RuntimeOptions>;
+    sessionLog?: SessionLog;
+    executionPlane?: ExecutionPlane;
+    mcpPlane?: McpExecutionPlane;
+    resolveAgent?: (name: string) => Agent | undefined | Promise<Agent | undefined>;
+    signalSource?: SignalSource;
+}
 export interface AgentOptions {
     name: string;
     description?: string;
@@ -120,16 +116,86 @@ export interface AgentOptions {
     outputSchema?: JsonSchema;
     metadata?: Record<string, unknown>;
     guardrails?: Guardrail[];
-    runtimeBinding?: {
-        provider?: LLMProvider;
-        providerFor?: (model: string) => LLMProvider | undefined;
-        runtimeOptions?: Partial<RuntimeOptions>;
-    };
+    runtimeBinding?: AgentRuntimeBinding;
+}
+export interface AgentRunOptions {
+    sessionId?: string;
+    maxTurns?: number;
+    maxTotalTokens?: number;
+    timeoutMs?: number;
+    metadata?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+    attachments?: ContentPart[];
+    cancelSignal?: AbortSignal;
 }
 export interface AgentRunResult {
     output: string;
+    runId?: string;
     sessionId: string;
     status: "completed" | "partial" | "failed" | "cancelled";
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    outputValidation?: {
+        ok: boolean;
+        errors: string[];
+    };
+    evidence?: {
+        route?: unknown;
+        measurement?: unknown;
+        contextBinding?: unknown;
+    };
+}
+export interface MemoryInput {
+    name: string;
+    content: string;
+    description?: string;
+    kind?: MemoryKind;
+    confidence?: number;
+    pinned?: boolean;
+    ttlDays?: number;
+}
+export interface RecallOptions {
+    topK?: number;
+    kinds?: MemoryKind[];
+    minScore?: number;
+}
+export interface DelegationResult {
+    output: string;
+    status: "completed" | "partial" | "failed";
+}
+export declare class AgentSession {
+    private readonly owner;
+    readonly id: string;
+    private activeRunner?;
+    constructor(owner: Agent, id: string);
+    history(fromSeq?: number): Promise<{
+        seq: number;
+        event: SessionEvent;
+    }[]>;
+    latestSeq(): Promise<number>;
+    workflowTrace(): Promise<{
+        seq: number;
+        event: SessionEvent;
+    }[]>;
+    workflowReplay(): Promise<{
+        events: {
+            seq: number;
+            event: SessionEvent;
+        }[];
+        nodeOutcomes: Record<string, unknown>[];
+        completed: boolean;
+    }>;
+    private runner;
+    stream(goal: string, options?: Omit<AgentRunOptions, "sessionId">): AsyncIterable<StreamEvent>;
+    run(goal: string, options?: Omit<AgentRunOptions, "sessionId">): Promise<AgentRunResult>;
+    resume(options?: Omit<AgentRunOptions, "sessionId">): AsyncIterable<StreamEvent>;
+    interrupt(reason?: "user" | "deadline" | "lease_lost" | "host_shutdown"): void;
+    remember(input: MemoryInput): Promise<MemoryRecord>;
+    recall(query: string, options?: RecallOptions): Promise<MemoryRecall[]>;
+    workflow(spec: WorkflowSpec): Promise<WorkflowOutcome>;
 }
 export declare class Agent {
     readonly name: string;
@@ -147,14 +213,29 @@ export declare class Agent {
     readonly outputSchema?: JsonSchema;
     readonly metadata?: Record<string, unknown>;
     readonly guardrails?: Guardrail[];
-    readonly runtimeBinding?: AgentOptions["runtimeBinding"];
+    readonly runtimeBinding?: AgentRuntimeBinding;
+    readonly sessionLog: SessionLog;
+    private readonly sessions;
     constructor(options: AgentOptions);
-    run(goal: string, options?: {
-        sessionId?: string;
-        maxTurns?: number;
-    }): Promise<AgentRunResult>;
-    stream(goal: string, options?: {
+    session(id?: string): AgentSession;
+    createRunner(_goal: string, _sessionId: string, options?: AgentRunOptions): Promise<RuntimeRunner>;
+    run(goal: string, options?: AgentRunOptions): Promise<AgentRunResult>;
+    stream(goal: string, options?: AgentRunOptions): AsyncIterable<StreamEvent>;
+    resume(sessionId: string, options?: Omit<AgentRunOptions, "sessionId">): AsyncIterable<StreamEvent>;
+    interrupt(reason?: "user" | "deadline" | "lease_lost" | "host_shutdown", sessionId?: string): void;
+    workflow(spec: WorkflowSpec, options?: {
         sessionId?: string;
-    }): AsyncIterable<StreamEvent>;
+    }): Promise<WorkflowOutcome>;
+    remember(input: MemoryInput, sessionId?: string): Promise<MemoryRecord>;
+    recall(query: string, options?: RecallOptions, _sessionId?: string): Promise<MemoryRecall[]>;
+    delegate(request: {
+        target: AgentRef;
+        goal: string;
+        metadata?: Record<string, unknown>;
+        providerOptions?: Record<string, unknown>;
+    }): Promise<DelegationResult>;
+    listen(): Promise<AgentRunResult | null>;
+    close(): Promise<void>;
+    result(sessionId: string, events: StreamEvent[]): Promise<AgentRunResult>;
 }
 export {};

package/dist/agent.js

@@ -1,6 +1,98 @@
 import { RuntimeRunner } from "./runtime/runner.js";
 import { LocalExecutionPlane } from "./runtime/execution-plane.js";
 import { InMemorySessionLog } from "./runtime/session-log.js";
+import { extractJsonValue, validateAgainstSchema } from "./runtime/output-schema.js";
+function statusOf(reason) {
+    if (["completed", "success", "done"].includes(reason))
+        return "completed";
+    if (["cancelled", "user", "user_abort", "deadline", "timeout"].includes(reason))
+        return "cancelled";
+    if (["failed", "error", "invalid_arg"].includes(reason))
+        return "failed";
+    return "partial";
+}
+export class AgentSession {
+    owner;
+    id;
+    activeRunner;
+    constructor(owner, id) {
+        this.owner = owner;
+        this.id = id;
+    }
+    history(fromSeq = 0) { return this.owner.sessionLog.read(this.id, fromSeq); }
+    latestSeq() { return this.owner.sessionLog.latestSeq(this.id); }
+    async workflowTrace() {
+        const kinds = new Set(["workflow_batch_spawned", "workflow_node_completed", "workflow_nodes_submitted", "workflow_completed"]);
+        return (await this.history()).filter(entry => kinds.has(entry.event.kind));
+    }
+    async workflowReplay() {
+        const events = await this.workflowTrace();
+        const outcomes = new Map();
+        let completed = false;
+        for (const entry of events) {
+            if (entry.event.kind === "workflow_node_completed") {
+                const id = entry.event.agent_id;
+                if (id)
+                    outcomes.set(id, entry.event);
+            }
+            if (entry.event.kind === "workflow_completed") {
+                completed = true;
+                for (const outcome of entry.event.node_outcomes) {
+                    const id = outcome.node_id;
+                    if (id)
+                        outcomes.set(id, outcome);
+                }
+            }
+        }
+        return { events, nodeOutcomes: [...outcomes.values()], completed };
+    }
+    runner(goal, options = {}) { return this.owner.createRunner(goal, this.id, options); }
+    async *stream(goal, options = {}) {
+        const runner = await this.runner(goal, { ...options, sessionId: this.id });
+        this.activeRunner = runner;
+        const abort = () => runner.interrupt("user");
+        if (options.cancelSignal?.aborted)
+            abort();
+        else
+            options.cancelSignal?.addEventListener("abort", abort, { once: true });
+        try {
+            yield* runner.run({ sessionId: this.id, goal, attachments: options.attachments, extensions: options.providerOptions });
+        }
+        finally {
+            options.cancelSignal?.removeEventListener("abort", abort);
+            this.activeRunner = undefined;
+        }
+    }
+    async run(goal, options = {}) {
+        const events = [];
+        for await (const event of this.stream(goal, options))
+            events.push(event);
+        return this.owner.result(this.id, events);
+    }
+    async *resume(options = {}) {
+        const runner = await this.runner("resume", { ...options, sessionId: this.id });
+        this.activeRunner = runner;
+        try {
+            yield* runner.wake(this.id, options.providerOptions);
+        }
+        finally {
+            this.activeRunner = undefined;
+        }
+    }
+    interrupt(reason = "user") { this.activeRunner?.interrupt(reason); }
+    remember(input) { return this.owner.remember(input, this.id); }
+    recall(query, options = {}) { return this.owner.recall(query, options, this.id); }
+    async workflow(spec) {
+        const runner = await this.runner("workflow", { sessionId: this.id });
+        this.activeRunner = runner;
+        try {
+            return await runner.runWorkflow(spec, { sessionId: this.id });
+        }
+        finally {
+            this.activeRunner = undefined;
+        }
+    }
+}
 export class Agent {
     name;
     description;
@@ -18,6 +110,8 @@ export class Agent {
     metadata;
     guardrails;
     runtimeBinding;
+    sessionLog;
+    sessions = new Map();
     constructor(options) {
         this.name = options.name;
         this.description = options.description;
@@ -35,44 +129,116 @@ export class Agent {
         this.metadata = options.metadata;
         this.guardrails = options.guardrails;
         this.runtimeBinding = options.runtimeBinding;
+        this.sessionLog = options.runtimeBinding?.sessionLog ?? options.runtimeBinding?.runtimeOptions?.sessionLog ?? new InMemorySessionLog();
     }
-    async run(goal, options = {}) {
+    session(id = `session-${crypto.randomUUID()}`) { if (!this.sessions.has(id))
+        this.sessions.set(id, new AgentSession(this, id)); return this.sessions.get(id); }
+    async createRunner(_goal, _sessionId, options = {}) {
         const binding = this.runtimeBinding;
         const provider = binding?.provider ?? (typeof this.model === "string" ? binding?.providerFor?.(this.model) : undefined);
         if (!provider)
             throw new Error(`agent "${this.name}" has no runtime provider binding`);
-        const runtime = new RuntimeRunner({
-            provider,
-            executionPlane: new LocalExecutionPlane(),
-            sessionLog: new InMemorySessionLog(),
-            maxTokens: 32_000,
-            agentId: this.name,
-            ...(this.instructions ? { systemPrompt: this.instructions } : {}),
-            ...(options.maxTurns !== undefined ? { maxTurns: options.maxTurns } : {}),
-            ...(binding?.runtimeOptions ?? {}),
-        });
-        const sessionId = options.sessionId ?? `session-${crypto.randomUUID()}`;
-        const events = [];
-        for await (const event of runtime.run({ sessionId, goal }))
-            events.push(event);
-        const output = events.filter(event => event.type === "text_delta").map(event => ("delta" in event ? String(event.delta) : "")).join("");
-        const failed = events.some(event => event.type === "error");
-        return { output, sessionId, status: failed ? "failed" : "completed" };
+        const base = { ...(binding?.runtimeOptions ?? {}) };
+        if (options.maxTurns !== undefined)
+            base.maxTurns = options.maxTurns;
+        if (options.maxTotalTokens !== undefined)
+            base.maxTotalTokens = options.maxTotalTokens;
+        if (options.timeoutMs !== undefined)
+            base.timeoutMs = options.timeoutMs;
+        if (options.providerOptions)
+            base.extensions = { ...(base.extensions ?? {}), ...options.providerOptions };
+        const mcpPlane = binding?.mcpPlane;
+        if (mcpPlane)
+            await mcpPlane.connect();
+        return new RuntimeRunner({ provider, executionPlane: binding?.executionPlane ?? mcpPlane ?? new LocalExecutionPlane(), sessionLog: this.sessionLog, maxTokens: 32_000, agentId: this.name, ...(this.instructions ? { systemPrompt: this.instructions } : {}), ...base });
     }
-    stream(goal, options = {}) {
-        const binding = this.runtimeBinding;
-        const provider = binding?.provider ?? (typeof this.model === "string" ? binding?.providerFor?.(this.model) : undefined);
-        if (!provider)
-            throw new Error(`agent "${this.name}" has no runtime provider binding`);
-        const runtime = new RuntimeRunner({
-            provider,
-            executionPlane: new LocalExecutionPlane(),
-            sessionLog: new InMemorySessionLog(),
-            maxTokens: 32_000,
-            agentId: this.name,
-            ...(this.instructions ? { systemPrompt: this.instructions } : {}),
-            ...(binding?.runtimeOptions ?? {}),
-        });
-        return runtime.run({ sessionId: options.sessionId ?? `session-${crypto.randomUUID()}`, goal });
+    async run(goal, options = {}) { return this.session(options.sessionId).run(goal, options); }
+    stream(goal, options = {}) { return this.session(options.sessionId).stream(goal, options); }
+    resume(sessionId, options = {}) { return this.session(sessionId).resume(options); }
+    interrupt(reason = "user", sessionId) { sessionId ? this.session(sessionId).interrupt(reason) : [...this.sessions.values()].forEach(s => s.interrupt(reason)); }
+    workflow(spec, options = {}) { return this.session(options.sessionId).workflow(spec); }
+    async remember(input, sessionId) {
+        if (!this.memory || typeof this.memory.put !== "function")
+            throw new Error(`agent "${this.name}" memory is not runtime-bound`);
+        const now = Date.now();
+        const record = {
+            record_id: crypto.randomUUID(), scope: this.memory.scope
+                ?? { tenant_id: "default", namespace: this.memory.namespace ?? this.name },
+            name: input.name, kind: input.kind ?? "reference", content: input.content,
+            description: input.description ?? input.name,
+            provenance: { author: "host", trust: "user_asserted", evidence_refs: [], session_id: sessionId ?? `memory-${crypto.randomUUID()}` },
+            created_at: now, updated_at: now, recall_count: 0, confidence: input.confidence ?? 1,
+            links: [], pinned: input.pinned ?? false, ...(input.ttlDays === undefined ? {} : { ttl_days: input.ttlDays }),
+        };
+        await this.memory.put(record);
+        return record;
+    }
+    async recall(query, options = {}, _sessionId) {
+        if (!this.memory || typeof this.memory.search !== "function")
+            throw new Error(`agent "${this.name}" memory is not runtime-bound`);
+        const records = await this.memory.search(query, { topK: options.topK ?? 8, kinds: options.kinds, minScore: options.minScore });
+        return records.map(record => ({ record, score: 1, why: "memory facade search" }));
+    }
+    async delegate(request) {
+        const targetName = typeof request.target === "string" ? request.target : request.target.name;
+        const declared = (this.handoffs ?? []).some(h => (typeof h.agent === "string" ? h.agent : h.agent.name) === targetName);
+        if (!declared)
+            throw new Error(`agent "${this.name}" cannot hand off to "${targetName}"`);
+        const resolver = this.runtimeBinding?.resolveAgent;
+        if (!resolver)
+            throw new Error(`agent "${this.name}" requires a host target resolver`);
+        const target = await resolver(targetName);
+        if (!target)
+            throw new Error(`target agent "${targetName}" is not registered`);
+        const result = await target.run(request.goal, { metadata: request.metadata, providerOptions: request.providerOptions });
+        return { output: result.output, status: result.status === "cancelled" ? "partial" : result.status };
+    }
+    async listen() {
+        const source = this.runtimeBinding?.signalSource;
+        if (!source)
+            throw new Error("agent signals require runtimeBinding.signalSource");
+        const claim = await source.claimSignal();
+        if (!claim)
+            return null;
+        const goal = String(claim.signal.payload.goal ?? claim.signal.payload.summary ?? JSON.stringify(claim.signal.payload));
+        try {
+            const result = await this.run(goal);
+            await source.ackSignal(claim);
+            return result;
+        }
+        catch (error) {
+            await source.nackSignal(claim);
+            throw error;
+        }
+    }
+    async close() { await this.runtimeBinding?.mcpPlane?.disconnect(); }
+    async result(sessionId, events) {
+        const entries = await this.sessionLog.read(sessionId);
+        const started = [...entries].reverse().find(e => e.event.kind === "run_started")?.event;
+        const terminal = [...entries].reverse().find(e => e.event.kind === "run_terminal")?.event;
+        const output = events.filter((e) => e.type === "text_delta" && "delta" in e).map(e => String(e.delta)).join("");
+        const usage = [...events].reverse().find((e) => e.type === "usage");
+        const result = { output, runId: started?.kind === "run_started" ? started.run_id : undefined, sessionId, status: statusOf(terminal?.kind === "run_terminal" ? terminal.reason : events.some(e => e.type === "error") ? "error" : "completed") };
+        const attempt = [...entries].reverse().find(e => e.event.kind === "provider_attempt")?.event;
+        if (usage)
+            result.usage = { inputTokens: usage.inputTokens ?? 0, outputTokens: usage.outputTokens ?? 0, totalTokens: usage.totalTokens };
+        else if (attempt?.kind === "provider_attempt" && attempt.usage) {
+            result.usage = { inputTokens: attempt.usage.inputTokens, outputTokens: attempt.usage.outputTokens, totalTokens: attempt.usage.inputTokens + attempt.usage.outputTokens };
+        }
+        const measured = [...entries].reverse().find(e => e.event.kind === "prompt_measured")?.event;
+        const prepared = [...entries].reverse().find(e => e.event.kind === "context_prepared")?.event;
+        if ((started?.kind === "run_started" && started.route) || (attempt?.kind === "provider_attempt" && attempt.route) || measured || prepared) {
+            result.evidence = {
+                ...((attempt?.kind === "provider_attempt" ? attempt.route : started?.kind === "run_started" ? started.route : undefined) ? { route: attempt?.kind === "provider_attempt" ? attempt.route : started.route } : {}),
+                ...(measured?.kind === "prompt_measured" ? { measurement: measured.measurement } : {}),
+                ...(prepared?.kind === "context_prepared" ? { contextBinding: prepared.preparation.binding } : {}),
+            };
+        }
+        if (this.outputSchema) {
+            result.outputValidation = validateAgainstSchema(extractJsonValue(output), this.outputSchema);
+            if (!result.outputValidation.ok && result.status === "completed")
+                result.status = "failed";
+        }
+        return result;
     }
 }

package/dist/index.d.ts

@@ -14,9 +14,9 @@ export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
 export { loopInstruction, classifyInstruction, judgeGoal, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
 export { Agent } from "./agent.js";
-export type { AgentMemory, AgentOptions, AgentRunResult, 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 { McpExecutionPlane } from "./runtime/mcp-transport.js";
+export type { McpConnection, McpConnectionFactory, McpCredentialVault, McpServerConfig } from "./runtime/mcp-transport.js";
+export type { AgentMemory, AgentOptions, AgentRunResult, AgentRunOptions, AgentToolDefinition, AgentRef, Guardrail, Handoff, Knowledge, KnowledgeSourceRef, MCPServer, McpTransport, MemoryReference, ModelRef, ModelRequirement, Skill, MemoryInput, RecallOptions, DelegationResult, AgentRuntimeBinding, AgentSession, } from "./agent.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
 export { OpenAIProvider, qwen, deepseek, minimax, kimi } from "./providers/openai.js";
 export type { OpenAIProviderOptions, BackendProviderOptions } from "./providers/openai.js";

package/dist/index.js

@@ -10,7 +10,7 @@ export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } fr
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.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 { McpExecutionPlane } from "./runtime/mcp-transport.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
 export { OpenAIProvider, qwen, deepseek, minimax, kimi } from "./providers/openai.js";
 export { ProviderError, classifyProviderError } from "./providers/provider-error.js";

package/dist/memory/durable.d.ts

@@ -3,8 +3,8 @@ import type { Memory, MemoryRecord, MemoryScope, MemorySearchOptions, MemoryStor
 export declare class DurableMemory implements Memory {
     private readonly store;
     private readonly agentId;
-    private readonly scope;
     readonly namespace: string;
+    readonly scope: MemoryScope;
     constructor(store: MemoryStore, agentId: string, scope: MemoryScope);
     search(query: string, options?: MemorySearchOptions): Promise<MemoryRecord[]>;
     get(recordId: string): Promise<MemoryRecord | null>;

package/dist/memory/durable.js

@@ -2,13 +2,13 @@
 export class DurableMemory {
     store;
     agentId;
-    scope;
     namespace;
+    scope;
     constructor(store, agentId, scope) {
         this.store = store;
         this.agentId = agentId;
-        this.scope = scope;
         this.namespace = scope.namespace;
+        this.scope = scope;
     }
     async search(query, options = {}) {
         const request = {

package/dist/runtime/index.d.ts

@@ -14,6 +14,8 @@ export { CanonicalKernelHost, CanonicalKernelRejectedError, CanonicalKernelRebui
 export type { CanonicalKernelInput, CanonicalPlannedStep, CanonicalRunnerRuntimeOptions, CanonicalTransition, CanonicalTransitionOptions, } from "./canonical-kernel-step.js";
 export { runAgent, runFanout } from "./facade.js";
 export type { RunAgentOptions, RunFanoutOptions } from "./facade.js";
+export { McpExecutionPlane } from "./mcp-transport.js";
+export type { McpConnection, McpConnectionFactory, McpCredentialVault, McpServerConfig } from "./mcp-transport.js";
 export { builtinReducers, resolveReducer } from "./reducers.js";
 export type { Reducer, ReducerRegistry, ReducerInput } from "./reducers.js";
 export { getKernel } from "./kernel.js";

package/dist/runtime/index.js

@@ -9,6 +9,7 @@ export { RuntimeRunner, collectText } from "./runner.js";
 export { MemoryPayloadDriver, PayloadStore } from "./payload-store.js";
 export { CanonicalKernelHost, CanonicalKernelRejectedError, CanonicalKernelRebuildRequiredError, CanonicalRunnerRuntime, sha256, } from "./canonical-kernel-step.js";
 export { runAgent, runFanout } from "./facade.js";
+export { McpExecutionPlane } from "./mcp-transport.js";
 export { builtinReducers, resolveReducer } from "./reducers.js";
 export { getKernel } from "./kernel.js";
 export { ReplayProvider } from "./replay-provider.js";

package/dist/runtime/mcp-transport.d.ts

@@ -0,0 +1,43 @@
+import type { ToolCall, ToolSchema, StreamEvent } from "../types.js";
+import { type ExecutionPlane, type RunContext } from "./execution-plane.js";
+import type { RegisteredTool } from "../tools/index.js";
+/** Browser-safe MCP connection boundary. Implement HTTP/SSE/custom transports in the host. */
+export interface McpConnection {
+    start(): Promise<void>;
+    schemas(): ToolSchema[];
+    execute(call: ToolCall, context?: RunContext): Promise<{
+        content: string;
+        isError: boolean;
+        contentParts?: unknown[];
+    }>;
+    stop(): Promise<void>;
+}
+export interface McpCredentialVault {
+    get(key: string): Promise<string | undefined>;
+}
+export interface McpServerConfig {
+    name: string;
+    transport: {
+        kind: "http" | "sse" | "custom";
+        [key: string]: unknown;
+    };
+    credentialVault?: McpCredentialVault;
+}
+export type McpConnectionFactory = (config: McpServerConfig) => McpConnection | Promise<McpConnection>;
+/** ExecutionPlane adapter that keeps MCP wire details outside the Kernel. */
+export declare class McpExecutionPlane implements ExecutionPlane {
+    private readonly configs;
+    private readonly factory;
+    private readonly connections;
+    private readonly toolMap;
+    private connected;
+    private readonly local;
+    private readonly localNames;
+    constructor(configs: McpServerConfig[], factory: McpConnectionFactory);
+    connect(): Promise<void>;
+    register(...tools: RegisteredTool[]): this;
+    unregister(name: string): this;
+    schemas(): ToolSchema[];
+    executeAll(calls: ToolCall[], context: RunContext): AsyncIterable<StreamEvent>;
+    disconnect(): Promise<void>;
+}

package/dist/runtime/mcp-transport.js

@@ -0,0 +1,58 @@
+import { LocalExecutionPlane } from "./execution-plane.js";
+/** ExecutionPlane adapter that keeps MCP wire details outside the Kernel. */
+export class McpExecutionPlane {
+    configs;
+    factory;
+    connections = [];
+    toolMap = new Map();
+    connected = false;
+    local = new LocalExecutionPlane();
+    localNames = new Set();
+    constructor(configs, factory) {
+        this.configs = configs;
+        this.factory = factory;
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        for (const config of this.configs) {
+            const connection = await this.factory(config);
+            await connection.start();
+            this.connections.push(connection);
+            for (const schema of connection.schemas())
+                this.toolMap.set(schema.name, connection);
+        }
+        this.connected = true;
+    }
+    register(...tools) { this.local.register(...tools); for (const tool of tools)
+        this.localNames.add(tool.schema.name); return this; }
+    unregister(name) { this.local.unregister(name); this.localNames.delete(name); this.toolMap.delete(name); return this; }
+    schemas() { return [...this.local.schemas(), ...this.connections.flatMap(connection => connection.schemas())]; }
+    async *executeAll(calls, context) {
+        const localCalls = calls.filter(call => this.localNames.has(call.name));
+        if (localCalls.length)
+            yield* this.local.executeAll(localCalls, context);
+        for (const call of calls) {
+            if (this.localNames.has(call.name))
+                continue;
+            const connection = this.toolMap.get(call.name);
+            if (!connection) {
+                yield { type: "tool_result", callId: call.id, name: call.name, content: `unknown MCP tool: ${call.name}`, isError: true };
+                continue;
+            }
+            try {
+                const result = await connection.execute(call, context);
+                yield { type: "tool_result", callId: call.id, name: call.name, content: result.content, isError: result.isError, contentParts: result.contentParts };
+            }
+            catch (error) {
+                yield { type: "tool_result", callId: call.id, name: call.name, content: String(error), isError: true };
+            }
+        }
+    }
+    async disconnect() {
+        await Promise.all(this.connections.map(connection => connection.stop()));
+        this.connections.length = 0;
+        this.toolMap.clear();
+        this.connected = false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.73",
+  "version": "0.2.74",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
@@ -12,12 +12,12 @@
   ],
   "scripts": {
     "build:wasm": "wasm-pack build ../crates/deepstrike-wasm --target bundler --out-dir ../../wasm/pkg",
-    "build": "tsc",
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "test": "node --experimental-vm-modules node_modules/.bin/jest",
     "test:canonical-binding": "wasm-pack build ../crates/deepstrike-wasm --target nodejs --dev --out-dir ../../wasm/pkg-node && node tests/canonical-binding.node.cjs && node tests/golden-fixtures-sweep.node.cjs"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.2.73"
+    "@deepstrike/wasm-kernel": "0.2.74"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",

package/dist/agent-ir.d.ts

@@ -1,81 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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 },
-        },
-    };
-}