pi-ca-leash 0.10.0

package/node_modules/@pi-claude-code-agent/runtime/dist/drivers/messages.d.ts

@@ -0,0 +1,72 @@
+export interface NormalizedDriverMessageBlock {
+    type: string;
+    text?: string;
+    name?: string;
+    id?: string;
+    input?: unknown;
+    content?: unknown;
+    isError?: boolean;
+    raw?: unknown;
+}
+export interface NormalizedDriverUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+    reasoningOutputTokens?: number;
+    totalCostUsd?: number;
+    contextTokens?: number;
+    contextWindow?: number;
+    contextPercentage?: number;
+    maxOutputTokens?: number;
+    raw?: unknown;
+}
+interface NormalizedDriverMessageBase {
+    raw?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export interface SystemDriverMessage extends NormalizedDriverMessageBase {
+    type: "system";
+    subtype?: string;
+    sessionId?: string;
+    cwd?: string;
+    model?: string;
+}
+export interface AssistantDriverMessage extends NormalizedDriverMessageBase {
+    type: "assistant";
+    blocks: NormalizedDriverMessageBlock[];
+    model?: string;
+}
+export interface ToolUseDriverMessage extends NormalizedDriverMessageBase {
+    type: "tool_use";
+    toolName: string;
+    toolUseId?: string;
+    input?: unknown;
+}
+export interface ToolResultDriverMessage extends NormalizedDriverMessageBase {
+    type: "tool_result";
+    role?: "user" | "tool";
+    blocks?: NormalizedDriverMessageBlock[];
+    toolName: string;
+    toolUseId?: string;
+    output?: unknown;
+    isError?: boolean;
+}
+export interface ResultDriverMessage extends NormalizedDriverMessageBase {
+    type: "result";
+    ok: boolean;
+    summary: string;
+    stopReason?: string;
+    usage?: NormalizedDriverUsage;
+}
+export interface ErrorDriverMessage extends NormalizedDriverMessageBase {
+    type: "error";
+    message: string;
+    code?: string;
+}
+export interface StreamEventDriverMessage extends NormalizedDriverMessageBase {
+    type: "stream_event";
+    summary: string;
+}
+export type NormalizedDriverMessage = SystemDriverMessage | AssistantDriverMessage | ToolUseDriverMessage | ToolResultDriverMessage | ResultDriverMessage | ErrorDriverMessage | StreamEventDriverMessage;
+export {};

package/node_modules/@pi-claude-code-agent/runtime/dist/drivers/messages.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=messages.js.map

package/node_modules/@pi-claude-code-agent/runtime/dist/drivers/messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.js","sourceRoot":"","sources":["../../src/drivers/messages.ts"],"names":[],"mappings":""}

package/node_modules/@pi-claude-code-agent/runtime/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { ClaudeCodeRuntime } from "./runtime.js";
+export { RUNTIME_DRIVER_ENV, parseRuntimeDriverName, resolveRuntimeDriverFromEnv } from "./driver-config.js";
+export { ClaudeSdkDriver, parseClaudeSdkMessage } from "./drivers/claude-sdk.js";
+export { CodexCliDriver, parseCodexCliEvent, buildCodexCliCommand } from "./drivers/codex-cli.js";
+export type { NormalizedDriverMessage } from "./drivers/messages.js";
+export type { DriverEventEnvelope, InterruptResult, ResultEvent, RuntimeDriver, RuntimeDriverName, RuntimeDriverResolver, RuntimeEvent, RuntimeMessage, RuntimeMessageBlock, RuntimeOptions, RuntimeSessionId, RuntimeSessionState, RuntimeStatus, SendMessageInput, StartSessionInput, ToolEvent, TranscriptChunk, } from "./types.js";

package/node_modules/@pi-claude-code-agent/runtime/dist/index.js

@@ -0,0 +1,5 @@
+export { ClaudeCodeRuntime } from "./runtime.js";
+export { RUNTIME_DRIVER_ENV, parseRuntimeDriverName, resolveRuntimeDriverFromEnv } from "./driver-config.js";
+export { ClaudeSdkDriver, parseClaudeSdkMessage } from "./drivers/claude-sdk.js";
+export { CodexCliDriver, parseCodexCliEvent, buildCodexCliCommand } from "./drivers/codex-cli.js";
+//# sourceMappingURL=index.js.map

package/node_modules/@pi-claude-code-agent/runtime/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAC7G,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC"}

package/node_modules/@pi-claude-code-agent/runtime/dist/persistence.d.ts

@@ -0,0 +1,16 @@
+import type { RuntimeEvent, RuntimeSessionId, RuntimeStatus, TranscriptChunk } from "./types.js";
+export declare function defaultStorageDir(): string;
+export declare function sessionDir(storageDir: string, sessionId: RuntimeSessionId): string;
+export declare function statePath(storageDir: string, sessionId: RuntimeSessionId): string;
+export declare function eventsPath(storageDir: string, sessionId: RuntimeSessionId): string;
+export declare function transcriptPath(storageDir: string, sessionId: RuntimeSessionId): string;
+export declare function ensureSessionLayout(storageDir: string, sessionId: RuntimeSessionId): Promise<void>;
+export declare function writeState(storageDir: string, status: RuntimeStatus): Promise<void>;
+export declare function readState(storageDir: string, sessionId: RuntimeSessionId): Promise<RuntimeStatus | undefined>;
+export declare function appendJsonLine(path: string, value: unknown): Promise<void>;
+export declare function appendEvent(storageDir: string, event: RuntimeEvent): Promise<void>;
+export declare function readJsonLines<T>(path: string): Promise<T[]>;
+export declare function readEvents(storageDir: string, sessionId: RuntimeSessionId, cursor?: number): Promise<TranscriptChunk>;
+export declare function readTranscript(storageDir: string, sessionId: RuntimeSessionId, cursor?: number): Promise<TranscriptChunk>;
+export declare function tailTranscript(storageDir: string, sessionId: RuntimeSessionId, limit?: number): Promise<RuntimeEvent[]>;
+export declare function listStates(storageDir: string): Promise<RuntimeStatus[]>;

package/node_modules/@pi-claude-code-agent/runtime/dist/persistence.js

@@ -0,0 +1,94 @@
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export function defaultStorageDir() {
+    return join(process.cwd(), ".claude-runtime");
+}
+export function sessionDir(storageDir, sessionId) {
+    return join(storageDir, "sessions", sessionId);
+}
+export function statePath(storageDir, sessionId) {
+    return join(sessionDir(storageDir, sessionId), "state.json");
+}
+export function eventsPath(storageDir, sessionId) {
+    return join(sessionDir(storageDir, sessionId), "events.jsonl");
+}
+export function transcriptPath(storageDir, sessionId) {
+    return join(sessionDir(storageDir, sessionId), "transcript.jsonl");
+}
+export async function ensureSessionLayout(storageDir, sessionId) {
+    await mkdir(join(sessionDir(storageDir, sessionId), "artifacts"), { recursive: true });
+}
+export async function writeState(storageDir, status) {
+    const path = statePath(storageDir, status.sessionId);
+    await mkdir(dirname(path), { recursive: true });
+    const tempPath = `${path}.${randomUUID()}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(status, null, 2)}\n`, "utf8");
+    await rename(tempPath, path);
+}
+export async function readState(storageDir, sessionId) {
+    try {
+        const raw = await readFile(statePath(storageDir, sessionId), "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function appendJsonLine(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    const line = `${JSON.stringify(value)}\n`;
+    await appendFile(path, line, "utf8");
+}
+async function readFileSafe(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+export async function appendEvent(storageDir, event) {
+    await appendJsonLine(eventsPath(storageDir, event.sessionId), event);
+    if (["message", "tool", "result", "error"].includes(event.type)) {
+        await appendJsonLine(transcriptPath(storageDir, event.sessionId), event);
+    }
+}
+export async function readJsonLines(path) {
+    const raw = await readFileSafe(path);
+    return raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+export async function readEvents(storageDir, sessionId, cursor = 0) {
+    const items = await readJsonLines(eventsPath(storageDir, sessionId));
+    return {
+        items: items.slice(cursor),
+        nextCursor: items.length,
+    };
+}
+export async function readTranscript(storageDir, sessionId, cursor = 0) {
+    const items = await readJsonLines(transcriptPath(storageDir, sessionId));
+    return {
+        items: items.slice(cursor),
+        nextCursor: items.length,
+    };
+}
+export async function tailTranscript(storageDir, sessionId, limit = 20) {
+    const items = await readJsonLines(transcriptPath(storageDir, sessionId));
+    return items.slice(-limit);
+}
+export async function listStates(storageDir) {
+    const base = join(storageDir, "sessions");
+    try {
+        const entries = await readdir(base, { withFileTypes: true });
+        const states = await Promise.all(entries.filter((entry) => entry.isDirectory()).map((entry) => readState(storageDir, entry.name)));
+        return states.filter((state) => Boolean(state));
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=persistence.js.map

package/node_modules/@pi-claude-code-agent/runtime/dist/persistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.js","sourceRoot":"","sources":["../src/persistence.ts"],"names":[],"mappings":"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"}

package/node_modules/@pi-claude-code-agent/runtime/dist/runtime.d.ts

@@ -0,0 +1,31 @@
+import type { InterruptResult, RuntimeEvent, RuntimeOptions, RuntimeSessionId, RuntimeStatus, SendMessageInput, StartSessionInput, TranscriptChunk } from "./types.js";
+export declare class ClaudeCodeRuntime {
+    private readonly storageDir;
+    private readonly drivers;
+    private readonly defaultDriverName;
+    private readonly resolveDriverByName;
+    private readonly emitter;
+    private readonly activeRuns;
+    private readonly sequences;
+    constructor(options?: RuntimeOptions);
+    start(input: StartSessionInput): Promise<RuntimeStatus>;
+    send(input: SendMessageInput): Promise<RuntimeStatus>;
+    status(sessionId: RuntimeSessionId): Promise<RuntimeStatus | undefined>;
+    list(): Promise<RuntimeStatus[]>;
+    interrupt(sessionId: RuntimeSessionId): Promise<InterruptResult>;
+    stop(sessionId: RuntimeSessionId): Promise<RuntimeStatus>;
+    tail(sessionId: RuntimeSessionId, limit?: number): Promise<RuntimeEvent[]>;
+    readTranscript(sessionId: RuntimeSessionId, cursor?: number): Promise<TranscriptChunk>;
+    events(sessionId: RuntimeSessionId, cursor?: number): Promise<TranscriptChunk>;
+    subscribe(listener: (event: RuntimeEvent) => void, sessionId?: RuntimeSessionId): () => void;
+    stream(sessionId?: RuntimeSessionId): AsyncIterable<RuntimeEvent>;
+    private runSession;
+    private waitForRunCompletion;
+    private handleDriverEvent;
+    private emitError;
+    private resolveDriver;
+    private patchStatus;
+    private requireSession;
+    private emitEvent;
+    private nextSequence;
+}

package/node_modules/@pi-claude-code-agent/runtime/dist/runtime.js

@@ -0,0 +1,409 @@
+import { EventEmitter, on } from "node:events";
+import { randomUUID } from "node:crypto";
+import { resolve } from "node:path";
+import { appendEvent, defaultStorageDir, ensureSessionLayout, listStates, readEvents, readState, readTranscript, tailTranscript, writeState, } from "./persistence.js";
+import { ClaudeSdkDriver, parseClaudeSdkMessage } from "./drivers/claude-sdk.js";
+import { CodexCliDriver } from "./drivers/codex-cli.js";
+export class ClaudeCodeRuntime {
+    storageDir;
+    drivers = new Map();
+    defaultDriverName;
+    resolveDriverByName;
+    emitter = new EventEmitter();
+    activeRuns = new Map();
+    sequences = new Map();
+    constructor(options = {}) {
+        this.storageDir = resolve(options.storageDir ?? defaultStorageDir());
+        const defaultClaudeDriver = new ClaudeSdkDriver();
+        const defaultCodexDriver = new CodexCliDriver();
+        this.drivers.set(defaultClaudeDriver.name, defaultClaudeDriver);
+        this.drivers.set(defaultCodexDriver.name, defaultCodexDriver);
+        if (options.drivers) {
+            for (const driver of Object.values(options.drivers)) {
+                if (driver) {
+                    this.drivers.set(driver.name, driver);
+                }
+            }
+        }
+        if (options.driver) {
+            this.drivers.set(options.driver.name, options.driver);
+        }
+        this.defaultDriverName = options.defaultDriver ?? options.driver?.name ?? "claude-sdk";
+        this.resolveDriverByName = options.resolveDriver ?? ((name) => {
+            const driver = this.drivers.get(name);
+            if (!driver) {
+                throw new Error(`No runtime driver registered for ${name}`);
+            }
+            return driver;
+        });
+    }
+    async start(input) {
+        const sessionId = randomUUID();
+        const driverName = input.driver ?? this.defaultDriverName;
+        const driver = this.resolveDriver(driverName);
+        const cwd = resolve(input.cwd ?? process.cwd());
+        const now = new Date().toISOString();
+        const status = {
+            sessionId,
+            driver: driver.name,
+            driverSessionId: sessionId,
+            state: "starting",
+            cwd,
+            model: input.model,
+            name: input.name,
+            createdAt: now,
+            updatedAt: now,
+            lastActivityAt: now,
+            raw: {},
+        };
+        await ensureSessionLayout(this.storageDir, sessionId);
+        await writeState(this.storageDir, status);
+        await this.emitEvent({ type: "session.created", sessionId, state: "starting" }, status);
+        await this.runSession(status, {
+            prompt: input.prompt,
+            appendSystemPrompt: input.appendSystemPrompt,
+            model: input.model,
+            name: input.name,
+            permissionMode: input.permissionMode,
+            tools: input.tools,
+            additionalDirectories: input.additionalDirectories,
+            env: input.env,
+        });
+        return (await this.status(sessionId));
+    }
+    async send(input) {
+        const status = await this.requireSession(input.sessionId);
+        if (status.state === "stopped") {
+            throw new Error(`Session ${input.sessionId} stopped`);
+        }
+        if (this.activeRuns.has(input.sessionId)) {
+            throw new Error(`Session ${input.sessionId} already active`);
+        }
+        await this.runSession(status, {
+            prompt: input.message,
+            appendSystemPrompt: input.appendSystemPrompt,
+            model: input.model ?? status.model,
+            name: status.name,
+            env: input.env,
+            resumeSessionId: status.driverSessionId,
+        });
+        return (await this.status(input.sessionId));
+    }
+    async status(sessionId) {
+        return readState(this.storageDir, sessionId);
+    }
+    async list() {
+        const states = await listStates(this.storageDir);
+        return states.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    async interrupt(sessionId) {
+        const status = await this.requireSession(sessionId);
+        if (status.state === "stopped") {
+            return { sessionId, interrupted: false, reason: "already-stopped" };
+        }
+        const active = this.activeRuns.get(sessionId);
+        if (!active) {
+            return { sessionId, interrupted: false, reason: "no-active-run" };
+        }
+        active.handle.kill("SIGINT");
+        const next = await this.patchStatus(sessionId, {
+            state: "interrupted",
+            interruptedAt: new Date().toISOString(),
+        });
+        await this.emitEvent({ type: "session.updated", sessionId, state: next.state, patch: { interrupted: true } }, next);
+        return { sessionId, interrupted: true, signal: "SIGINT", reason: "signalled" };
+    }
+    async stop(sessionId) {
+        await this.requireSession(sessionId);
+        const active = this.activeRuns.get(sessionId);
+        if (active) {
+            active.handle.kill("SIGINT");
+        }
+        const next = await this.patchStatus(sessionId, {
+            state: "stopped",
+            stopRequested: true,
+            stoppedAt: new Date().toISOString(),
+            activeRunId: undefined,
+        });
+        await this.emitEvent({ type: "session.stopped", sessionId, state: "stopped" }, next);
+        return next;
+    }
+    async tail(sessionId, limit = 20) {
+        return tailTranscript(this.storageDir, sessionId, limit);
+    }
+    async readTranscript(sessionId, cursor = 0) {
+        return readTranscript(this.storageDir, sessionId, cursor);
+    }
+    async events(sessionId, cursor = 0) {
+        return readEvents(this.storageDir, sessionId, cursor);
+    }
+    subscribe(listener, sessionId) {
+        const wrapped = (event) => {
+            if (!sessionId || event.sessionId === sessionId) {
+                listener(event);
+            }
+        };
+        this.emitter.on("event", wrapped);
+        return () => this.emitter.off("event", wrapped);
+    }
+    async *stream(sessionId) {
+        for await (const [event] of on(this.emitter, "event")) {
+            if (!sessionId || event.sessionId === sessionId) {
+                yield event;
+            }
+        }
+    }
+    async runSession(status, input) {
+        const runId = randomUUID();
+        const next = await this.patchStatus(status.sessionId, {
+            state: input.resumeSessionId ? "running" : "starting",
+            activeRunId: runId,
+            stopRequested: false,
+            model: input.model ?? status.model,
+            name: input.name ?? status.name,
+        });
+        await this.emitEvent({ type: "session.updated", sessionId: status.sessionId, state: next.state, patch: { activeRunId: runId } }, next);
+        const driver = this.resolveDriver(status.driver);
+        const handle = driver.run({
+            sessionId: status.sessionId,
+            prompt: input.prompt,
+            cwd: next.cwd,
+            model: input.model,
+            name: input.name,
+            appendSystemPrompt: input.appendSystemPrompt,
+            permissionMode: input.permissionMode,
+            tools: input.tools,
+            additionalDirectories: input.additionalDirectories,
+            env: input.env,
+            resumeSessionId: input.resumeSessionId,
+        }, async (event) => {
+            await this.handleDriverEvent(status.sessionId, event);
+        });
+        this.activeRuns.set(status.sessionId, { runId, handle, requestedModel: input.model });
+        void this.waitForRunCompletion(status.sessionId, runId, handle);
+    }
+    async waitForRunCompletion(sessionId, runId, handle) {
+        const { code, signal } = await handle.done;
+        const current = await this.requireSession(sessionId);
+        const stillActive = current.activeRunId === runId;
+        if (stillActive) {
+            this.activeRuns.delete(sessionId);
+        }
+        if (!stillActive) {
+            return;
+        }
+        if (current.stopRequested || current.state === "stopped") {
+            const stopped = await this.patchStatus(sessionId, {
+                state: "stopped",
+                stoppedAt: current.stoppedAt ?? new Date().toISOString(),
+                activeRunId: undefined,
+            });
+            await this.emitEvent({ type: "session.stopped", sessionId, state: "stopped" }, stopped);
+            return;
+        }
+        if (signal === "SIGINT" || current.state === "interrupted") {
+            const interrupted = await this.patchStatus(sessionId, {
+                state: "interrupted",
+                interruptedAt: current.interruptedAt ?? new Date().toISOString(),
+                activeRunId: undefined,
+            });
+            await this.emitEvent({ type: "session.idle", sessionId, state: "interrupted" }, interrupted);
+            return;
+        }
+        if (code && code !== 0) {
+            const failed = await this.patchStatus(sessionId, {
+                state: "failed",
+                activeRunId: undefined,
+                lastError: current.lastError ?? { message: `Driver exited with code ${code}` },
+            });
+            await this.emitEvent({ type: "session.stopped", sessionId, state: "failed" }, failed);
+            return;
+        }
+        const idle = await this.patchStatus(sessionId, {
+            state: "idle",
+            completedAt: new Date().toISOString(),
+            activeRunId: undefined,
+        });
+        await this.emitEvent({ type: "session.idle", sessionId, state: "idle" }, idle);
+    }
+    async handleDriverEvent(sessionId, envelope) {
+        if (envelope.type === "raw") {
+            for (const message of parseClaudeSdkMessage(envelope.payload)) {
+                await this.handleDriverEvent(sessionId, { type: "message", payload: message });
+            }
+            return;
+        }
+        if (envelope.type === "error") {
+            await this.emitError(sessionId, envelope.payload.message, envelope.payload.code, envelope.payload.raw ?? envelope.payload);
+            return;
+        }
+        const current = await this.requireSession(sessionId);
+        const message = envelope.payload;
+        switch (message.type) {
+            case "system": {
+                if (message.subtype !== "init") {
+                    return;
+                }
+                const active = this.activeRuns.get(sessionId);
+                const updated = await this.patchStatus(sessionId, {
+                    driverSessionId: message.sessionId ?? current.driverSessionId,
+                    model: active?.requestedModel ?? message.model ?? current.model,
+                    raw: {
+                        ...(current.raw ?? {}),
+                        init: message.raw ?? message,
+                    },
+                });
+                await this.emitEvent({
+                    type: "session.updated",
+                    sessionId,
+                    state: updated.state,
+                    patch: {
+                        driverSessionId: updated.driverSessionId,
+                        model: updated.model,
+                    },
+                    raw: message.raw ?? message,
+                }, updated);
+                return;
+            }
+            case "assistant": {
+                const updated = await this.patchStatus(sessionId, {});
+                await this.emitEvent({
+                    type: "message",
+                    sessionId,
+                    role: "assistant",
+                    message: { role: "assistant", blocks: toRuntimeBlocks(message.blocks), raw: message.raw ?? message },
+                }, updated);
+                return;
+            }
+            case "tool_use": {
+                const updated = await this.patchStatus(sessionId, {});
+                await this.emitEvent({
+                    type: "tool",
+                    sessionId,
+                    phase: "requested",
+                    toolName: message.toolName,
+                    toolUseId: message.toolUseId,
+                    input: message.input,
+                    raw: message.raw ?? message,
+                }, updated);
+                return;
+            }
+            case "tool_result": {
+                const updated = await this.patchStatus(sessionId, {});
+                if (message.blocks?.length) {
+                    const role = message.role ?? "user";
+                    await this.emitEvent({
+                        type: "message",
+                        sessionId,
+                        role,
+                        message: { role, blocks: toRuntimeBlocks(message.blocks), raw: message.raw ?? message },
+                    }, updated);
+                }
+                await this.emitEvent({
+                    type: "tool",
+                    sessionId,
+                    phase: "completed",
+                    toolName: message.toolName,
+                    toolUseId: message.toolUseId,
+                    output: message.output,
+                    isError: message.isError,
+                    raw: message.raw ?? message,
+                }, updated);
+                return;
+            }
+            case "result": {
+                const updated = await this.patchStatus(sessionId, {});
+                await this.emitEvent({
+                    type: "result",
+                    sessionId,
+                    ok: message.ok,
+                    summary: message.summary,
+                    stopReason: message.stopReason,
+                    usage: message.usage,
+                    raw: message.raw ?? message,
+                }, updated);
+                return;
+            }
+            case "error": {
+                await this.emitError(sessionId, message.message, message.code, message.raw ?? message);
+                return;
+            }
+            case "stream_event":
+                return;
+            default:
+                return;
+        }
+    }
+    async emitError(sessionId, message, code, raw) {
+        const current = await this.patchStatus(sessionId, {
+            lastError: {
+                message: message ?? "Unknown driver error",
+                code,
+            },
+        });
+        await this.emitEvent({
+            type: "error",
+            sessionId,
+            message: message ?? "Unknown driver error",
+            code,
+            raw,
+        }, current);
+    }
+    resolveDriver(name) {
+        return this.resolveDriverByName(name);
+    }
+    async patchStatus(sessionId, patch) {
+        const current = await this.requireSession(sessionId);
+        const next = {
+            ...current,
+            ...patch,
+            updatedAt: new Date().toISOString(),
+            lastActivityAt: new Date().toISOString(),
+        };
+        await writeState(this.storageDir, next);
+        return next;
+    }
+    async requireSession(sessionId) {
+        const status = await readState(this.storageDir, sessionId);
+        if (!status) {
+            throw new Error(`Unknown session ${sessionId}`);
+        }
+        return status;
+    }
+    async emitEvent(partial, status) {
+        const sequence = (await this.nextSequence(status.sessionId)) + 1;
+        this.sequences.set(status.sessionId, sequence);
+        const event = {
+            id: randomUUID(),
+            sequence,
+            timestamp: new Date().toISOString(),
+            ...partial,
+        };
+        await appendEvent(this.storageDir, event);
+        this.emitter.emit("event", event);
+        return event;
+    }
+    async nextSequence(sessionId) {
+        const cached = this.sequences.get(sessionId);
+        if (typeof cached === "number") {
+            return cached;
+        }
+        const existing = await readEvents(this.storageDir, sessionId, 0);
+        const max = existing.items.at(-1)?.sequence ?? 0;
+        this.sequences.set(sessionId, max);
+        return max;
+    }
+}
+function toRuntimeBlocks(blocks) {
+    return blocks.map((block) => ({
+        type: block.type,
+        text: block.text,
+        name: block.name,
+        id: block.id,
+        input: block.input,
+        content: block.content,
+        isError: block.isError,
+        raw: block.raw,
+    }));
+}
+//# sourceMappingURL=runtime.js.map