stitchkit 0.56.1 → 0.56.2

package/README.md

@@ -85,11 +85,13 @@ Server code imports server entrypoints:
 import { createServer, createHandler, implement } from 'stitchkit/server'
 import { createSocketIOServer, createAuthHook } from 'stitchkit/server'
 import { createMcpHandler, mountAgent } from 'stitchkit/tools'
+import { createAgentRuntime, defineAgentProtocol } from 'stitchkit/agent-runtime'
 import { implementRemote } from 'stitchkit/remote'
 ```
 
-The root `stitchkit` entrypoint is browser-safe. Server, tool and peer-free
-remote-proxy code live behind `stitchkit/server`, `stitchkit/tools` and
+The root `stitchkit` entrypoint is browser-safe. Server, tool, optional
+AI-SDK-backed agent-runtime and peer-free remote-proxy code live behind
+`stitchkit/server`, `stitchkit/tools`, `stitchkit/agent-runtime` and
 `stitchkit/remote` respectively.
 
 ## Quick Start
@@ -213,6 +215,11 @@ const result = await generateText({ model, tools, prompt: 'Create a user named M
 
 ### 7. WebSocket (Socket.IO)
 
+For applications that want Stitchkit to own durable message/run transitions,
+stream checkpoints, interruption and managed-tool fencing, use the optional
+[`stitchkit/agent-runtime`](docs/guide/agent-runtime.md). `mountAgent` remains
+the smaller application-owned-loop path.
+
 stitchkit's WebSocket layer is Socket.IO — `polling` fallback, heartbeat, acks,
 a mature client. The wrappers cover the boilerplate.
 
@@ -282,6 +289,7 @@ import { parseSSE } from 'stitchkit'           // client: Response → AsyncGene
 | **HTTP Server** | `createServer()` / `createHandler()` — Bun.serve, validation, hooks, raw routes |
 | **MCP Tools** | `createMcpHandler()` / `mountMcp()` — MCP tools from contracts |
 | **Agent Tools** | `mountAgent()` — Vercel AI SDK tools from contracts |
+| **Agent Runtime** | `createAgentRuntime()` — optional durable history, stream loop, coordination and fencing |
 | **Typed Client** | `createClient()` / `createClients()` — typed fetch from contracts |
 | **Cursor Pagination** | `createCursorQuery()` — `react-query-kit` infinite query from a contract method |
 | **WebSocket** | `createSocketIOClient()` / `createSocketIOServer()` — typed Socket.IO wrappers |
@@ -367,7 +375,8 @@ peer — an install pulls in only what the project actually uses.
 | `@modelcontextprotocol/server` | peer, optional | MCP server surfaces in `stitchkit/tools`; SDK v2, protocol `2026-07-28`. |
 | `@modelcontextprotocol/client` | development dependency, optional | Only consumers that run MCP client integration tests or build an MCP host. |
 | `@modelcontextprotocol/ext-apps` | peer, optional | Only MCP Apps (`ui://` resources and UI metadata). |
-| `ai` | peer, optional | Only `stitchkit/tools` — agent tools (Vercel AI SDK). |
+| `ai` | peer, optional | `stitchkit/tools` agent tools and the optional server-only `stitchkit/agent-runtime`. |
+| `@openrouter/ai-sdk-provider` | peer, optional | Only `stitchkit/agent-runtime/openrouter`; neutral runtime imports do not resolve it. |
 | `@tanstack/react-query` + `react-query-kit` | peer, optional | Only `stitchkit/react` — `createCursorQuery`, `createCacheBridge`. |
 | `socket.io` / `@socket.io/bun-engine` / `socket.io-client` | peer, optional | Only the Socket.IO wrappers. |
 

package/dist/agent-runtime/compaction.d.ts

