@jini-ai/chat 0.5.3 → 0.5.5

package/dist/store/runtime/run-ledger.js

@@ -0,0 +1,206 @@
+import { chatKernelTables } from "../sql/boundary.js";
+import { createDurableRunStore } from "./durable-run-store.js";
+/**
+ * @file The run-status half of chat history: the writes that decide how an assistant turn ENDS.
+ *
+ * Purpose:
+ * The browser formerly competed with the finalizer to finish daemon rows. Daemon acceptance
+ * and recovery now own those rows, while request-bound BYOK/AG-UI keep their browser writes.
+ * For one attempt the first terminal write wins; subsequent checkpoints or settlements are
+ * ignored. Continuation changes the attempt id by CAS while retaining the logical message;
+ * an older attempt cannot write afterward. Terminal rows remain absorbing during recovery.
+ *
+ * How it stays race-free with async storage: every "is it settled?" check and the write it guards
+ * run in ONE kernel transaction holding the run's lock ({@link runLockKey}), and {@link
+ * ChatRunLedger.settle} takes the same lock. On SQLite that is `BEGIN IMMEDIATE` (the write lock);
+ * on Postgres a transaction-scoped advisory lock, since a plain transaction does not serialize there.
+ *
+ * Architectural role:
+ * ONE Kysely body over the chat kernel (`platform/db/chat-kernel.ts`), for every dialect. Nothing
+ * here exposes history to request handlers; the cross-owner boot operation
+ * ({@link ChatRunLedger.reconcileInterrupted}) supplies a recovery port with the persisted owner
+ * and run stub. The recovery coordinator decides whether to reattach, continue or finalize;
+ * rows it cannot adopt receive an atomic cancellation fallback rather than spinning forever.
+ */
+const TERMINAL_STATUSES = ["succeeded", "failed", "canceled"];
+import { runLockKey } from "../../core/durable-runs/run-lock.js";
+export { runLockKey } from "../../core/durable-runs/run-lock.js";
+function isTerminal(status) {
+    return typeof status === "string" && TERMINAL_STATUSES.includes(status);
+}
+/** `run_status` is not terminal (NULL counts as not terminal). */
+const notTerminal = (eb) => eb.or([eb("run_status", "is", null), eb("run_status", "not in", TERMINAL_STATUSES)]);
+/** The assistant row of exactly this run. */
+const isRunRow = (eb, run) => eb.and([
+    eb("id", "=", run.messageId),
+    eb("conversation_id", "=", run.conversationId),
+    eb("run_id", "=", run.runId),
+    eb("role", "=", "assistant"),
+]);
+function readEvents(eventsJson) {
+    let events = [];
+    try {
+        events = eventsJson ? JSON.parse(eventsJson) : [];
+    }
+    catch {
+        events = [];
+    }
+    return Array.isArray(events) ? events : [];
+}
+function hasNewToolProgress(current, next) {
+    const key = (event) => event.kind === "tool_use" ? `use:${event.id}` : event.kind === "tool_result" ? `result:${event.toolUseId}` : "";
+    const saved = new Set(current.map(key));
+    return next.some((event) => { const id = key(event); return id !== "" && !saved.has(id); });
+}
+function retainSavedEvents(saved, incoming) {
+    const keys = new Set(saved.map((event) => JSON.stringify(event)));
+    const additions = incoming.filter((event) => event.kind !== "text" && !keys.has(JSON.stringify(event)));
+    return [...saved, ...additions];
+}
+function keepToolCheckpoints(saved, incoming) {
+    const key = (event) => event.kind === "tool_use" ? `use:${event.id}` : event.kind === "tool_result" ? `result:${event.toolUseId}` : "";
+    const seen = new Set(incoming.map(key));
+    return [...incoming, ...saved.filter((event) => { const id = key(event); return id !== "" && !seen.has(id); })];
+}
+/**
+ * @param store the chat kernel, or the open `chat.db` handle `createChatStoreFactory` also wraps.
+ * @complexity each method is one or two indexed statements, except `reconcileInterrupted`, which
+ *   is O(stuck rows).
+ */
+export function createChatRunLedger({ kernel: hostKernel, isDaemonRunId }, _optional = {}) {
+    const kernel = chatKernelTables({ kernel: hostKernel }, {});
+    async function isSettled(run) {
+        const row = await kernel.run((db) => db
+            .selectFrom("ai_chat_messages")
+            .select("run_status")
+            .where("id", "=", run.messageId)
+            .where("conversation_id", "=", run.conversationId)
+            .where("run_id", "=", run.runId)
+            .executeTakeFirst());
+        return isTerminal(row?.run_status);
+    }
+    return {
+        durable: createDurableRunStore({ kernel, isDaemonRunId }, {}),
+        unlessSettled({ run, write }, _optional = {}) {
+            return kernel.transaction(async () => {
+                await kernel.lockKey(runLockKey(run));
+                if (await isSettled(run))
+                    return { written: false };
+                return { written: true, value: await write() };
+            });
+        },
+        settle(settlement, _optional = {}) {
+            return kernel.transaction(async () => {
+                await kernel.lockKey(runLockKey(settlement));
+                const saved = await kernel.run((db) => db.selectFrom("ai_chat_messages").select(["content", "events_json"])
+                    .where((eb) => eb.and([isRunRow(eb, settlement), notTerminal(eb)])).executeTakeFirst());
+                if (!saved)
+                    return false;
+                const content = settlement.content.length >= saved.content.length ? settlement.content : saved.content;
+                let events = keepToolCheckpoints(readEvents(saved.events_json), settlement.events);
+                if (content !== settlement.content) {
+                    events = retainSavedEvents(readEvents(saved.events_json), settlement.events);
+                    if (!events.some((event) => event.kind === "text"))
+                        events.unshift({ kind: "text", text: saved.content });
+                }
+                const result = await kernel.run((db) => db
+                    .updateTable("ai_chat_messages")
+                    .set({
+                    content,
+                    events_json: JSON.stringify(events),
+                    run_status: settlement.status,
+                    ended_at: settlement.endedAt,
+                })
+                    .where((eb) => eb.and([isRunRow(eb, settlement), notTerminal(eb)]))
+                    .executeTakeFirst());
+                if (Number(result.numUpdatedRows) === 0)
+                    return false;
+                await kernel.run((db) => db
+                    .updateTable("ai_chats")
+                    .set({ updated_at: settlement.endedAt })
+                    .where("id", "=", settlement.conversationId)
+                    .execute());
+                return true;
+            });
+        },
+        async checkpoint(progress, _optional = {}) {
+            return kernel.transaction(async () => {
+                await kernel.lockKey(runLockKey(progress));
+                const current = await kernel.run((db) => db.selectFrom("ai_chat_messages").select(["content", "events_json"])
+                    .where((eb) => eb.and([isRunRow(eb, progress), notTerminal(eb)])).executeTakeFirst());
+                if (!current || progress.content.length < current.content.length)
+                    return false;
+                const events = keepToolCheckpoints(readEvents(current.events_json), progress.events);
+                const grown = progress.content.length > current.content.length || hasNewToolProgress(readEvents(current.events_json), events);
+                const result = await kernel.run((db) => db
+                    .updateTable("ai_chat_messages")
+                    .set({ content: progress.content, events_json: JSON.stringify(events) })
+                    .where((eb) => eb.and([isRunRow(eb, progress), notTerminal(eb)]))
+                    .executeTakeFirst());
+                if (Number(result.numUpdatedRows) > 0 && grown) {
+                    // Progress earns a fresh recovery budget. Replayed prefixes and the coordinator's
+                    // divider are not progress and cannot keep a repeatedly failing attempt alive forever.
+                    await kernel.run((db) => db.updateTable("assistant_run_attempts")
+                        .set({ recovery_count: 0, recovery_deadline: null, recovery_elapsed_ms: 0, last_progress_at: Date.now() })
+                        .where("message_id", "=", progress.messageId).execute());
+                }
+                return Number(result.numUpdatedRows) > 0;
+            });
+        },
+        async reconcileInterrupted(required = {}, optional = {}) {
+            const stuck = await kernel.run((db) => db
+                .selectFrom("ai_chat_messages")
+                .innerJoin("ai_chats", "ai_chats.id", "ai_chat_messages.conversation_id")
+                .select(["ai_chat_messages.id", "conversation_id", "run_id", "run_status", "content", "events_json", "owner_kind", "owner_id"])
+                .where("ai_chat_messages.role", "=", "assistant")
+                .where("ai_chat_messages.run_status", "in", ["queued", "running"])
+                .orderBy("ai_chat_messages.id")
+                .execute());
+            let count = 0;
+            for (const row of stuck) {
+                const dispatched = await optional.recover?.({
+                    principalId: row.owner_kind === "user" ? row.owner_id : null,
+                    conversationId: row.conversation_id,
+                    message: {
+                        id: row.id, role: "assistant", content: row.content, events: readEvents(row.events_json),
+                        ...(row.run_id ? { runId: row.run_id } : {}),
+                        runStatus: row.run_status,
+                    },
+                });
+                if (dispatched) {
+                    count += 1;
+                    continue;
+                }
+                // A legacy stub without an attempt id, or a host without durable recovery, cannot ever
+                // be adopted. Preserve the latest checkpoint under the same lock as settle: discovery's
+                // snapshot may be old, and acceptance/recovery may have replaced its run id meanwhile.
+                const canceled = await kernel.transaction(async () => {
+                    await kernel.lockKey(runLockKey({ conversationId: row.conversation_id, messageId: row.id, runId: row.run_id ?? "" }));
+                    const matches = (eb) => eb.and([
+                        eb("id", "=", row.id), eb("conversation_id", "=", row.conversation_id), eb("role", "=", "assistant"),
+                        row.run_id === null ? eb("run_id", "is", null) : eb("run_id", "=", row.run_id),
+                        notTerminal(eb),
+                    ]);
+                    const current = await kernel.run((db) => db.selectFrom("ai_chat_messages").select("events_json")
+                        .where(matches).executeTakeFirst());
+                    if (!current)
+                        return false;
+                    const endedAt = required.now ?? Date.now();
+                    const events = [...readEvents(current.events_json), { kind: "status", label: "Stopped. Saved work is above." }];
+                    const result = await kernel.run((db) => db.updateTable("ai_chat_messages")
+                        .set({ run_status: "canceled", ended_at: endedAt, events_json: JSON.stringify(events) })
+                        .where(matches).executeTakeFirst());
+                    if (Number(result.numUpdatedRows) === 0)
+                        return false;
+                    await kernel.run((db) => db.updateTable("ai_chats").set({ updated_at: endedAt })
+                        .where("id", "=", row.conversation_id).execute());
+                    return true;
+                });
+                if (canceled)
+                    count += 1;
+            }
+            return count;
+        },
+    };
+}
+//# sourceMappingURL=run-ledger.js.map

