@zhanguym/chatroom 1.0.0 → 1.1.0-beta.0

package/dist/plugins/agent/providers/codex/rpc.d.ts

@@ -0,0 +1,40 @@
+import type { LogWriter } from "#core/logging/types";
+export type CodexRequestId = string | number;
+export interface CodexNotification {
+    method: string;
+    params?: unknown;
+}
+export interface CodexServerRequest extends CodexNotification {
+    id: CodexRequestId;
+}
+interface InitializeResult {
+    userAgent: string;
+}
+export declare class CodexRpcClient {
+    private readonly logs;
+    private process;
+    private readonly pending;
+    private readonly notificationListeners;
+    private readonly requestListeners;
+    private readonly closeListeners;
+    private nextId;
+    private starting;
+    private initialized;
+    constructor(logs: LogWriter);
+    ensureStarted(): Promise<InitializeResult>;
+    request<T>(method: string, params?: unknown, timeoutMs?: number): Promise<T>;
+    notify(method: string, params?: unknown): void;
+    respond(id: CodexRequestId, result: unknown): void;
+    respondError(id: CodexRequestId, code: number, message: string): void;
+    onNotification(listener: (notification: CodexNotification) => void): () => void;
+    onServerRequest(listener: (request: CodexServerRequest) => void): () => void;
+    onTransportClose(listener: (error: Error) => void): () => void;
+    close(): Promise<void>;
+    private start;
+    private requestReady;
+    private failTransport;
+    private handleLine;
+    private write;
+    private requireProcess;
+}
+export {};

package/dist/plugins/agent/providers/codex/rpc.js