@@ -0,0 +1,33 @@
+import type { ZodType, z } from 'zod';
+import type { AgentMessage, AgentSnapshot } from './schemas';
+import type { AgentRuntimeStore } from './store';
+export interface AgentCompactionContext<SUMMARY> {
+    conversationId: string;
+    snapshot: AgentSnapshot;
+    eligibleMessages: readonly AgentMessage[];
+    previousSummary?: SUMMARY;
+    signal: AbortSignal;
+}
+export interface StructuredCompactionConfig<SUMMARY_SCHEMA extends ZodType> {
+    schema: SUMMARY_SCHEMA;
+    keepRecentTurns: number;
+    threshold(input: AgentSnapshot): boolean | Promise<boolean>;
+    summarize(context: AgentCompactionContext<z.infer<SUMMARY_SCHEMA>>): z.infer<SUMMARY_SCHEMA> | Promise<z.infer<SUMMARY_SCHEMA>>;
+    createSummaryMessage(input: {
+        conversationId: string;
+        summary: z.infer<SUMMARY_SCHEMA>;
+        compactedMessages: readonly AgentMessage[];
+    }): AgentMessage;
+    readPreviousSummary?(message: AgentMessage): z.infer<SUMMARY_SCHEMA>;
+}
+export interface AgentCompactionResult {
+    outcome: 'not_needed' | 'nothing_eligible' | 'applied' | 'conflict' | 'not_found';
+    snapshot: AgentSnapshot;
+}
+export declare function structuredCompaction<SUMMARY_SCHEMA extends ZodType>(config: StructuredCompactionConfig<SUMMARY_SCHEMA>): (input: {
+    conversationId: string;
+    store: AgentRuntimeStore;
+    signal: AbortSignal;
+    previousSummary?: z.infer<SUMMARY_SCHEMA>;
+}) => Promise<AgentCompactionResult>;
+//# sourceMappingURL=compaction.d.ts.map

package/dist/agent-runtime/compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/compaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAA4B,MAAM,SAAS,CAAC;AAE3E,MAAM,WAAW,sBAAsB,CAAC,OAAO;IAC7C,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,aAAa,CAAC;IACxB,gBAAgB,EAAE,SAAS,YAAY,EAAE,CAAC;IAC1C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,0BAA0B,CAAC,cAAc,SAAS,OAAO;IACxE,MAAM,EAAE,cAAc,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5D,SAAS,CACP,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,GACvD,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;IAC9D,oBAAoB,CAAC,KAAK,EAAE;QAC1B,cAAc,EAAE,MAAM,CAAC;QACvB,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QACjC,iBAAiB,EAAE,SAAS,YAAY,EAAE,CAAC;KAC5C,GAAG,YAAY,CAAC;IACjB,mBAAmB,CAAC,CAAC,OAAO,EAAE,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;CACtE;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,YAAY,GAAG,kBAAkB,GAAG,SAAS,GAAG,UAAU,GAAG,WAAW,CAAC;IAClF,QAAQ,EAAE,aAAa,CAAC;CACzB;AAqED,wBAAgB,oBAAoB,CAAC,cAAc,SAAS,OAAO,EACjE,MAAM,EAAE,0BAA0B,CAAC,cAAc,CAAC,WAM7B;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,iBAAiB,CAAC;IACzB,MAAM,EAAE,WAAW,CAAC;IACpB,eAAe,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;CAC3C,KAAG,OAAO,CAAC,qBAAqB,CAAC,CA4CnC"}

package/dist/agent-runtime/coordinator.d.ts

@@ -0,0 +1,24 @@
+export type AgentInputPolicy = 'queue' | 'interrupt';
+export type AgentStopReason = 'user-interrupt' | 'timeout' | 'shutdown';
+export interface AgentCoordinatedRun<RESULT> {
+    runId: string;
+    execute(): Promise<RESULT>;
+}
+export interface AgentRunTicket<RESULT> {
+    accepted: Promise<void>;
+    result: Promise<RESULT>;
+}
+export interface AgentSessionCoordinator {
+    submit<RESULT>(input: {
+        key: string;
+        policy: AgentInputPolicy;
+        create(signal: AbortSignal): AgentCoordinatedRun<RESULT> | Promise<AgentCoordinatedRun<RESULT>>;
+    }): AgentRunTicket<RESULT>;
+    stop(key: string, reason?: AgentStopReason): boolean;
+    close(options?: {
+        drainTimeoutMs?: number;
+    }): Promise<void>;
+    isRunning(key: string): boolean;
+}
+export declare function createAgentSessionCoordinator(): AgentSessionCoordinator;
+//# sourceMappingURL=coordinator.d.ts.map