package/dist/store/sql/boundary.d.ts

@@ -20,7 +20,13 @@ export declare function atStoreBoundary<T>({ operation }: {
 /** The single audited table-subset projection. Required table types are proven by DB's bound;
  * host extra tables and all transaction/locking effects stay on the original kernel object.
  * Kysely's invariant DB parameter requires this one erasure; it never bridges driver/version copies.
+ * @returns The original kernel with only the required table types exposed.
+ * @complexity O(1) time and space; no wrapper, connection or transaction is created.
  */
+export declare function chatKernelTables<DB extends Tables, Tables extends ChatDatabase = ChatDatabase>({ kernel }: {
+    kernel: StorageKernel<DB>;
+}, _optional?: {}): StorageKernel<Tables>;
+/** Execute a transcript query through the shared table-subset projection. */
 export declare function runChatQuery<DB extends ChatDatabase, T>({ kernel, body }: {
     kernel: StorageKernel<DB>;
     body: (db: Kysely<ChatDatabase>) => T | Promise<T>;

package/dist/store/sql/boundary.js

@@ -25,8 +25,14 @@ export async function atStoreBoundary({ operation }) {
 /** The single audited table-subset projection. Required table types are proven by DB's bound;
  * host extra tables and all transaction/locking effects stay on the original kernel object.
  * Kysely's invariant DB parameter requires this one erasure; it never bridges driver/version copies.
+ * @returns The original kernel with only the required table types exposed.
+ * @complexity O(1) time and space; no wrapper, connection or transaction is created.
  */
+export function chatKernelTables({ kernel }, _optional = {}) {
+    return kernel;
+}
+/** Execute a transcript query through the shared table-subset projection. */
 export function runChatQuery({ kernel, body }) {
-    return kernel.run(db => body(db));
+    return chatKernelTables({ kernel }, {}).run(body);
 }
 //# sourceMappingURL=boundary.js.map

package/dist/store/sql/store.d.ts

@@ -1,5 +1,6 @@
 import { type Clock } from '@jini-ai/core/primitives';
 import { type StorageKernel } from '@jini-ai/db/kernel';
+import { type UserTextRedactionOptions } from '../../core/user-text-redaction.js';
 import type { ChatStore, ChatOwnerScope } from '../ports.js';
 import type { ChatDatabase } from './tables.js';
 /**
@@ -16,7 +17,7 @@ import type { ChatDatabase } from './tables.js';
 export declare function createSqlChatStore<DB extends ChatDatabase>({ kernel, scope: inputScope }: {
     kernel: StorageKernel<DB>;
     scope: ChatOwnerScope;
-}, { clock }?: {
+}, { clock, ...redactionOptions }?: {
     clock?: Clock;
-}): ChatStore;
+} & UserTextRedactionOptions): ChatStore;
 //# sourceMappingURL=store.d.ts.map

package/dist/store/sql/store.js

@@ -12,6 +12,7 @@
 import { sql } from 'kysely';
 import { createSystemClock } from '@jini-ai/core/primitives';
 import { isUniqueViolation } from '@jini-ai/db/kernel';
+import { redactUserMessage } from '../../core/user-text-redaction.js';
 import { ChatStoreError } from '../errors.js';
 import { copyScope, atStoreBoundary, runChatQuery } from './boundary.js';
 import { pageLimit, decodeCursor, encodeCursor } from './cursor.js';
@@ -80,7 +81,7 @@ function toMessage(row) {
  * @complexity each method is one to four indexed statements; `list` is O(owned conversations),
  *   `messages` O(messages in the conversation).
  */
-export function createSqlChatStore({ kernel, scope: inputScope }, { clock = createSystemClock() } = {}) {
+export function createSqlChatStore({ kernel, scope: inputScope }, { clock = createSystemClock(), ...redactionOptions } = {}) {
     const scope = copyScope({ scope: inputScope });
     const { scopeId, ownerKind, ownerId } = scope;
     // The single subset boundary: DB must contain both required table definitions. Extra host tables
@@ -283,7 +284,13 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
         },
         messages,
         async appendMessage({ conversationId, message }, _optional = {}) {
-            return writeMessage(conversationId, message);
+            const prepared = redactUserMessage({ message }, { ...(redactionOptions.redactUserText ? { redactUserText: redactionOptions.redactUserText } : {}) });
+            const saved = await writeMessage(conversationId, prepared.message);
+            if (!saved || !prepared.secretRedacted)
+                return saved;
+            const signal = { secretRedacted: true, count: prepared.count };
+            redactionOptions.onSecretRedacted?.(signal);
+            return { ...saved, secretRedaction: signal };
         },
         async pageConversations(_required, options = {}) {
             const limit = pageLimit({ options: options });

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

@@ -1,3 +1,4 @@
+import type { UserTextRedactionOptions } from '../../core/user-text-redaction.js';
 /** Sqlite 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 createSqliteChatStore<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 createSqliteChatMaintenance<DB extends ChatDatabase>(required: {
     kernel: StorageKernel<DB>;
@@ -28,7 +29,7 @@ export declare function createChatHistoryStore({ db, scope }: {
     scope: ChatOwnerScope;
 }, optional?: {
     clock?: Clock;
-}): ChatStore;
+} & UserTextRedactionOptions): ChatStore;
 /** Compatibility retention wrapper; the caller still owns the handle and its configuration. */
 export declare function createChatHistoryMaintenance({ db }: {
     db: SqliteConnectionSource;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/chat",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Jini's chat/artifact frontend, consolidated into one package with two subpaths: framework-free chat vocabulary and pure parsers in `/core`, headless hooks + presentational components + slots in `/react`. Import only the layer you need.",
   "license": "Apache-2.0",
   "repository": {
@@ -29,12 +29,23 @@
       "./server/run-finalizer": "universal",
       "./react/embed": "browser",
       "./transports/fetch-sse": "universal",
+      "./transports/http": "universal",
+      "./transports/ag-ui": "universal",
       "./browser/session-store": "browser",
-      "./browser/page-actions": "browser"
+      "./browser/page-actions": "browser",
+      "./server/durable-runs": "node",
+      "./store/runtime": "node"
     },
     "neutralEntries": [
       "src/store/contracts"
-    ]
+    ],
+    "isolation": {
+      "entries": {
+        "./browser/page-actions": "core",
+        "./transports/http": "core",
+        "./transports/ag-ui": "core"
+      }
+    }
   },
   "type": "module",
   "sideEffects": [
@@ -110,6 +121,16 @@
       "import": "./dist/embed-widget/react/embed.js",
       "default": "./dist/embed-widget/react/embed.js"
     },
+    "./transports/ag-ui": {
+      "types": "./dist/core/assistant-client/ag-ui-transport.d.ts",
+      "import": "./dist/core/assistant-client/ag-ui-transport.js",
+      "default": "./dist/core/assistant-client/ag-ui-transport.js"
+    },
+    "./transports/http": {
+      "types": "./dist/core/assistant-client/entry.d.ts",
+      "import": "./dist/core/assistant-client/entry.js",
+      "default": "./dist/core/assistant-client/entry.js"
+    },
     "./transports/fetch-sse": {
       "types": "./dist/embed-widget/transports/fetch-sse.d.ts",
       "import": "./dist/embed-widget/transports/fetch-sse.js",
@@ -124,6 +145,16 @@
       "types": "./dist/embed-widget/browser/page-actions.d.ts",
       "import": "./dist/embed-widget/browser/page-actions.js",
       "default": "./dist/embed-widget/browser/page-actions.js"
+    },
+    "./server/durable-runs": {
+      "types": "./dist/server/durable-runs/entry.d.ts",
+      "import": "./dist/server/durable-runs/entry.js",
+      "default": "./dist/server/durable-runs/entry.js"
+    },
+    "./store/runtime": {
+      "types": "./dist/store/runtime/entry.d.ts",
+      "import": "./dist/store/runtime/entry.js",
+      "default": "./dist/store/runtime/entry.js"
     }
   },
   "files": [
@@ -145,10 +176,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@jini-ai/agentic": "^0.4.2",
-    "@jini-ai/ui": "^0.4.4",
-    "@jini-ai/protocol": "^0.4.0",
-    "@jini-ai/core": "^0.4.1"
+    "@jini-ai/core": "^0.4.2"
   },
   "peerDependencies": {
     "react": "^18.3.0 || ^19.0.0",
@@ -165,7 +193,12 @@
     "@radix-ui/react-radio-group": "^1.4.7",
     "@radix-ui/react-select": "^2.3.7",
     "@radix-ui/react-slot": "^1.3.3",
-    "recharts": "^3.10.1"
+    "recharts": "^3.10.1",
+    "@jini-ai/agent-runtime": "^0.4.1",
+    "@jini-ai/agentic": "^0.4.2",
+    "@jini-ai/protocol": "^0.4.1",
+    "@jini-ai/ui": "^0.4.5",
+    "@jini-ai/diagnostics": "^0.5.0"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -212,6 +245,21 @@
     },
     "recharts": {
       "optional": true
+    },
+    "@jini-ai/agent-runtime": {
+      "optional": true
+    },
+    "@jini-ai/agentic": {
+      "optional": true
+    },
+    "@jini-ai/protocol": {
+      "optional": true
+    },
+    "@jini-ai/ui": {
+      "optional": true
+    },
+    "@jini-ai/diagnostics": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -238,8 +286,13 @@
     "@electric-sql/pglite": "0.5.8",
     "pg": "8.23.0",
     "@ag-ui/core": "0.0.58",
-    "@jini-ai/db": "0.3.0",
-    "@jini-ai/agent-runtime": "0.4.0"
+    "@jini-ai/db": "0.3.1",
+    "@jini-ai/agent-runtime": "0.4.2",
+    "@jini-ai/agentic": "^0.4.3",
+    "@jini-ai/ui": "^0.4.5",
+    "@jini-ai/protocol": "^0.4.2",
+    "@jini-ai/core": "^0.4.2",
+    "@jini-ai/diagnostics": "^0.5.1"
   },
   "typesVersions": {
     "*": {
@@ -276,6 +329,12 @@
       "react/embed": [
         "./dist/embed-widget/react/embed.d.ts"
       ],
+      "transports/ag-ui": [
+        "./dist/core/assistant-client/ag-ui-transport.d.ts"
+      ],
+      "transports/http": [
+        "./dist/core/assistant-client/entry.d.ts"
+      ],
       "transports/fetch-sse": [
         "./dist/embed-widget/transports/fetch-sse.d.ts"
       ],
@@ -284,6 +343,12 @@
       ],
       "browser/page-actions": [
         "./dist/embed-widget/browser/page-actions.d.ts"
+      ],
+      "server/durable-runs": [
+        "./dist/server/durable-runs/entry.d.ts"
+      ],
+      "store/runtime": [
+        "./dist/store/runtime/entry.d.ts"
       ]
     }
   },