@nylorun/runtime 0.5.0-beta → 0.6.0-beta

package/dist/core/store.d.ts

@@ -0,0 +1,16 @@
+import { DatabaseSync } from "node:sqlite";
+import type { LiveEvent } from "@nylorun/core/contracts";
+export declare function canonical(value: unknown): string;
+export declare class Store {
+    readonly db: DatabaseSync;
+    constructor(path: string);
+    tx<T>(fn: () => T): T;
+    get<T = any>(table: string, id: string): T | undefined;
+    all<T = any>(table: string): T[];
+    put(table: string, id: string, body: unknown): void;
+    event(sessionId: string, turnId: string | null, type: string, payload: unknown): LiveEvent;
+    history(sessionId: string, cursor?: string): {
+        items: LiveEvent[];
+        cursor: string | null;
+    };
+}

package/dist/core/store.js

@@ -0,0 +1,101 @@
+import { DatabaseSync } from "node:sqlite";
+import { randomUUID } from "node:crypto";
+export function canonical(value) {
+    if (Array.isArray(value))
+        return "[" + value.map(canonical).join(",") + "]";
+    if (value && typeof value === "object")
+        return ("{" +
+            Object.keys(value)
+                .sort()
+                .filter((k) => value[k] !== undefined)
+                .map((k) => JSON.stringify(k) + ":" + canonical(value[k]))
+                .join(",") +
+            "}");
+    return JSON.stringify(value) ?? "null";
+}
+export class Store {
+    db;
+    constructor(path) {
+        this.db = new DatabaseSync(path);
+        this.db
+            .exec(`PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000;
+      CREATE TABLE IF NOT EXISTS definitions(id TEXT PRIMARY KEY, body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS sessions(id TEXT PRIMARY KEY, body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS commands(id TEXT PRIMARY KEY, body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS checkpoints(id TEXT PRIMARY KEY, body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS effects(id TEXT PRIMARY KEY, body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS actions(id TEXT PRIMARY KEY, body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS events(sequence INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, body TEXT NOT NULL);
+      CREATE INDEX IF NOT EXISTS events_session ON events(session_id, sequence);`);
+    }
+    tx(fn) {
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const result = fn();
+            this.db.exec("COMMIT");
+            return result;
+        }
+        catch (e) {
+            this.db.exec("ROLLBACK");
+            throw e;
+        }
+    }
+    get(table, id) {
+        const row = this.db.prepare(`SELECT body FROM ${table} WHERE id=?`).get(id);
+        return row ? JSON.parse(String(row.body)) : undefined;
+    }
+    all(table) {
+        return this.db
+            .prepare(`SELECT body FROM ${table}`)
+            .all()
+            .map((r) => JSON.parse(String(r.body)));
+    }
+    put(table, id, body) {
+        this.db
+            .prepare(`INSERT INTO ${table}(id,body) VALUES(?,?) ON CONFLICT(id) DO UPDATE SET body=excluded.body`)
+            .run(id, JSON.stringify(body));
+    }
+    event(sessionId, turnId, type, payload) {
+        const base = {
+            eventId: randomUUID(),
+            sessionId,
+            turnId,
+            createdAt: new Date().toISOString(),
+            type,
+            payload,
+        };
+        const result = this.db
+            .prepare("INSERT INTO events(session_id,body) VALUES(?,?)")
+            .run(sessionId, "{}");
+        const event = {
+            ...base,
+            cursor: Buffer.from(`${sessionId}:${result.lastInsertRowid}`).toString("base64url"),
+        };
+        this.db
+            .prepare("UPDATE events SET body=? WHERE sequence=?")
+            .run(JSON.stringify(event), result.lastInsertRowid);
+        return event;
+    }
+    history(sessionId, cursor) {
+        let sequence = 0;
+        if (cursor) {
+            const decoded = Buffer.from(cursor, "base64url").toString();
+            const prefix = `${sessionId}:`;
+            if (!decoded.startsWith(prefix) ||
+                !/^\d+$/.test(decoded.slice(prefix.length)))
+                throw new Error("Invalid cursor");
+            sequence = Number(decoded.slice(prefix.length));
+        }
+        const items = this.db
+            .prepare("SELECT body FROM events WHERE session_id=? AND sequence>? ORDER BY sequence")
+            .all(sessionId, sequence)
+            .map((r) => JSON.parse(String(r.body)));
+        const last = this.db
+            .prepare("SELECT body FROM events WHERE session_id=? ORDER BY sequence DESC LIMIT 1")
+            .get(sessionId);
+        return {
+            items,
+            cursor: last ? JSON.parse(String(last.body)).cursor : null,
+        };
+    }
+}