package/dist/agent-runtime/coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinator.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coordinator.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,WAAW,CAAC;AACrD,MAAM,MAAM,eAAe,GAAG,gBAAgB,GAAG,SAAS,GAAG,UAAU,CAAC;AAExE,MAAM,WAAW,mBAAmB,CAAC,MAAM;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc,CAAC,MAAM;IACpC,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE;QACpB,GAAG,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,gBAAgB,CAAC;QACzB,MAAM,CACJ,MAAM,EAAE,WAAW,GAClB,mBAAmB,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC;KACvE,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;IAC3B,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC;IACrD,KAAK,CAAC,OAAO,CAAC,EAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC;AAiBD,wBAAgB,6BAA6B,IAAI,uBAAuB,CAmGvE"}

package/dist/agent-runtime/events.d.ts

@@ -0,0 +1,454 @@
+import { z } from 'zod';
+export declare const AgentTransientDeltaEventSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    runId: z.ZodString;
+    emittedAt: z.ZodISODateTime;
+    type: z.ZodLiteral<"assistant-delta">;
+    runtimeEpoch: z.ZodString;
+    sequence: z.ZodInt;
+    textDelta: z.ZodString;
+}, z.core.$strip>;
+export declare const AgentCheckpointEventSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    runId: z.ZodString;
+    emittedAt: z.ZodISODateTime;
+    type: z.ZodLiteral<"assistant-checkpoint">;
+    eventId: z.ZodString;
+    snapshotVersion: z.ZodInt;
+    message: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            summary: "summary";
+            system: "system";
+            user: "user";
+        }>;
+        status: z.ZodEnum<{
+            committed: "committed";
+            completed: "completed";
+            failed: "failed";
+            interrupted: "interrupted";
+            streaming: "streaming";
+        }>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            text: z.ZodString;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            mediaType: z.ZodString;
+            reference: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"source">;
+            sourceId: z.ZodString;
+            url: z.ZodOptional<z.ZodURL>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-call">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-result">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            outcome: z.ZodEnum<{
+                error: "error";
+                interrupted: "interrupted";
+                success: "success";
+            }>;
+            output: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"provider">;
+            envelope: z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"control">;
+            reason: z.ZodEnum<{
+                "run-interrupted": "run-interrupted";
+                "stale-run": "stale-run";
+            }>;
+        }, z.core.$strip>], "type">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const AgentRunStateEventSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    runId: z.ZodString;
+    emittedAt: z.ZodISODateTime;
+    type: z.ZodLiteral<"run-state">;
+    eventId: z.ZodString;
+    snapshotVersion: z.ZodInt;
+    state: z.ZodEnum<{
+        abandoned: "abandoned";
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        interrupt_requested: "interrupt_requested";
+        interrupted: "interrupted";
+        queued: "queued";
+        running: "running";
+    }>;
+}, z.core.$strip>;
+export declare const AgentToolStatusEventSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    runId: z.ZodString;
+    emittedAt: z.ZodISODateTime;
+    type: z.ZodLiteral<"tool-status">;
+    runtimeEpoch: z.ZodString;
+    sequence: z.ZodInt;
+    callId: z.ZodString;
+    toolName: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        interrupted: "interrupted";
+        started: "started";
+    }>;
+    input: z.ZodOptional<z.ZodJSONSchema>;
+    output: z.ZodOptional<z.ZodJSONSchema>;
+}, z.core.$strip>;
+export declare const AgentTerminalEventSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    runId: z.ZodString;
+    emittedAt: z.ZodISODateTime;
+    type: z.ZodLiteral<"terminal">;
+    eventId: z.ZodString;
+    snapshotVersion: z.ZodInt;
+    reason: z.ZodEnum<{
+        abandoned: "abandoned";
+        cancelled: "cancelled";
+        interrupted: "interrupted";
+        policy_stop: "policy_stop";
+        provider_failure: "provider_failure";
+        shutdown: "shutdown";
+        success: "success";
+        timeout: "timeout";
+        tool_failure: "tool_failure";
+    }>;
+    policyName: z.ZodOptional<z.ZodString>;
+    message: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            summary: "summary";
+            system: "system";
+            user: "user";
+        }>;
+        status: z.ZodEnum<{
+            committed: "committed";
+            completed: "completed";
+            failed: "failed";
+            interrupted: "interrupted";
+            streaming: "streaming";
+        }>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            text: z.ZodString;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            mediaType: z.ZodString;
+            reference: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"source">;
+            sourceId: z.ZodString;
+            url: z.ZodOptional<z.ZodURL>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-call">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-result">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            outcome: z.ZodEnum<{
+                error: "error";
+                interrupted: "interrupted";
+                success: "success";
+            }>;
+            output: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"provider">;
+            envelope: z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"control">;
+            reason: z.ZodEnum<{
+                "run-interrupted": "run-interrupted";
+                "stale-run": "stale-run";
+            }>;
+        }, z.core.$strip>], "type">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const AgentRuntimeEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    conversationId: z.ZodString;
+    runId: z.ZodString;
+    emittedAt: z.ZodISODateTime;
+    type: z.ZodLiteral<"assistant-delta">;
+    runtimeEpoch: z.ZodString;
+    sequence: z.ZodInt;
+    textDelta: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    conversationId: z.ZodString;
+    runId: z.ZodString;
+    emittedAt: z.ZodISODateTime;
+    type: z.ZodLiteral<"assistant-checkpoint">;
+    eventId: z.ZodString;
+    snapshotVersion: z.ZodInt;
+    message: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            summary: "summary";
+            system: "system";
+            user: "user";
+        }>;
+        status: z.ZodEnum<{
+            committed: "committed";
+            completed: "completed";
+            failed: "failed";
+            interrupted: "interrupted";
+            streaming: "streaming";
+        }>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            text: z.ZodString;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            mediaType: z.ZodString;
+            reference: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"source">;
+            sourceId: z.ZodString;
+            url: z.ZodOptional<z.ZodURL>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-call">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-result">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            outcome: z.ZodEnum<{
+                error: "error";
+                interrupted: "interrupted";
+                success: "success";
+            }>;
+            output: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"provider">;
+            envelope: z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"control">;
+            reason: z.ZodEnum<{
+                "run-interrupted": "run-interrupted";
+                "stale-run": "stale-run";
+            }>;
+        }, z.core.$strip>], "type">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    conversationId: z.ZodString;
+    runId: z.ZodString;
+    emittedAt: z.ZodISODateTime;
+    type: z.ZodLiteral<"run-state">;
+    eventId: z.ZodString;
+    snapshotVersion: z.ZodInt;
+    state: z.ZodEnum<{
+        abandoned: "abandoned";
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        interrupt_requested: "interrupt_requested";
+        interrupted: "interrupted";
+        queued: "queued";
+        running: "running";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    conversationId: z.ZodString;
+    runId: z.ZodString;
+    emittedAt: z.ZodISODateTime;
+    type: z.ZodLiteral<"tool-status">;
+    runtimeEpoch: z.ZodString;
+    sequence: z.ZodInt;
+    callId: z.ZodString;
+    toolName: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        interrupted: "interrupted";
+        started: "started";
+    }>;
+    input: z.ZodOptional<z.ZodJSONSchema>;
+    output: z.ZodOptional<z.ZodJSONSchema>;
+}, z.core.$strip>, z.ZodObject<{
+    conversationId: z.ZodString;
+    runId: z.ZodString;
+    emittedAt: z.ZodISODateTime;
+    type: z.ZodLiteral<"terminal">;
+    eventId: z.ZodString;
+    snapshotVersion: z.ZodInt;
+    reason: z.ZodEnum<{
+        abandoned: "abandoned";
+        cancelled: "cancelled";
+        interrupted: "interrupted";
+        policy_stop: "policy_stop";
+        provider_failure: "provider_failure";
+        shutdown: "shutdown";
+        success: "success";
+        timeout: "timeout";
+        tool_failure: "tool_failure";
+    }>;
+    policyName: z.ZodOptional<z.ZodString>;
+    message: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            summary: "summary";
+            system: "system";
+            user: "user";
+        }>;
+        status: z.ZodEnum<{
+            committed: "committed";
+            completed: "completed";
+            failed: "failed";
+            interrupted: "interrupted";
+            streaming: "streaming";
+        }>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            text: z.ZodString;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            mediaType: z.ZodString;
+            reference: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"source">;
+            sourceId: z.ZodString;
+            url: z.ZodOptional<z.ZodURL>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-call">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-result">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            outcome: z.ZodEnum<{
+                error: "error";
+                interrupted: "interrupted";
+                success: "success";
+            }>;
+            output: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"provider">;
+            envelope: z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"control">;
+            reason: z.ZodEnum<{
+                "run-interrupted": "run-interrupted";
+                "stale-run": "stale-run";
+            }>;
+        }, z.core.$strip>], "type">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+export type AgentRuntimeEvent = z.infer<typeof AgentRuntimeEventSchema>;
+export type AgentRuntimePublisher = (event: AgentRuntimeEvent) => void | Promise<void>;
+//# sourceMappingURL=events.d.ts.map