@@ -0,0 +1,227 @@
+import { LineProcess } from "#core/runtime/line-process";
+import { CHATROOM_VERSION } from "#core/runtime/identity";
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+export class CodexRpcClient {
+    logs;
+    process = null;
+    pending = new Map();
+    notificationListeners = new Set();
+    requestListeners = new Set();
+    closeListeners = new Set();
+    nextId = 1;
+    starting = null;
+    initialized = null;
+    constructor(logs) {
+        this.logs = logs;
+    }
+    async ensureStarted() {
+        if (this.initialized)
+            return this.initialized;
+        if (!this.starting)
+            this.starting = this.start();
+        try {
+            this.initialized = await this.starting;
+            return this.initialized;
+        }
+        finally {
+            this.starting = null;
+        }
+    }
+    async request(method, params, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+        await this.ensureStarted();
+        return this.requestReady(method, params, timeoutMs);
+    }
+    notify(method, params) {
+        this.write(params === undefined ? { method } : { method, params });
+    }
+    respond(id, result) {
+        this.write({ id, result });
+    }
+    respondError(id, code, message) {
+        this.write({ id, error: { code, message } });
+    }
+    onNotification(listener) {
+        this.notificationListeners.add(listener);
+        return () => this.notificationListeners.delete(listener);
+    }
+    onServerRequest(listener) {
+        this.requestListeners.add(listener);
+        return () => this.requestListeners.delete(listener);
+    }
+    onTransportClose(listener) {
+        this.closeListeners.add(listener);
+        return () => this.closeListeners.delete(listener);
+    }
+    async close() {
+        const process = this.process;
+        if (!process)
+            return;
+        this.failTransport(process, new Error("Codex app-server closed"));
+        process.terminate();
+        await process.waitForExit(1500);
+        process.forceKill();
+    }
+    async start() {
+        let process;
+        process = new LineProcess({
+            command: "codex",
+            args: ["app-server", "--listen", "stdio://", "-c", "mcp_servers={}"],
+            onStdout: (line) => this.handleLine(line),
+            onStderr: (line) => {
+                const message = line.trim();
+                if (message)
+                    this.logs.debug("agent.codex", "codex.stderr", message.slice(0, 4000));
+            },
+            onExit: (code, signal) => {
+                if (this.process !== process)
+                    return;
+                this.failTransport(process, new Error("Codex app-server exited" +
+                    (code === null ? "" : " with code " + code) +
+                    (signal ? " (" + signal + ")" : "")));
+            },
+            onError: (error) => {
+                if (this.process === process)
+                    this.failTransport(process, error);
+            },
+        });
+        await process.spawned();
+        this.process = process;
+        try {
+            const initialized = await this.requestReady("initialize", {
+                clientInfo: {
+                    name: "chatroom",
+                    title: "ChatRoom",
+                    version: CHATROOM_VERSION,
+                },
+                capabilities: { experimentalApi: false, requestAttestation: false },
+            });
+            this.notify("initialized");
+            return initialized;
+        }
+        catch (error) {
+            const failure = error instanceof Error ? error : new Error(String(error));
+            this.failTransport(process, failure);
+            process.terminate();
+            await process.waitForExit(500);
+            process.forceKill();
+            throw failure;
+        }
+    }
+    requestReady(method, params, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+        this.requireProcess();
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                if (!this.pending.delete(id))
+                    return;
+                reject(new Error(`Codex app-server request timed out: ${method}`));
+            }, timeoutMs);
+            timer.unref();
+            this.pending.set(id, {
+                resolve: (value) => {
+                    clearTimeout(timer);
+                    resolve(value);
+                },
+                reject: (error) => {
+                    clearTimeout(timer);
+                    reject(error);
+                },
+            });
+            try {
+                this.write(params === undefined ? { id, method } : { id, method, params });
+            }
+            catch (error) {
+                this.pending.delete(id);
+                clearTimeout(timer);
+                reject(error);
+            }
+        });
+    }
+    failTransport(process, error) {
+        if (this.process !== process)
+            return;
+        this.process = null;
+        this.initialized = null;
+        this.starting = null;
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+        for (const listener of this.closeListeners)
+            listener(error);
+    }
+    handleLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            this.logs.warn("agent.codex", "codex.invalid_json", "Codex app-server emitted invalid JSON", { line: line.slice(0, 1000) });
+            return;
+        }
+        if (!isRecord(message))
+            return;
+        if ("method" in message && typeof message.method === "string") {
+            const notification = {
+                method: message.method,
+                ...("params" in message ? { params: message.params } : {}),
+            };
+            const params = isRecord(notification.params) ? notification.params : null;
+            if (params &&
+                (notification.method === "configWarning" ||
+                    notification.method === "deprecationNotice" ||
+                    (notification.method === "warning" && params.threadId === null))) {
+                const summary = notification.method === "warning" ? params.message : params.summary;
+                if (typeof summary === "string")
+                    this.logs.warn("agent.codex", "codex." + notification.method, [
+                        summary,
+                        typeof params.details === "string" ? params.details : null,
+                    ]
+                        .filter(Boolean)
+                        .join("\n"));
+            }
+            if ("id" in message && isRequestId(message.id)) {
+                const request = {
+                    ...notification,
+                    id: message.id,
+                };
+                for (const listener of this.requestListeners)
+                    listener(request);
+            }
+            else {
+                for (const listener of this.notificationListeners)
+                    listener(notification);
+            }
+            return;
+        }
+        if (!("id" in message) || typeof message.id !== "number")
+            return;
+        const pending = this.pending.get(message.id);
+        if (!pending)
+            return;
+        this.pending.delete(message.id);
+        if ("error" in message && message.error) {
+            pending.reject(new Error(rpcErrorMessage(message.error)));
+            return;
+        }
+        pending.resolve("result" in message ? message.result : null);
+    }
+    write(message) {
+        this.requireProcess().writeLine(JSON.stringify(message));
+    }
+    requireProcess() {
+        if (!this.process)
+            throw new Error("Codex app-server is not running");
+        return this.process;
+    }
+}
+function isRequestId(value) {
+    return typeof value === "string" || typeof value === "number";
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function rpcErrorMessage(value) {
+    if (isRecord(value) && typeof value.message === "string")
+        return value.message;
+    return "Codex app-server request failed";
+}

package/dist/plugins/agent/providers/common.d.ts

@@ -0,0 +1,11 @@
+import type { AgentError, AgentInteractionOption } from "#plugins/agent/types";
+export declare function array(value: unknown): unknown[];
+export declare function record(value: unknown): Record<string, unknown> | null;
+export declare function questionOptions(value: unknown): AgentInteractionOption[];
+export declare function stringifyOptional(value: unknown): string | null;
+export declare function continuityInstructions(context: string): string;
+export declare function workspaceInstructions(prompt: string): string;
+export declare function combinedProviderInstructions(workspacePrompt: string | null, continuityContext: string | null): string | null;
+export declare function errorMessage(error: unknown): string;
+export declare function isMissingExecutable(error: unknown): boolean;
+export declare function providerError(error: unknown): AgentError;

package/dist/plugins/agent/providers/common.js

@@ -0,0 +1,75 @@
+export function array(value) {
+    return Array.isArray(value) ? value : [];
+}
+export function record(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+export function questionOptions(value) {
+    return array(value)
+        .map(record)
+        .filter((option) => Boolean(option))
+        .map((option, index) => ({
+        id: typeof option.label === "string" ? option.label : "option_" + index,
+        label: typeof option.label === "string"
+            ? option.label
+            : "Option " + (index + 1),
+        description: typeof option.description === "string" ? option.description : null,
+    }));
+}
+export function stringifyOptional(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function continuityInstructions(context) {
+    return [
+        "ChatRoom conversation continuity follows.",
+        "This is prior conversation context from periods handled by another coding-agent provider in the same ChatRoom session.",
+        "Treat it as authoritative prior conversation context alongside the current workspace state.",
+        "Do not mention this continuity injection unless it is directly relevant to the user's request.",
+        "",
+        context,
+    ].join("\n");
+}
+export function workspaceInstructions(prompt) {
+    return [
+        "ChatRoom workspace preset instructions follow.",
+        "These instructions are configured for the current workspace and apply to work performed in it.",
+        "",
+        prompt,
+    ].join("\n");
+}
+export function combinedProviderInstructions(workspacePrompt, continuityContext) {
+    const sections = [];
+    if (workspacePrompt)
+        sections.push(workspaceInstructions(workspacePrompt));
+    if (continuityContext)
+        sections.push(continuityInstructions(continuityContext));
+    return sections.length ? sections.join("\n\n") : null;
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function isMissingExecutable(error) {
+    return (Boolean(error) &&
+        typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+export function providerError(error) {
+    return {
+        message: errorMessage(error),
+        details: null,
+        providerData: null,
+    };
+}

package/dist/plugins/agent/providers/index.d.ts

@@ -0,0 +1,3 @@
+import type { LogWriter } from "#core/logging/types";
+import type { AgentProvider } from "../provider.js";
+export declare function createAgentProviders(logs: LogWriter): AgentProvider[];

package/dist/plugins/agent/providers/index.js

@@ -0,0 +1,4 @@
+import { CodexProvider } from "./codex/provider.js";
+export function createAgentProviders(logs) {
+    return [new CodexProvider(logs)];
+}

package/dist/plugins/agent/repository.d.ts

@@ -0,0 +1,21 @@
+import type { AgentStore } from "./store.js";
+import type { AgentHistory, AgentHistoryUpdate, AgentItem, AgentProviderSessionState, AgentSession, AgentTurn } from "./types.js";
+import type { AppDatabase } from "#infrastructure/database/app-database";
+export declare class AgentRepository implements AgentStore {
+    private readonly database;
+    constructor(database: AppDatabase);
+    reconcileInterrupted(now: string): void;
+    insertSession(session: AgentSession): void;
+    updateSession(session: AgentSession): void;
+    getSession(id: string): AgentSession | null;
+    listSessions(): AgentSession[];
+    deleteSession(id: string): void;
+    getProviderState(sessionId: string, provider: AgentProviderSessionState["provider"]): AgentProviderSessionState | null;
+    upsertProviderState(state: AgentProviderSessionState): void;
+    insertTurn(turn: AgentTurn): void;
+    updateTurn(turn: AgentTurn): void;
+    insertItem(item: AgentItem): void;
+    updateItem(item: AgentItem): void;
+    history(sessionId: string): AgentHistory | null;
+    historyUpdate(sessionId: string, turnIds: readonly string[], itemIds: readonly string[]): AgentHistoryUpdate | null;
+}

package/dist/plugins/agent/repository.js

@@ -0,0 +1,226 @@
+export class AgentRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    reconcileInterrupted(now) {
+        this.database.raw.exec("BEGIN IMMEDIATE");
+        try {
+            this.database.raw
+                .prepare("UPDATE agent_items SET status='interrupted', updated_at=? WHERE status IN ('running','waiting')")
+                .run(now);
+            this.database.raw
+                .prepare("UPDATE agent_turns SET status='interrupted', completed_at=? WHERE status='running'")
+                .run(now);
+            const interruptedSessions = this.database.raw
+                .prepare("SELECT id, updated_at FROM agent_sessions WHERE status IN ('running','waiting_input')")
+                .all();
+            const updateSession = this.database.raw.prepare("UPDATE agent_sessions SET status='idle', updated_at=? WHERE id=?");
+            for (const session of interruptedSessions)
+                updateSession.run(monotonicTimestamp(session.updated_at, now), session.id);
+            this.database.raw.exec("COMMIT");
+        }
+        catch (error) {
+            this.database.raw.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    insertSession(session) {
+        this.database.raw
+            .prepare("INSERT INTO agent_sessions(id, workspace_root, provider, status, created_at, updated_at) VALUES(?,?,?,?,?,?)")
+            .run(session.id, session.workspaceRoot, session.provider, session.status, session.createdAt, session.updatedAt);
+    }
+    updateSession(session) {
+        this.database.raw
+            .prepare("UPDATE agent_sessions SET workspace_root=?, provider=?, status=?, created_at=?, updated_at=? WHERE id=?")
+            .run(session.workspaceRoot, session.provider, session.status, session.createdAt, session.updatedAt, session.id);
+    }
+    getSession(id) {
+        const row = this.database.raw
+            .prepare("SELECT s.*, p.model AS model, p.reasoning_effort, p.reasoning_summary, p.service_tier, p.approval_policy_json, p.approvals_reviewer, p.permission_mode, p.token_usage_json, CASE WHEN EXISTS (SELECT 1 FROM agent_items ai JOIN agent_turns at ON at.id=ai.turn_id WHERE at.session_id=s.id AND ai.type='interaction' AND ai.status='waiting' AND json_extract(ai.payload_json,'$.interaction.kind')='approval') THEN 'approval' WHEN EXISTS (SELECT 1 FROM agent_items ai JOIN agent_turns at ON at.id=ai.turn_id WHERE at.session_id=s.id AND ai.type='interaction' AND ai.status='waiting') THEN 'input' ELSE NULL END AS attention_kind, (SELECT COUNT(*) FROM agent_items ai JOIN agent_turns at ON at.id=ai.turn_id WHERE at.session_id=s.id AND ai.type='interaction' AND ai.status='waiting') AS attention_count FROM agent_sessions s LEFT JOIN agent_session_providers p ON p.session_id=s.id AND p.provider=s.provider WHERE s.id=?")
+            .get(id);
+        return row ? sessionFromRow(row) : null;
+    }
+    listSessions() {
+        return this.database.raw
+            .prepare("SELECT s.*, p.model AS model, p.reasoning_effort, p.reasoning_summary, p.service_tier, p.approval_policy_json, p.approvals_reviewer, p.permission_mode, p.token_usage_json, CASE WHEN EXISTS (SELECT 1 FROM agent_items ai JOIN agent_turns at ON at.id=ai.turn_id WHERE at.session_id=s.id AND ai.type='interaction' AND ai.status='waiting' AND json_extract(ai.payload_json,'$.interaction.kind')='approval') THEN 'approval' WHEN EXISTS (SELECT 1 FROM agent_items ai JOIN agent_turns at ON at.id=ai.turn_id WHERE at.session_id=s.id AND ai.type='interaction' AND ai.status='waiting') THEN 'input' ELSE NULL END AS attention_kind, (SELECT COUNT(*) FROM agent_items ai JOIN agent_turns at ON at.id=ai.turn_id WHERE at.session_id=s.id AND ai.type='interaction' AND ai.status='waiting') AS attention_count FROM agent_sessions s LEFT JOIN agent_session_providers p ON p.session_id=s.id AND p.provider=s.provider ORDER BY s.updated_at DESC")
+            .all().map(sessionFromRow);
+    }
+    deleteSession(id) {
+        this.database.raw.prepare("DELETE FROM agent_sessions WHERE id=?").run(id);
+    }
+    getProviderState(sessionId, provider) {
+        const row = this.database.raw
+            .prepare("SELECT * FROM agent_session_providers WHERE session_id=? AND provider=?")
+            .get(sessionId, provider);
+        return row ? providerStateFromRow(row) : null;
+    }
+    upsertProviderState(state) {
+        this.database.raw
+            .prepare("INSERT INTO agent_session_providers(session_id, provider, provider_session_id, model, reasoning_effort, reasoning_summary, service_tier, approval_policy_json, approvals_reviewer, permission_mode, token_usage_json, continuity_context, synced_through_turn_id, created_at, updated_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(session_id, provider) DO UPDATE SET provider_session_id=excluded.provider_session_id, model=excluded.model, reasoning_effort=excluded.reasoning_effort, reasoning_summary=excluded.reasoning_summary, service_tier=excluded.service_tier, approval_policy_json=excluded.approval_policy_json, approvals_reviewer=excluded.approvals_reviewer, permission_mode=excluded.permission_mode, token_usage_json=excluded.token_usage_json, continuity_context=excluded.continuity_context, synced_through_turn_id=excluded.synced_through_turn_id, updated_at=excluded.updated_at")
+            .run(state.sessionId, state.provider, state.providerSessionId, state.model, state.reasoningEffort, state.reasoningSummary, state.serviceTier, state.approvalPolicy === null
+            ? null
+            : JSON.stringify(state.approvalPolicy), state.approvalsReviewer, state.permissionMode, JSON.stringify(state.tokenUsage), state.continuityContext, state.syncedThroughTurnId, state.createdAt, state.updatedAt);
+    }
+    insertTurn(turn) {
+        this.database.raw
+            .prepare("INSERT INTO agent_turns(id, session_id, provider_turn_id, provider, model, reasoning_effort, reasoning_summary, service_tier, approval_policy_json, approvals_reviewer, permission_mode, usage_json, origin, status, error_json, started_at, completed_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+            .run(turn.id, turn.sessionId, turn.providerTurnId, turn.provider, turn.model, turn.reasoningEffort, turn.reasoningSummary, turn.serviceTier, turn.approvalPolicy === null
+            ? null
+            : JSON.stringify(turn.approvalPolicy), turn.approvalsReviewer, turn.permissionMode, JSON.stringify(turn.usage), turnOriginCode(turn.source), turn.status, JSON.stringify(turn.error), turn.startedAt, turn.completedAt);
+    }
+    updateTurn(turn) {
+        this.database.raw
+            .prepare("UPDATE agent_turns SET session_id=?, provider_turn_id=?, provider=?, model=?, reasoning_effort=?, reasoning_summary=?, service_tier=?, approval_policy_json=?, approvals_reviewer=?, permission_mode=?, usage_json=?, origin=?, status=?, error_json=?, started_at=?, completed_at=? WHERE id=?")
+            .run(turn.sessionId, turn.providerTurnId, turn.provider, turn.model, turn.reasoningEffort, turn.reasoningSummary, turn.serviceTier, turn.approvalPolicy === null
+            ? null
+            : JSON.stringify(turn.approvalPolicy), turn.approvalsReviewer, turn.permissionMode, JSON.stringify(turn.usage), turnOriginCode(turn.source), turn.status, JSON.stringify(turn.error), turn.startedAt, turn.completedAt, turn.id);
+    }
+    insertItem(item) {
+        this.database.raw
+            .prepare("INSERT INTO agent_items(id, turn_id, provider_item_id, type, sequence, status, payload_json, created_at, updated_at) VALUES(?,?,?,?,?,?,?,?,?)")
+            .run(item.id, item.turnId, item.providerItemId, item.type, item.sequence, item.status, JSON.stringify(itemPayload(item)), item.createdAt, item.updatedAt);
+    }
+    updateItem(item) {
+        this.database.raw
+            .prepare("UPDATE agent_items SET turn_id=?, provider_item_id=?, type=?, sequence=?, status=?, payload_json=?, created_at=?, updated_at=? WHERE id=?")
+            .run(item.turnId, item.providerItemId, item.type, item.sequence, item.status, JSON.stringify(itemPayload(item)), item.createdAt, item.updatedAt, item.id);
+    }
+    history(sessionId) {
+        const session = this.getSession(sessionId);
+        if (!session)
+            return null;
+        const turns = this.database.raw
+            .prepare("SELECT * FROM agent_turns WHERE session_id=? ORDER BY started_at ASC")
+            .all(sessionId).map(turnFromRow);
+        const items = this.database.raw
+            .prepare("SELECT i.* FROM agent_items i JOIN agent_turns t ON t.id=i.turn_id WHERE t.session_id=? ORDER BY i.sequence ASC")
+            .all(sessionId);
+        const itemsByTurn = new Map();
+        for (const row of items) {
+            const turnItems = itemsByTurn.get(row.turn_id) ?? [];
+            turnItems.push(itemFromRow(row));
+            itemsByTurn.set(row.turn_id, turnItems);
+        }
+        return {
+            session,
+            turns: turns.map((turn) => ({
+                turn,
+                items: itemsByTurn.get(turn.id) ?? [],
+            })),
+        };
+    }
+    historyUpdate(sessionId, turnIds, itemIds) {
+        const session = this.getSession(sessionId);
+        if (!session)
+            return null;
+        const items = selectByIds(this.database, "SELECT i.* FROM agent_items i JOIN agent_turns t ON t.id=i.turn_id WHERE t.session_id=? AND i.id IN", sessionId, itemIds).map(itemFromRow);
+        const turns = selectByIds(this.database, "SELECT * FROM agent_turns WHERE session_id=? AND id IN", sessionId, [...turnIds, ...items.map((item) => item.turnId)]).map(turnFromRow);
+        return { session, turns, items };
+    }
+}
+function selectByIds(database, prefix, sessionId, ids) {
+    const unique = [...new Set(ids)].filter(Boolean);
+    if (!unique.length)
+        return [];
+    const placeholders = unique.map(() => "?").join(",");
+    return database.raw
+        .prepare(prefix + " (" + placeholders + ")")
+        .all(sessionId, ...unique);
+}
+function sessionFromRow(row) {
+    return {
+        id: row.id,
+        workspaceRoot: row.workspace_root,
+        tokenUsage: parseJson(row.token_usage_json),
+        provider: row.provider,
+        model: row.model,
+        reasoningEffort: row.reasoning_effort,
+        reasoningSummary: row.reasoning_summary,
+        serviceTier: row.service_tier,
+        approvalPolicy: parseJson(row.approval_policy_json),
+        approvalsReviewer: row.approvals_reviewer,
+        permissionMode: row.permission_mode,
+        status: row.status,
+        attention: row.attention_kind && row.attention_count > 0
+            ? { kind: row.attention_kind, count: row.attention_count }
+            : null,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function providerStateFromRow(row) {
+    return {
+        sessionId: row.session_id,
+        provider: row.provider,
+        providerSessionId: row.provider_session_id,
+        tokenUsage: parseJson(row.token_usage_json),
+        model: row.model,
+        reasoningEffort: row.reasoning_effort,
+        reasoningSummary: row.reasoning_summary,
+        serviceTier: row.service_tier,
+        approvalPolicy: parseJson(row.approval_policy_json),
+        approvalsReviewer: row.approvals_reviewer,
+        permissionMode: row.permission_mode,
+        continuityContext: row.continuity_context,
+        syncedThroughTurnId: row.synced_through_turn_id,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function turnFromRow(row) {
+    return {
+        id: row.id,
+        sessionId: row.session_id,
+        providerTurnId: row.provider_turn_id,
+        usage: parseJson(row.usage_json),
+        provider: row.provider,
+        model: row.model,
+        reasoningEffort: row.reasoning_effort,
+        reasoningSummary: row.reasoning_summary,
+        serviceTier: row.service_tier,
+        approvalPolicy: parseJson(row.approval_policy_json),
+        approvalsReviewer: row.approvals_reviewer,
+        permissionMode: row.permission_mode,
+        source: turnSourceFromCode(row.origin),
+        status: row.status,
+        error: parseJson(row.error_json),
+        startedAt: row.started_at,
+        completedAt: row.completed_at,
+    };
+}
+function itemPayload(item) {
+    const { id: _id, turnId: _turnId, providerItemId: _providerItemId, type: _type, sequence: _sequence, status: _status, createdAt: _createdAt, updatedAt: _updatedAt, ...payload } = item;
+    return payload;
+}
+function itemFromRow(row) {
+    const payload = parseJson(row.payload_json);
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        throw new Error("Invalid agent item payload: " + row.id);
+    return {
+        id: row.id,
+        turnId: row.turn_id,
+        providerItemId: row.provider_item_id,
+        type: row.type,
+        sequence: row.sequence,
+        status: row.status,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        ...payload,
+    };
+}
+function turnOriginCode(source) {
+    return source === "mcp" ? 1 : 0;
+}
+function turnSourceFromCode(origin) {
+    return origin === 1 ? "mcp" : "human";
+}
+function parseJson(value) {
+    return value === null ? null : JSON.parse(value);
+}
+function monotonicTimestamp(current, candidate) {
+    const currentMs = Date.parse(current);
+    const candidateMs = Date.parse(candidate);
+    const nextMs = Math.max(Number.isFinite(candidateMs) ? candidateMs : Date.now(), Number.isFinite(currentMs) ? currentMs + 1 : 0);
+    return new Date(nextMs).toISOString();
+}

package/dist/plugins/agent/runtime-config.d.ts

@@ -0,0 +1,5 @@
+import type { AgentProviderNativeSetting, AgentReviewTarget, AgentSessionConfig } from "./types.js";
+export declare function emptyAgentSessionConfig(): AgentSessionConfig;
+export declare function copyAgentSessionConfig(config: AgentSessionConfig): AgentSessionConfig;
+export declare function approvalPolicySupported(value: AgentSessionConfig["approvalPolicy"], setting: AgentProviderNativeSetting): boolean;
+export declare function validateReviewTarget(target: AgentReviewTarget): void;