@jini-ai/chat 0.5.3 → 0.5.5

package/dist/server/durable-runs/recover.js

@@ -0,0 +1,147 @@
+import { recoveredRunEvents } from "../../core/index.js";
+import { classifyAgentServiceFailure } from "@jini-ai/agent-runtime";
+import { continuationRequest } from "../../core/durable-runs/continuation.js";
+import { RECOVERY_LIMIT, RECOVERY_WINDOW_MS, RUN_STALENESS_MS, SAVED_WORK_NOTICE, EXHAUSTED_NOTICE } from "../../core/durable-runs/policies.js";
+export { RECOVERY_LIMIT, RECOVERY_WINDOW_MS, RUN_STALENESS_MS, SAVED_WORK_NOTICE, EXHAUSTED_NOTICE } from "../../core/durable-runs/policies.js";
+/** Retryability is independent of session resumability. Inspect executor diagnostics, never
+ * answer text or tool results: those can quote unrelated failures from completed work. Old
+ * attempt diagnostics remain visible but cannot decide the fate of their continuation. */
+function attemptFailure(run) {
+    const events = run.message.events ?? [];
+    // Checkpoints merge adjacent text, so a base's event count is not a durable offset. The
+    // coordinator's recovery marker separates attempts and survives that compaction.
+    let marker = -1;
+    // Reverse scan preserves the last-marker rule on the desktop's ES2022 target.
+    for (let index = run.attemptBase.length ? events.length - 1 : -1; index >= 0; index--) {
+        const event = events[index];
+        if (event.kind === "status" && event.code === "run_recovering") {
+            marker = index;
+            break;
+        }
+    }
+    const diagnostics = events.slice(marker >= 0 ? marker + 1 : run.attemptBase.length).flatMap((event) => event.kind === "status" ? [event.label, event.detail ?? ""] : event.kind === "raw" ? [event.line] : []).join("\n");
+    if (/inactivity[_ -]?(timeout|watchdog)|watchdog.*(kill|stop)/i.test(diagnostics))
+        return "inactivity-watchdog";
+    const service = classifyAgentServiceFailure({ text: diagnostics });
+    if (service === "AGENT_AUTH_REQUIRED")
+        return "auth-failure";
+    // Quota/billing and bad requests need human repair. A 429 for rate throttling and a 5xx
+    // overload remain retryable; the provider's coarse RATE_LIMITED class also includes billing.
+    const requestStatuses = diagnostics.matchAll(/\b(?:http(?:[ /]?\d(?:\.\d)?)?|(?:status|error|response)(?:[ _-]?code)?|code(?=\s*[:=#]))[\s:=#-]*(4\d\d)\b/gi);
+    if ([...requestStatuses].some((match) => match[1] !== "408" && match[1] !== "429"))
+        return "permanent";
+    if (/another answer in this chat is still running|invalid[_ -]?request|context[_ -]?(length|window)|maximum context|model.*(?:not[_ -]found|does not exist|not supported)|unsupported|does not support|permission denied|forbidden|insufficient[_ -]?(quota|balance|credit|funds)|credit balance is too low|exceeded your current quota|quota[_ -]?exceeded|usage limit|billing|payment required/i.test(diagnostics))
+        return "permanent";
+    return "retryable";
+}
+function exclusion(run, failure) {
+    if (run.cancelReason)
+        return run.cancelReason;
+    if (!run.principalId || run.engine !== "daemon")
+        return "excluded";
+    if (failure === "auth-failure" || failure === "inactivity-watchdog")
+        return failure;
+    return null;
+}
+function budgetNotice(run, now) {
+    if (now - run.lastProgressAt >= RUN_STALENESS_MS)
+        return SAVED_WORK_NOTICE;
+    if (run.recoveryCount >= RECOVERY_LIMIT)
+        return EXHAUSTED_NOTICE;
+    if (run.recoveryDeadline !== null && now >= run.recoveryDeadline)
+        return EXHAUSTED_NOTICE;
+    return null;
+}
+/** Recovery coordinator behind explicit host ports. One CAS owns both the attempt and its conversation slot. */
+export function createDurableRecovery(ports, _optional = {}) {
+    async function finalize(run, notice, canceled = false) {
+        await ports.cancelAttempt(run, {}).catch(() => undefined);
+        // Persist the notice as an event: hook errors are live-only and would leave a reloaded
+        // terminal message without its explanation. Only this coordinator decides exhaustion.
+        const events = [...(run.message.events ?? []), { kind: "status", label: notice }];
+        await ports.settle({ ...run, content: run.message.content, events, status: canceled ? "canceled" : "failed", endedAt: ports.now() }, {});
+        return "finalized";
+    }
+    async function nativeAllowed(run) {
+        if (!run.sessionConfirmed || !run.sessionId || !run.child)
+            return false;
+        if (!ports.supportsNativeResume({ agentId: run.request.agentId ?? "claude" }, {}))
+            return false;
+        return ports.verifyChildDead(run.child, {}).catch(() => false);
+    }
+    async function continueDead(run) {
+        await ports.cancelAttempt(run, {}).catch(() => undefined);
+        const native = await nativeAllowed(run);
+        const nextRunId = ports.mintRunId();
+        const saved = [...(run.message.events ?? [])];
+        if (!saved.some((event) => event.kind === "text") && run.message.content)
+            saved.unshift({ kind: "text", text: run.message.content });
+        const events = recoveredRunEvents({ saved }, {});
+        if (!await ports.store.advance({ run, nextRunId, now: ports.now(), events }, {}))
+            return "superseded";
+        const next = await ports.store.load({ messageId: run.messageId }, {});
+        // Cancel/deletion can win while the old attempt is being fenced. Re-read after CAS and do
+        // not launch against a removed binding or a newer generation.
+        if (!next || next.runId !== nextRunId)
+            return "superseded";
+        if (next.cancelReason)
+            return finalize(next, "Stopped. Saved work is above.", true);
+        try {
+            await ports.launch({ run: next, request: continuationRequest({ run: { ...run, message: next.message, transcript: next.transcript }, native }, {}) }, {});
+            await ports.store.recoveryClock({ runId: next.runId, now: ports.now(), active: false }, {});
+        }
+        catch {
+            // A rejected/lost start response is uncertain: the daemon may already be executing. The
+            // same idempotent attempt is probed by the attached watcher before another CAS is possible.
+        }
+        ports.attach(next, {});
+        return "continued";
+    }
+    async function decide(run, trigger, liveRunId) {
+        const failure = attemptFailure(run);
+        const reason = exclusion(run, failure);
+        if (reason)
+            return finalize(run, reason === "auth-failure" ? "Not logged in. Saved work is above." : "Stopped. Saved work is above.", true);
+        // A terminal executor end confirms this attempt is dead even when the daemon retains its
+        // replayable record (HTTP 200). Other triggers must obtain fresh liveness evidence.
+        const probe = trigger === "attempt-failed" ? "dead" : liveRunId === run.runId ? "live" : await ports.probe(run, {});
+        if (probe === "live") {
+            await ports.store.recoveryClock({ runId: run.runId, now: ports.now(), active: false }, {});
+            ports.attach(run, {});
+            return "reattached";
+        }
+        if (failure === "permanent")
+            return finalize(run, EXHAUSTED_NOTICE);
+        return resolveMissing(run, probe, trigger);
+    }
+    async function resolveMissing(run, probe, trigger) {
+        await ports.store.recoveryClock({ runId: run.runId, now: ports.now(), active: true }, {});
+        const timed = await ports.store.load({ messageId: run.messageId }, {}) ?? run;
+        // A probe only speaks about the generation it inspected. Never apply its dead result to
+        // a newer attempt committed by another caller while this one was awaiting storage/HTTP.
+        if (timed.runId !== run.runId)
+            return "superseded";
+        const notice = budgetNotice(timed, ports.now());
+        if (notice)
+            return finalize(run, notice);
+        // A queued attempt may be between durable acceptance and the daemon's start transaction.
+        // Give that idempotent launch time to appear before a 404 can advance its generation.
+        if (probe === "dead" && (trigger === "attempt-failed" || ports.now() - run.attemptStartedAt >= 10_000))
+            return continueDead(timed);
+        ports.attach(run, {});
+        return "waiting";
+    }
+    return {
+        async recover({ messageId, trigger, expectedRunId }, options) {
+            const run = await ports.store.load({ messageId }, {});
+            if (!run)
+                return "gone";
+            if (run.message.runStatus !== "queued" && run.message.runStatus !== "running")
+                return "terminal";
+            if (expectedRunId && expectedRunId !== run.runId)
+                return "superseded";
+            return decide(run, trigger, options.liveRunId);
+        },
+    };
+}
+//# sourceMappingURL=recover.js.map

package/dist/server/run-finalizer/ports.d.ts

@@ -1,19 +1,5 @@
-import type { AgentEvent } from '../../core/events.js';
-import type { ChatRunStatus } from '../../core/messages.js';
-/** Exactly which run owns the row; the host binds authorization and storage scope. */
-export interface RunRef {
-    readonly conversationId: string;
-    readonly messageId: string;
-    readonly runId: string;
-}
-export interface RunProgress extends RunRef {
-    readonly content: string;
-    readonly events: readonly AgentEvent[];
-}
-export interface RunSettlement extends RunProgress {
-    readonly status: Extract<ChatRunStatus, 'succeeded' | 'failed' | 'canceled'>;
-    readonly endedAt: number;
-}
+import type { RunProgress, RunSettlement } from "../../core/durable-runs/run-contracts.js";
+export type { RunRef, RunProgress, RunSettlement } from "../../core/durable-runs/run-contracts.js";
 /** Storage contract only. Both methods must atomically reject a different run or terminal row.
  * First terminal write wins; a late checkpoint cannot reopen or replace that row. */
 export interface RunLedger {

package/dist/store/legacy/sqlite/messages.d.ts

@@ -1,3 +1,4 @@
+import { type SecretRedactionSignal, type UserTextRedactionOptions } from '../../../core/user-text-redaction.js';
 /**
  * @module db/messages/messages
  * Chat message CRUD, streamed-event append, and telemetry finalization. Imports only the
@@ -84,27 +85,13 @@ export declare class MessageConversationMismatchError extends Error {
  * @returns The normalized, re-fetched message row, or null if the row vanished between write and read.
  * @throws {MessageConversationMismatchError} if `m.id` already exists under a different conversation.
  */
-export declare function upsertMessage({ db, conversationId, m }: {
+export declare function upsertMessage({ db, conversationId, m: incoming }: {
     db: SqliteDb;
     conversationId: string;
     m: DbRow;
-}): {
-    id: any;
-    role: any;
-    content: any;
-    agentId: any;
-    agentName: any;
-    runId: any;
-    runStatus: any;
-    lastRunEventId: any;
-    events: any;
-    attachments: any;
-    sessionMode: ChatSessionMode | undefined;
-    runContext: any;
-    createdAt: any;
-    startedAt: any;
-    endedAt: any;
-} | null;
+}, options?: UserTextRedactionOptions): (ReturnType<typeof normalizeMessage> & {
+    secretRedaction?: SecretRedactionSignal;
+}) | null;
 /**
  * Reads whether telemetry has been finalized for a message without loading the full row.
  * Used to decide whether to enqueue a finalization job.
@@ -153,4 +140,23 @@ export declare function deleteMessage({ db, id }: {
     db: SqliteDb;
     id: string;
 }): void;
+/** @internal Converts a raw SQLite row to a plain object with JSON columns parsed and null coerced to undefined. */
+declare function normalizeMessage(row: DbRow): {
+    id: any;
+    role: any;
+    content: any;
+    agentId: any;
+    agentName: any;
+    runId: any;
+    runStatus: any;
+    lastRunEventId: any;
+    events: any;
+    attachments: any;
+    sessionMode: ChatSessionMode | undefined;
+    runContext: any;
+    createdAt: any;
+    startedAt: any;
+    endedAt: any;
+};
+export {};
 //# sourceMappingURL=messages.d.ts.map

package/dist/store/legacy/sqlite/messages.js

@@ -1,3 +1,4 @@
+import { redactUserText } from '../../../core/user-text-redaction.js';
 import { parseJsonOrUndef } from '@jini-ai/db/core';
 /** @internal Column alias list used by both `listMessages` and `upsertMessage`'s re-fetch. */
 const MESSAGE_COLS = `id, role, content, agent_id AS agentId, agent_name AS agentName,
@@ -71,7 +72,11 @@ export class MessageConversationMismatchError extends Error {
  * @returns The normalized, re-fetched message row, or null if the row vanished between write and read.
  * @throws {MessageConversationMismatchError} if `m.id` already exists under a different conversation.
  */
-export function upsertMessage({ db, conversationId, m }) {
+export function upsertMessage({ db, conversationId, m: incoming }, options = {}) {
+    const redaction = incoming.role === 'user' && typeof incoming.content === 'string'
+        ? (options.redactUserText ?? redactUserText)({ text: incoming.content })
+        : null;
+    const m = redaction ? { ...incoming, content: redaction.text } : incoming;
     const runUpsert = db.transaction(() => {
         const existing = db
             .prepare(`SELECT conversation_id AS conversationId, position FROM messages WHERE id = ?`)
@@ -119,7 +124,12 @@ export function upsertMessage({ db, conversationId, m }) {
             .get(m.id, conversationId);
         return row ? normalizeMessage(row) : null;
     });
-    return runUpsert.immediate();
+    const saved = runUpsert.immediate();
+    if (!saved || !redaction?.secretRedacted)
+        return saved;
+    const signal = { secretRedacted: true, count: redaction.count };
+    options.onSecretRedacted?.(signal);
+    return { ...saved, secretRedaction: signal };
 }
 /**
  * Reads whether telemetry has been finalized for a message without loading the full row.

package/dist/store/pglite/index.d.ts

@@ -1,3 +1,4 @@
+import type { UserTextRedactionOptions } from '../../core/user-text-redaction.js';
 /** Pglite transcript adapter. The host owns the opened, migrated kernel and its lifetime. */
 import type { Clock } from '@jini-ai/core/primitives';
 import type { StorageKernel } from '@jini-ai/db/kernel';
@@ -13,7 +14,7 @@ export declare function createPgliteChatStore<DB extends ChatDatabase>(required:
     scope: ChatOwnerScope;
 }, optional?: {
     clock?: Clock;
-}): ChatStore;
+} & UserTextRedactionOptions): ChatStore;
 /** Privileged bounded expiry maintenance; never hand this collaborator to request handlers. */
 export declare function createPgliteChatMaintenance<DB extends ChatDatabase>(required: {
     kernel: StorageKernel<DB>;

package/dist/store/postgres/index.d.ts

@@ -1,3 +1,4 @@
+import type { UserTextRedactionOptions } from '../../core/user-text-redaction.js';
 /** Postgres transcript adapter. The host owns the opened, migrated kernel and its lifetime. */
 import type { Clock } from '@jini-ai/core/primitives';
 import type { StorageKernel } from '@jini-ai/db/kernel';
@@ -13,7 +14,7 @@ export declare function createPostgresChatStore<DB extends ChatDatabase>(require
     scope: ChatOwnerScope;
 }, optional?: {
     clock?: Clock;
-}): ChatStore;
+} & UserTextRedactionOptions): ChatStore;
 /** Privileged bounded expiry maintenance; never hand this collaborator to request handlers. */
 export declare function createPostgresChatMaintenance<DB extends ChatDatabase>(required: {
     kernel: StorageKernel<DB>;

package/dist/store/runtime/chat-expiry-sweep.d.ts

@@ -0,0 +1,40 @@
+import type { ChatHistoryMaintenance } from "../ports.js";
+/**
+ * @file Retention for chat history: deletes every conversation whose `expires_at` has passed.
+ *
+ * This is the one chat operation that legitimately spans owners (`tenant-scope.ts`'s doc), so it
+ * lives here, on the raw chat kernel, and never in a scoped store. Only guest chats carry an
+ * `expires_at` (`chatExpiryFor`); a NULL one never expires. Messages, agent sessions and tool
+ * approvals go with each conversation through `ON DELETE CASCADE`.
+ */
+/** How often {@link startChatExpirySweep} re-runs after its boot pass: hourly. */
+export declare const CHAT_EXPIRY_SWEEP_INTERVAL_MS: number;
+/**
+ * Deletes every conversation that expired at or before `now`.
+ *
+ * @param store the chat kernel, or the open `chat.db` handle whose kernel to use.
+ * @returns how many conversations were deleted.
+ * @complexity One bounded DELETE per 500 expired parents, plus the final partial/empty batch.
+ */
+export declare function sweepExpiredChats({ maintenance }: {
+    maintenance: ChatHistoryMaintenance;
+}, { now }?: {
+    now?: number;
+}): Promise<number>;
+/**
+ * Runs {@link sweepExpiredChats} once now and then every `intervalMs`, until the returned stop
+ * function is called. The timer is `unref`'d so it never keeps the process alive. A failed pass is
+ * reported through `onError` and the next pass still runs. A tick that fires while a pass is still
+ * running is skipped, so passes never overlap.
+ *
+ * @returns `stop`: clears the timer and resolves once the pass in flight (if any) has finished, so
+ *   the store can be closed right after it. Safe to call more than once.
+ */
+export declare function startChatExpirySweep({ maintenance }: {
+    maintenance: ChatHistoryMaintenance;
+}, options?: {
+    readonly intervalMs?: number;
+    readonly now?: () => number;
+    readonly onError?: (error: unknown) => void;
+}): () => Promise<void>;
+//# sourceMappingURL=chat-expiry-sweep.d.ts.map

package/dist/store/runtime/chat-expiry-sweep.js

@@ -0,0 +1,70 @@
+import { ChatStoreError } from "../errors.js";
+/**
+ * @file Retention for chat history: deletes every conversation whose `expires_at` has passed.
+ *
+ * This is the one chat operation that legitimately spans owners (`tenant-scope.ts`'s doc), so it
+ * lives here, on the raw chat kernel, and never in a scoped store. Only guest chats carry an
+ * `expires_at` (`chatExpiryFor`); a NULL one never expires. Messages, agent sessions and tool
+ * approvals go with each conversation through `ON DELETE CASCADE`.
+ */
+/** How often {@link startChatExpirySweep} re-runs after its boot pass: hourly. */
+export const CHAT_EXPIRY_SWEEP_INTERVAL_MS = 60 * 60 * 1000;
+/**
+ * Deletes every conversation that expired at or before `now`.
+ *
+ * @param store the chat kernel, or the open `chat.db` handle whose kernel to use.
+ * @returns how many conversations were deleted.
+ * @complexity One bounded DELETE per 500 expired parents, plus the final partial/empty batch.
+ */
+export async function sweepExpiredChats({ maintenance }, { now = Date.now() } = {}) {
+    let total = 0;
+    let deleted;
+    try {
+        do {
+            deleted = await maintenance.sweepExpired({ now }, { limit: 500 });
+            total += deleted;
+        } while (deleted === 500);
+    }
+    catch (error) {
+        // Preserve the host timer's existing onError collaborator and retry behavior.
+        if (error instanceof ChatStoreError && error.cause !== undefined)
+            throw error.cause;
+        throw error;
+    }
+    return total;
+}
+/**
+ * Runs {@link sweepExpiredChats} once now and then every `intervalMs`, until the returned stop
+ * function is called. The timer is `unref`'d so it never keeps the process alive. A failed pass is
+ * reported through `onError` and the next pass still runs. A tick that fires while a pass is still
+ * running is skipped, so passes never overlap.
+ *
+ * @returns `stop`: clears the timer and resolves once the pass in flight (if any) has finished, so
+ *   the store can be closed right after it. Safe to call more than once.
+ */
+export function startChatExpirySweep({ maintenance }, options = {}) {
+    const { intervalMs = CHAT_EXPIRY_SWEEP_INTERVAL_MS, now = Date.now } = options;
+    const onError = options.onError ??
+        ((error) => {
+            // eslint-disable-next-line no-console
+            console.warn(`[chat-expiry-sweep] sweep failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    let active;
+    const pass = () => {
+        if (active !== undefined)
+            return;
+        active = sweepExpiredChats({ maintenance }, { now: now() })
+            .then(() => undefined, onError)
+            .finally(() => {
+            active = undefined;
+        });
+    };
+    pass();
+    const timer = setInterval(pass, intervalMs);
+    timer.unref();
+    return async () => {
+        clearInterval(timer);
+        await active;
+    };
+}
+//# sourceMappingURL=chat-expiry-sweep.js.map

package/dist/store/runtime/chat-history-store.d.ts

@@ -0,0 +1,20 @@
+import type { RunIdPolicy } from "../../core/durable-runs/ports.js";
+import type { ChatOwnerScope, ChatStore } from "../ports.js";
+import type { ChatDatabase, ChatKernel } from "./kernel.js";
+/**
+ * Host compatibility factory over Jini's owner-scoped transcript adapters (PLAN C3).
+ * Borrows the exact migrated kernel: the adapter's append joins the host's run-ledger transaction.
+ * The host retains principal hashing, migrations and connection lifetime.
+ * @param kernel The already-open chat kernel; never wrap or open a second connection here.
+ * @param scope The authenticated owner tuple; guest ownerId is already hashed by tenant-scope.
+ * @param now Injectable epoch-millisecond clock.
+ * @returns Full ChatStore, also assignable to existing eight-method ChatHistoryStore consumers.
+ */
+export declare function createChatHistoryStore<DB extends ChatDatabase>({ kernel: hostKernel, scope, isDaemonRunId }: {
+    kernel: ChatKernel<DB>;
+    scope: ChatOwnerScope;
+    isDaemonRunId: RunIdPolicy;
+}, { now }?: {
+    now?: () => number;
+}): ChatStore;
+//# sourceMappingURL=chat-history-store.d.ts.map

package/dist/store/runtime/chat-history-store.js

@@ -0,0 +1,50 @@
+import { createSqliteChatStore } from "../sqlite/index.js";
+// Owner isolation versus legacy project-only storage: packages/chat/src/store/sqlite/index.ts.
+import { createPgliteChatStore } from "../pglite/index.js";
+import { createPostgresChatStore } from "../postgres/index.js";
+import { chatKernelTables } from "../sql/boundary.js";
+function repairLegacyTurnOrder({ messages, isDaemonRunId }, _optional = {}) {
+    const ordered = [];
+    for (let index = 0; index < messages.length; index++) {
+        const answer = messages[index];
+        const question = messages[index + 1];
+        // Legacy acceptance saved no question ID. Repair only an orphan daemon answer immediately
+        // followed by an earlier/equal-clock user row; a preceding question already owns its answer.
+        // A global timestamp sort would reorder valid follow-ups when browser/server clocks disagree.
+        if (ordered.at(-1)?.role !== "user" && answer.role === "assistant" && answer.runId && isDaemonRunId({ runId: answer.runId })
+            && question?.role === "user" && question.createdAt !== undefined && answer.createdAt !== undefined
+            && question.createdAt <= answer.createdAt) {
+            ordered.push(question, answer);
+            index++;
+        }
+        else
+            ordered.push(answer);
+    }
+    return ordered;
+}
+// Transcript-isolation rationale: Jini packages/chat/src/store/sql/store.ts.
+/**
+ * Host compatibility factory over Jini's owner-scoped transcript adapters (PLAN C3).
+ * Borrows the exact migrated kernel: the adapter's append joins the host's run-ledger transaction.
+ * The host retains principal hashing, migrations and connection lifetime.
+ * @param kernel The already-open chat kernel; never wrap or open a second connection here.
+ * @param scope The authenticated owner tuple; guest ownerId is already hashed by tenant-scope.
+ * @param now Injectable epoch-millisecond clock.
+ * @returns Full ChatStore, also assignable to existing eight-method ChatHistoryStore consumers.
+ */
+export function createChatHistoryStore({ kernel: hostKernel, scope, isDaemonRunId }, { now = Date.now } = {}) {
+    const kernel = chatKernelTables({ kernel: hostKernel }, {});
+    const required = { kernel, scope };
+    const optional = { clock: { nowMs: now } };
+    const store = kernel.transport === "better-sqlite3" ? createSqliteChatStore(required, optional)
+        : kernel.transport === "pglite" || kernel.transport === "pglite-socket" ? createPgliteChatStore(required, optional)
+            : createPostgresChatStore(required, optional);
+    return { ...store,
+        // Admin reload and recovery use this full-transcript compatibility read. Preserve stored
+        // positions (and Jini's position-based page cursors); existing user databases need no migration.
+        async messages(required, optional = {}) {
+            return repairLegacyTurnOrder({ messages: await store.messages(required, optional), isDaemonRunId }, {});
+        },
+    };
+}
+//# sourceMappingURL=chat-history-store.js.map

package/dist/store/runtime/durable-run-store.d.ts

@@ -0,0 +1,21 @@
+import type { RunIdPolicy } from "../../core/durable-runs/ports.js";
+import { type AgentEvent } from "../../core/index.js";
+import type { ChatKernel, ChatDatabase } from "./kernel.js";
+import type { DurableRun, DurableRunStore } from "../../core/durable-runs/ports.js";
+export declare const RUN_SLOT_BUSY = "Another answer in this chat is still running. This turn is queued in your browser.";
+export declare class RunSlotBusyError extends Error {
+    constructor();
+}
+export declare function attemptCanExecute({ run }: {
+    run: DurableRun | null;
+}, _optional?: {}): boolean;
+export declare function savedRunEvents({ json }: {
+    json: string | null;
+}, _optional?: {}): AgentEvent[];
+/** Same kernel and message lock as checkpoint/settle. Claim changes run_id before any spawn;
+ * old attempts cannot write projections or dispatch tools after that transaction commits. */
+export declare function createDurableRunStore<DB extends ChatDatabase>({ kernel: hostKernel, isDaemonRunId }: {
+    kernel: ChatKernel<DB>;
+    isDaemonRunId: RunIdPolicy;
+}, _optional?: {}): DurableRunStore;
+//# sourceMappingURL=durable-run-store.d.ts.map