package/dist/agent-runtime/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB,eAAO,MAAM,8BAA8B;;;;;;;;iBAKzC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKrC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;iBAKnC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;iBASrC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOnC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAMlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC"}

package/dist/agent-runtime/history.d.ts

@@ -0,0 +1,11 @@
+import { type FilePart, type ModelMessage } from 'ai';
+import type { AgentMessage, AgentMessagePart } from './schemas';
+export interface AgentHistoryProjectionOptions {
+    resolveFile?(part: Extract<AgentMessagePart, {
+        type: 'file';
+    }>, message: AgentMessage): FilePart['data'] | Promise<FilePart['data']>;
+    unresolvedFile?: 'text' | 'omit' | 'error';
+}
+/** Project canonical engine records into provider-valid AI SDK messages. */
+export declare function projectAgentHistory(messages: readonly AgentMessage[], options?: AgentHistoryProjectionOptions): Promise<ModelMessage[]>;
+//# sourceMappingURL=history.d.ts.map

package/dist/agent-runtime/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/history.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,YAAY,EAAsB,MAAM,IAAI,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAyB,MAAM,WAAW,CAAC;AAEvF,MAAM,WAAW,6BAA6B;IAC5C,WAAW,CAAC,CACV,IAAI,EAAE,OAAO,CAAC,gBAAgB,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,EACjD,OAAO,EAAE,YAAY,GACpB,QAAQ,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;IAChD,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;CAC5C;AA0FD,4EAA4E;AAC5E,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,SAAS,YAAY,EAAE,EACjC,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB"}