package/dist/index.d.ts

@@ -1,11 +1,6 @@
-export type { RuntimeConfig } from "./config.js";
-export type * from "./contracts.js";
-export { Runtime, serveAgents, type AgentRouterOptions, type RuntimeActor, type ServeAgentsOptions, } from "./server/host.js";
-export { SessionHost, type SubmitOptions } from "./sessions/host.js";
-export { memorySessions } from "./sessions/store.js";
-export type { SessionStore, ManagedSessionStore, StoredSession, SessionSummary, CanonicalEvent, } from "./sessions/store.js";
-export { IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, validateImageBytes, } from "./media.js";
-export type { RuntimeMedia, MediaAsset, MediaReference } from "./media.js";
-export { httpModel, type HttpModelOptions, type ModelEnvironment, } from "./model/http-model.js";
-export { agUiEvents } from "./server/ag-ui.js";
-export type { ModelFactoryOptions, ModelPreview } from "./model/defaults.js";
+export { CoreRuntime, createRuntime, startRuntime, type RuntimeOptions } from "./core/runtime.js";
+export { scriptedModel, gatewayModel, type ModelProvider } from "./core/provider.js";
+export { httpModel, type HttpModelOptions, type ModelEnvironment } from "./model/http-model.js";
+export type { RuntimeAgent } from "./contracts.js";
+export { IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, validateImageBytes } from "./media.js";
+export type { RuntimeModelAdapter } from "./contracts.js";

package/dist/index.js

@@ -1,6 +1,4 @@
-export { Runtime, serveAgents, } from "./server/host.js";
-export { SessionHost } from "./sessions/host.js";
-export { memorySessions } from "./sessions/store.js";
-export { IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, validateImageBytes, } from "./media.js";
-export { httpModel, } from "./model/http-model.js";
-export { agUiEvents } from "./server/ag-ui.js";
+export { CoreRuntime, createRuntime, startRuntime } from "./core/runtime.js";
+export { scriptedModel, gatewayModel } from "./core/provider.js";
+export { httpModel } from "./model/http-model.js";
+export { IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, validateImageBytes } from "./media.js";

package/dist/model/defaults.d.ts