package/dist/agent-runtime/managed-tools.d.ts

@@ -0,0 +1,18 @@
+import type { RuntimeContext } from '../contract';
+import type { OperationIdentity } from '../server/types';
+import { type ToolExecutionControlReason, type ToolLifecycle } from '../tools/execute';
+export interface AgentToolFenceContext {
+    runId: string;
+    stepId?: string;
+    callId?: string;
+    idempotencyKey?: string;
+}
+export interface AgentToolFenceConfig {
+    runId: string;
+    assertCurrent(input: AgentToolFenceContext): void | ToolExecutionControlReason | Promise<void> | Promise<ToolExecutionControlReason | undefined>;
+    context?(ctx: RuntimeContext, endpoint: OperationIdentity): Partial<AgentToolFenceContext>;
+    onSettled?(input: AgentToolFenceContext): void | Promise<void>;
+}
+/** Compose beside auth/application lifecycles with `composeToolLifecycle`. */
+export declare function createAgentToolFenceLifecycle(config: AgentToolFenceConfig): ToolLifecycle;
+//# sourceMappingURL=managed-tools.d.ts.map

package/dist/agent-runtime/managed-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-tools.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/managed-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAEL,KAAK,0BAA0B,EAC/B,KAAK,aAAa,EACnB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CACX,KAAK,EAAE,qBAAqB,GAE1B,IAAI,GACJ,0BAA0B,GAC1B,OAAO,CAAC,IAAI,CAAC,GACb,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC,CAAC;IACpD,OAAO,CAAC,CAAC,GAAG,EAAE,cAAc,EAAE,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAC3F,SAAS,CAAC,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChE;AAUD,8EAA8E;AAC9E,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,oBAAoB,GAAG,aAAa,CAoBzF"}

package/dist/agent-runtime/models.d.ts

@@ -0,0 +1,51 @@
+import type { LanguageModel, LanguageModelUsage } from 'ai';
+import { z } from 'zod';
+import type { AgentUsage } from './schemas';
+export declare const AgentModelCapabilitySchema: z.ZodEnum<{
+    files: "files";
+    reasoning: "reasoning";
+    tools: "tools";
+    vision: "vision";
+}>;
+export type AgentModelCapability = z.infer<typeof AgentModelCapabilitySchema>;
+export declare const AgentModelDescriptorSchema: z.ZodObject<{
+    provider: z.ZodString;
+    modelId: z.ZodString;
+    contextWindow: z.ZodInt;
+    capabilities: z.ZodArray<z.ZodEnum<{
+        files: "files";
+        reasoning: "reasoning";
+        tools: "tools";
+        vision: "vision";
+    }>>;
+    observedAt: z.ZodOptional<z.ZodISODateTime>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AgentModelDescriptor = z.infer<typeof AgentModelDescriptorSchema>;
+export interface AgentLanguageModelProvider {
+    create(modelId: string): LanguageModel;
+    normalizeUsage?(input: {
+        usage: LanguageModelUsage;
+        providerMetadata?: unknown;
+    }): AgentUsage;
+}
+export interface AgentModelDeclaration extends AgentModelDescriptor {
+    provider: string;
+}
+export interface AgentModelRegistryConfig<MODELS extends Record<string, AgentModelDeclaration>> {
+    models: MODELS;
+    providers: Readonly<Record<string, AgentLanguageModelProvider>>;
+}
+export interface AgentResolvedModel {
+    descriptor: AgentModelDescriptor;
+    model: LanguageModel;
+    normalizeUsage?: AgentLanguageModelProvider['normalizeUsage'];
+}
+export interface AgentModelRegistry<MODEL_KEY extends string> {
+    keys(): readonly MODEL_KEY[];
+    descriptor(key: MODEL_KEY): AgentModelDescriptor;
+    supports(key: MODEL_KEY, capabilities: readonly AgentModelCapability[]): boolean;
+    resolve(key: MODEL_KEY, capabilities?: readonly AgentModelCapability[]): AgentResolvedModel;
+}
+export declare function defineModelRegistry<MODELS extends Record<string, AgentModelDeclaration>>(config: AgentModelRegistryConfig<MODELS>): AgentModelRegistry<Extract<keyof MODELS, string>>;
+//# sourceMappingURL=models.d.ts.map

package/dist/agent-runtime/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/models.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,IAAI,CAAC;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,eAAO,MAAM,0BAA0B;;;;;EAAoD,CAAC;AAE5F,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;iBAOrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,MAAM,WAAW,0BAA0B;IACzC,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAAC;IACvC,cAAc,CAAC,CAAC,KAAK,EAAE;QACrB,KAAK,EAAE,kBAAkB,CAAC;QAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;KAC5B,GAAG,UAAU,CAAC;CAChB;AAED,MAAM,WAAW,qBAAsB,SAAQ,oBAAoB;IACjE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,wBAAwB,CACvC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC;IAEpD,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC,CAAC;CACjE;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,oBAAoB,CAAC;IACjC,KAAK,EAAE,aAAa,CAAC;IACrB,cAAc,CAAC,EAAE,0BAA0B,CAAC,gBAAgB,CAAC,CAAC;CAC/D;AAED,MAAM,WAAW,kBAAkB,CAAC,SAAS,SAAS,MAAM;IAC1D,IAAI,IAAI,SAAS,SAAS,EAAE,CAAC;IAC7B,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,oBAAoB,CAAC;IACjD,QAAQ,CAAC,GAAG,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAAG,OAAO,CAAC;IACjF,OAAO,CAAC,GAAG,EAAE,SAAS,EAAE,YAAY,CAAC,EAAE,SAAS,oBAAoB,EAAE,GAAG,kBAAkB,CAAC;CAC7F;AAED,wBAAgB,mBAAmB,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,EACtF,MAAM,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACvC,kBAAkB,CAAC,OAAO,CAAC,MAAM,MAAM,EAAE,MAAM,CAAC,CAAC,CAqCnD"}