@@ -1,4 +1,4 @@
-import type { ModelAdapter } from "@nylorun/harness";
+import type { ModelAdapter } from "@nylorun/core/define";
 import { type ModelEnvironment } from "./http-model.js";
 export interface ModelPreview {
     readonly invocationId: string;

package/dist/model/http-model.d.ts

@@ -1,4 +1,4 @@
-import type { ModelAdapter } from "@nylorun/harness";
+import type { ModelAdapter } from "@nylorun/core/define";
 import type { ModelFactoryOptions } from "./defaults.js";
 export type ModelEnvironment = Readonly<Record<string, string | undefined>>;
 export interface HttpModelOptions extends ModelFactoryOptions {

package/dist/node/local-sessions.js

@@ -134,6 +134,23 @@ export function localSessions(options) {
                 .flatMap((session) => (session ? [sessionSummary(session)] : []))
                 .sort((a, b) => b.startedAt - a.startedAt);
         },
+        async delete(agentId, sessionId) {
+            const operation = operations.then(async () => {
+                await check();
+                const target = pathFor(agentId, sessionId);
+                try {
+                    await rm(target);
+                    return true;
+                }
+                catch (error) {
+                    if (isMissing(error))
+                        return false;
+                    throw error;
+                }
+            });
+            operations = operation.then(() => { }, () => { });
+            return operation;
+        },
         async close() {
             await operations;
             if (closed)

package/dist/server/host.d.ts

@@ -1,8 +1,10 @@
 import { Hono, type Context } from "hono";
 import type { JsonValue, RuntimeAgent } from "../contracts.js";
+import type { BuiltAgent, ModelAdapter } from "@nylorun/core/define";
 import { SessionHost } from "../sessions/host.js";
 import type { RuntimeConfig } from "../config.js";
 import type { ModelEnvironment } from "../model/http-model.js";
+import { type OpenSessionOptions, type SessionHandle } from "../session/handle.js";
 export type RuntimeActor = Readonly<{
     id: string;
     context?: Record<string, JsonValue>;
@@ -14,19 +16,55 @@ export type AgentRouterOptions = Readonly<{
     getEnvironment?: (context: Context) => ModelEnvironment | Promise<ModelEnvironment>;
     getRequestMetadata?: (context: Context) => Record<string, JsonValue> | undefined | Promise<Record<string, JsonValue> | undefined>;
 }>;
-export type ServeAgentsOptions = AgentRouterOptions & {
+/** 1.0 compatibility: requires an explicit Runtime and returns a Hono app. */
+export type ServeAgentsCompatOptions = AgentRouterOptions & {
     readonly agents: readonly RuntimeAgent[];
     readonly runtime: Runtime;
 };
+/** DX v5.6 local: optional Runtime; returns `{ fetch }`. */
+export type ServeAgentsFetchOptions = AgentRouterOptions & {
+    readonly agents?: readonly RuntimeAgent[];
+    readonly runtime?: Runtime;
+    /** Alias for `getInfo` — keep the name `info` (never `user`). */
+    readonly info?: AgentRouterOptions["getInfo"];
+    readonly on?: {
+        readonly session?: {
+            readonly created?: (session: {
+                readonly id: string;
+                readonly agentId: string;
+            }) => void;
+            readonly idle?: (session: {
+                readonly id: string;
+                readonly agentId: string;
+            }) => void;
+            readonly failed?: (session: {
+                readonly id: string;
+                readonly agentId: string;
+            }) => void;
+        };
+    };
+};
+export type ServeAgentsOptions = ServeAgentsCompatOptions;
+export type ServeAgentsFetch = {
+    readonly fetch: (request: Request) => Response | Promise<Response>;
+};
 declare const kServe: unique symbol;
 export declare class Runtime {
-    private readonly config;
+    readonly config: RuntimeConfig;
     readonly host: SessionHost;
     private served;
     private closing?;
     constructor(config?: RuntimeConfig);
     close: () => Promise<void>;
-    [kServe](options: Omit<ServeAgentsOptions, "runtime">): Hono<any>;
+    resolveModel(onPreview?: (preview: import("../model/defaults.js").ModelPreview) => void): ModelAdapter;
+    openSession(agent: BuiltAgent<any, any>, options?: OpenSessionOptions): SessionHandle;
+    listSessions(agentId: string): Promise<readonly import("../sessions/store.js").SessionSummary[]>;
+    getSession(agentId: string, sessionId: string): Promise<import("../sessions/store.js").StoredSession | undefined>;
+    deleteSession(agentId: string, sessionId: string): Promise<boolean>;
+    [kServe](options: Omit<ServeAgentsCompatOptions, "runtime"> & {
+        readonly agents: readonly RuntimeAgent[];
+    }): Hono<any>;
 }
-export declare function serveAgents(options: ServeAgentsOptions): Hono<any>;
+export declare function serveAgents(options: ServeAgentsCompatOptions): Hono<any>;
+export declare function serveAgents(options: ServeAgentsFetchOptions): ServeAgentsFetch;
 export {};

package/dist/server/host.js

@@ -8,6 +8,8 @@ import { memorySessions } from "../sessions/store.js";
 import { SessionHost } from "../sessions/host.js";
 import { IMAGE_MEDIA_TYPES, MAX_IMAGE_BYTES, decodeImageBase64, } from "../media.js";
 import { defaultModel, processEnvironment, registerRuntimeLifecycle, } from "../model/defaults.js";
+import { createSessionHandle, } from "../session/handle.js";
+import { installDefaultRuntimeFactory } from "../session/default.js";
 const randomUUID = () => crypto.randomUUID();
 const kServe = Symbol("serve");
 export class Runtime {
@@ -21,6 +23,26 @@ export class Runtime {
         registerRuntimeLifecycle(this.close);
     }
     close = () => (this.closing ??= this.host.close());
+    resolveModel(onPreview) {
+        return (this.config.onModelCall ??
+            (this.config.createModel ?? defaultModel)({
+                environment: this.config.environment ?? processEnvironment(),
+                onPreview,
+                media: this.config.media,
+            }));
+    }
+    openSession(agent, options) {
+        return createSessionHandle(this, agent, options);
+    }
+    async listSessions(agentId) {
+        return this.host.list(agentId);
+    }
+    async getSession(agentId, sessionId) {
+        return this.host.read(agentId, sessionId);
+    }
+    async deleteSession(agentId, sessionId) {
+        return this.host.delete(agentId, sessionId);
+    }
     [kServe](options) {
         if (this.served)
             throw new Error("A Runtime may only be served once.");
@@ -141,8 +163,20 @@ export class Runtime {
                 id: document.id,
                 state: document.status,
                 pending_interaction: document.state?.plan?.calls.find((call) => call.status === "interaction")?.interaction,
+                pending_waits: document.state?.plan?.calls
+                    .filter((call) => (call.status === "interaction" || call.status === "deferred") &&
+                    call.wait)
+                    .map((call) => call.wait),
             });
         });
+        app.delete("/:agentId/v1/sessions/:session", async (context) => {
+            const agent = agentFor(context);
+            const sessionId = context.req.param("session");
+            const deleted = await this.host.delete(agent.id, sessionId);
+            if (!deleted)
+                return context.json({ error: "unknown session" }, 404);
+            return context.json({ session_id: sessionId, deleted: true });
+        });
         app.post("/:agentId/v1/sessions/:session", async (context) => {
             const agent = agentFor(context), sessionId = context.req.param("session");
             const payload = await context.req.json();
@@ -161,6 +195,20 @@ export class Runtime {
             }
             if (payload.settlement)
                 input = { kind: "settle", ...payload.settlement };
+            else if (payload.action === "wait-resolve" ||
+                payload.waitResolve ||
+                (interaction?.kind === "wait-resolve" &&
+                    typeof interaction.waitId === "string")) {
+                const wait = payload.waitResolve ??
+                    (interaction?.kind === "wait-resolve" ? interaction : payload);
+                if (typeof wait.waitId !== "string")
+                    return context.json({ error: "wait-resolve requires waitId" }, 400);
+                input = {
+                    kind: "wait-resolve",
+                    waitId: wait.waitId,
+                    ...("value" in wait ? { value: wait.value } : {}),
+                };
+            }
             else if (interaction?.kind === "approval" &&
                 typeof interaction.id === "string" &&
                 typeof interaction.approved === "boolean")
@@ -178,7 +226,9 @@ export class Runtime {
                     value: interaction.value,
                 };
             else
-                return context.json({ error: "expected a correlated interaction or settlement" }, 400);
+                return context.json({
+                    error: "expected a correlated interaction, settlement, or wait-resolve",
+                }, 400);
             const document = await this.host.read(agent.id, sessionId);
             if (!document || document.status !== "waiting")
                 return context.json({ error: "interaction is no longer pending" }, 409);
@@ -280,9 +330,25 @@ export class Runtime {
     }
 }
 export function serveAgents(options) {
-    const { runtime, ...rest } = options;
-    return runtime[kServe](rest);
+    if ("runtime" in options && options.runtime) {
+        const { runtime, ...rest } = options;
+        return runtime[kServe]({
+            ...rest,
+            agents: options.agents ?? [],
+        });
+    }
+    const runtime = new Runtime({});
+    const getInfo = options.getInfo ?? ("info" in options ? options.info : undefined);
+    const app = runtime[kServe]({
+        ...options,
+        agents: options.agents ?? [],
+        ...(getInfo ? { getInfo } : {}),
+    });
+    return {
+        fetch: (request) => app.fetch(request),
+    };
 }
+installDefaultRuntimeFactory(() => new Runtime({}));
 /** Workers-style provider bindings on context.env; ignore Hono Node stream slots. */
 function bindingsEnvironment(context) {
     const env = context.env;

package/dist/session/api.d.ts

@@ -0,0 +1,10 @@
+import type { BuiltAgent } from "@nylorun/core/define";
+import { setDefaultRuntime } from "./default.js";
+import type { OpenSessionOptions, SessionHandle } from "./handle.js";
+export { setDefaultRuntime };
+export type { OpenSessionOptions, SessionHandle };
+/** Open-or-create a local session with an agent (bound to the default Runtime). */
+export declare function openSession(agent: BuiltAgent<any, any>, options?: OpenSessionOptions): SessionHandle;
+export declare function listSessions(agentId: string): Promise<readonly import("../sessions/store.js").SessionSummary[]>;
+export declare function getSession(agentId: string, sessionId: string): Promise<import("../sessions/store.js").StoredSession | undefined>;
+export declare function deleteSession(agentId: string, sessionId: string): Promise<boolean>;

package/dist/session/api.js

@@ -0,0 +1,15 @@
+import { getDefaultRuntime, setDefaultRuntime, } from "./default.js";
+export { setDefaultRuntime };
+/** Open-or-create a local session with an agent (bound to the default Runtime). */
+export function openSession(agent, options) {
+    return getDefaultRuntime().openSession(agent, options);
+}
+export async function listSessions(agentId) {
+    return getDefaultRuntime().listSessions(agentId);
+}
+export async function getSession(agentId, sessionId) {
+    return getDefaultRuntime().getSession(agentId, sessionId);
+}
+export async function deleteSession(agentId, sessionId) {
+    return getDefaultRuntime().deleteSession(agentId, sessionId);
+}

package/dist/session/default.d.ts

@@ -0,0 +1,5 @@
+import type { Runtime } from "../server/host.js";
+/** Wired from `server/host.ts` after `Runtime` is defined (avoids init cycles). */
+export declare function installDefaultRuntimeFactory(factory: () => Runtime): void;
+export declare function setDefaultRuntime(runtime: Runtime | undefined): void;
+export declare function getDefaultRuntime(): Runtime;

package/dist/session/default.js

@@ -0,0 +1,30 @@
+let defaultRuntime;
+let bannerShown = false;
+let createRuntime;
+/** Wired from `server/host.ts` after `Runtime` is defined (avoids init cycles). */
+export function installDefaultRuntimeFactory(factory) {
+    createRuntime = factory;
+}
+export function setDefaultRuntime(runtime) {
+    defaultRuntime = runtime;
+}
+export function getDefaultRuntime() {
+    if (defaultRuntime)
+        return defaultRuntime;
+    if (!createRuntime)
+        throw new Error("Default Runtime factory is not installed");
+    defaultRuntime = createRuntime();
+    maybeBanner();
+    return defaultRuntime;
+}
+function maybeBanner() {
+    if (bannerShown || typeof process === "undefined")
+        return;
+    if (process.env.NYLORUN_QUIET === "1")
+        return;
+    bannerShown = true;
+    const model = process.env.MODEL_PROVIDER && process.env.MODEL
+        ? `${process.env.MODEL_PROVIDER}/${process.env.MODEL}`
+        : "unset";
+    console.info(`nylorun ▸ local runtime · loop runs in this process · sessions in memory · model ${model} (your key)`);
+}

package/dist/session/handle.d.ts

@@ -0,0 +1,27 @@
+import type { BuiltAgent, JsonObject, JsonValue, ModelAdapter } from "@nylorun/core/define";
+import type { Session } from "@nylorun/harness";
+import type { RuntimeConfig } from "../config.js";
+import type { SessionHost } from "../sessions/host.js";
+export type OpenSessionOptions = {
+    readonly id?: string;
+    /** Trusted host bag — keep the name `info` (never `user`). */
+    readonly info?: unknown;
+    /** Initial durable session memory (`ExecutionState.state`). */
+    readonly state?: JsonObject;
+};
+export type SessionHandle<Output = unknown> = Session<{
+    readonly id: string;
+}, Output> & {
+    readonly agentId: string;
+};
+export type SessionRuntime = {
+    readonly host: SessionHost;
+    readonly config: RuntimeConfig;
+    resolveModel(): ModelAdapter;
+};
+export declare function createSessionHandle(runtime: SessionRuntime, agent: BuiltAgent<any, any>, options?: OpenSessionOptions): SessionHandle;
+/** Resolve a wait by harness waitId (H6). */
+export declare function resolveWait(runtime: SessionRuntime, agent: BuiltAgent<any, any>, sessionId: string, waitId: string, value?: JsonValue, options?: {
+    readonly info?: unknown;
+    readonly onModelCall?: ModelAdapter;
+}): Promise<void>;

package/dist/session/handle.js

@@ -0,0 +1,199 @@
+export function createSessionHandle(runtime, agent, options = {}) {
+    const id = options.id ?? crypto.randomUUID();
+    let seedState = options.state;
+    const info = options.info;
+    const submitOptions = () => {
+        const sessionState = seedState;
+        seedState = undefined;
+        return {
+            info: info === undefined
+                ? { sessionId: id }
+                : { ...info, sessionId: id },
+            onModelCall: runtime.resolveModel(),
+            ...(sessionState ? { sessionState } : {}),
+        };
+    };
+    const handle = {
+        id,
+        agentId: agent.id,
+        async input(message) {
+            try {
+                const result = await runtime.host.submit(agent, id, message, submitOptions());
+                const cursor = String((await runtime.host.read(agent.id, id))?.events.at(-1)?.seq ?? 0);
+                return {
+                    status: "accepted",
+                    turnId: result.state.plan?.turnId ?? result.state.executionId,
+                    cursor,
+                };
+            }
+            catch (error) {
+                return {
+                    status: "rejected",
+                    error: {
+                        code: error && typeof error === "object" && "code" in error
+                            ? String(error.code)
+                            : "runtime.input-rejected",
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                };
+            }
+        },
+        async *stream(opts) {
+            let after = opts?.after ? Number(opts.after) : 0;
+            if (!Number.isFinite(after) || after < 0)
+                after = 0;
+            const queue = [];
+            let notify;
+            const wake = () => {
+                notify?.();
+                notify = undefined;
+            };
+            const unsubscribe = runtime.host.subscribe(agent.id, id, (event) => {
+                queue.push(event);
+                wake();
+            });
+            try {
+                const existing = await runtime.host.read(agent.id, id);
+                for (const event of existing?.events ?? [])
+                    if (event.seq > after)
+                        queue.push(event);
+                for (;;) {
+                    while (queue.length) {
+                        const event = queue.shift();
+                        if (event.seq <= after)
+                            continue;
+                        after = event.seq;
+                        const mapped = mapEvent(event, id);
+                        if (mapped)
+                            yield mapped;
+                    }
+                    await new Promise((resolve) => {
+                        notify = resolve;
+                    });
+                }
+            }
+            finally {
+                unsubscribe();
+            }
+        },
+        async history() {
+            const document = await runtime.host.read(agent.id, id);
+            return (document?.events ?? [])
+                .filter((event) => ["final", "interaction.required", "error", "cancelled"].includes(event.type))
+                .map((event) => event.payload);
+        },
+        async approve(interactionId, approved) {
+            await runtime.host.submit(agent, id, { kind: "approve", interactionId, approved }, submitOptions());
+        },
+        async respond(interactionId, value) {
+            await runtime.host.submit(agent, id, { kind: "respond", interactionId, value }, submitOptions());
+        },
+        async cancel() {
+            await runtime.host.cancel(agent, id);
+        },
+    };
+    return handle;
+}
+/** Resolve a wait by harness waitId (H6). */
+export async function resolveWait(runtime, agent, sessionId, waitId, value, options) {
+    const input = {
+        kind: "wait-resolve",
+        waitId,
+        ...(value === undefined ? {} : { value }),
+    };
+    await runtime.host.submit(agent, sessionId, input, {
+        info: options?.info,
+        onModelCall: options?.onModelCall ?? runtime.resolveModel(),
+    });
+}
+function mapEvent(event, sessionId) {
+    const turnId = typeof event.payload.turnId === "string"
+        ? event.payload.turnId
+        : typeof event.payload.executionId === "string"
+            ? event.payload.executionId
+            : sessionId;
+    const cursor = String(event.seq);
+    const at = event.ts;
+    switch (event.type) {
+        case "session.run.started":
+            return { type: "turn.started", cursor, at, sessionId, turnId };
+        case "tool.started":
+            return {
+                type: "tool.started",
+                tool: String(event.payload.toolName ?? "tool"),
+                sessionId,
+                turnId,
+            };
+        case "tool.progress":
+            return {
+                type: "tool.progress",
+                tool: String(event.payload.toolName ?? "tool"),
+                sessionId,
+                turnId,
+            };
+        case "tool.completed":
+            return {
+                type: event.payload.outcome === "failed" ? "tool.failed" : "tool.completed",
+                tool: String(event.payload.toolName ?? "tool"),
+                sessionId,
+                turnId,
+            };
+        case "interaction.required": {
+            const interaction = event.payload.interaction;
+            return {
+                type: "interaction.required",
+                id: String(interaction?.id ?? ""),
+                prompt: String(interaction?.prompt ?? ""),
+                ...(interaction?.metadata ? { options: interaction.metadata } : {}),
+                sessionId,
+                turnId,
+            };
+        }
+        case "final":
+            return {
+                type: "turn.settled",
+                result: {
+                    status: "completed",
+                    output: event.payload.output,
+                },
+                sessionId,
+                turnId,
+            };
+        case "error":
+            return {
+                type: "turn.settled",
+                result: {
+                    status: "failed",
+                    error: {
+                        code: String(event.payload.code ?? "execution.failed"),
+                        message: String(event.payload.message ?? "failed"),
+                    },
+                },
+                sessionId,
+                turnId,
+            };
+        case "cancelled":
+            return {
+                type: "turn.settled",
+                result: { status: "cancelled" },
+                sessionId,
+                turnId,
+            };
+        default:
+            if (event.type === "model.requested" || event.type === "model.completed")
+                return {
+                    type: "status",
+                    status: "thinking",
+                    sessionId,
+                    turnId,
+                };
+            if (event.type.startsWith("tool."))
+                return {
+                    type: "status",
+                    status: "calling_tool",
+                    sessionId,
+                    turnId,
+                };
+            return undefined;
+    }
+}