@jini-ai/chat 0.5.6 → 0.5.8

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

@@ -6,7 +6,7 @@ export { RECOVERY_LIMIT, RECOVERY_WINDOW_MS, RUN_STALENESS_MS, SAVED_WORK_NOTICE
 /** 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) {
+function attemptDiagnostics({ run }, _optional = {}) {
     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.
@@ -19,7 +19,10 @@ function attemptFailure(run) {
             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");
+    return 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");
+}
+function attemptFailure(run) {
+    const diagnostics = attemptDiagnostics({ run }, {});
     if (/inactivity[_ -]?(timeout|watchdog)|watchdog.*(kill|stop)/i.test(diagnostics))
         return "inactivity-watchdog";
     const service = classifyAgentServiceFailure({ text: diagnostics });
@@ -34,13 +37,11 @@ function attemptFailure(run) {
         return "permanent";
     return "retryable";
 }
-function exclusion(run, failure) {
+function exclusion(run) {
     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) {
@@ -71,12 +72,15 @@ export function createDurableRecovery(ports, _optional = {}) {
     }
     async function continueDead(run) {
         await ports.cancelAttempt(run, {}).catch(() => undefined);
-        const native = await nativeAllowed(run);
+        // A locator captured before a hard cancel can outlive its rollout. Reuse reconstruction,
+        // including prior turns/tool outcomes, instead of retrying a known missing native session.
+        const missingResume = run.request.agentId === 'codex' && /no rollout found for thread id/.test(attemptDiagnostics({ run }, {}));
+        const native = !missingResume && 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 }, {});
+        const events = recoveredRunEvents({ saved }, { notice: missingResume ? 'silent' : 'visible' });
         if (!await ports.store.advance({ run, nextRunId, now: ports.now(), events }, {}))
             return "superseded";
         const next = await ports.store.load({ messageId: run.messageId }, {});
@@ -98,10 +102,8 @@ export function createDurableRecovery(ports, _optional = {}) {
         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);
+        if (exclusion(run))
+            return finalize(run, "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, {});
@@ -110,6 +112,12 @@ export function createDurableRecovery(ports, _optional = {}) {
             ports.attach(run, {});
             return "reattached";
         }
+        // Diagnostics decide only the fate of an attempt that is no longer running. Read before the
+        // probe, raw stdout quoting a tool description ("OAuth-authenticated") canceled a live turn
+        // as "Not logged in" (luvira, 2026-10-08).
+        const failure = attemptFailure(run);
+        if (failure === "auth-failure" || failure === "inactivity-watchdog")
+            return finalize(run, failure === "auth-failure" ? "Not logged in. Saved work is above." : "Stopped. Saved work is above.", true);
         if (failure === "permanent")
             return finalize(run, EXHAUSTED_NOTICE);
         return resolveMissing(run, probe, trigger);

package/dist/server/run-finalizer/entry.js

@@ -86,8 +86,9 @@ export function createAssistantRunFinalizer(args, options = {}) {
         // Each connection replays the complete history, rather than appending duplicate deltas.
         watch.events = [];
         watch.failed = false;
+        const carry = {};
         for await (const frame of readSseFrames({ body: response.body })) {
-            const outcome = translateRunFrame({ kind: frame.event, raw: frame.data, notices: args.notices });
+            const outcome = translateRunFrame({ kind: frame.event, raw: frame.data, notices: args.notices }, { carry });
             watch.events.push(...outcome.events);
             if (outcome.error)
                 watch.failed = true;

package/dist/store/ports.d.ts

@@ -63,6 +63,8 @@ export interface ChatSearchCapability {
  * @example store.rename({ id, title }, { source: 'generated' }); store.pageConversations({}, { limit: 50 })
  */
 export interface ChatStore {
+    /** Bounded history discovery/read capability; always uses this store's immutable owner scope. */
+    readonly history?: ChatHistoryReader;
     /** Compatibility read: all owned conversations, updatedAt descending. */
     list(): Promise<ChatConversation[]>;
     /** Unknown and other-owned IDs both return null. */
@@ -97,8 +99,29 @@ export interface ChatStore {
     pageMessages(input: ChatMessagePageInput, options?: ChatPageOptions): Promise<ChatPage<ChatMessage>>;
     readonly search?: ChatSearchCapability;
 }
-/** Eight-method subset for hosts/fakes without paging; shares the object call contract. */
-export type ChatHistoryStore = Pick<ChatStore, 'list' | 'get' | 'create' | 'rename' | 'touch' | 'delete' | 'messages' | 'appendMessage'>;
+/** Eight-method compatibility subset plus optional bounded history; old hosts/fakes still fit. */
+export type ChatHistoryStore = Pick<ChatStore, 'list' | 'get' | 'create' | 'rename' | 'touch' | 'delete' | 'messages' | 'appendMessage' | 'history'>;
+/** Internal persistence projections. Model-facing tools redact and cap these before returning. */
+export interface ChatHistoryReader {
+    list(required: Record<string, never>, optional?: {
+        query?: string;
+        limit?: number;
+    }): Promise<readonly (ChatConversation & {
+        firstUserLine: string;
+    })[]>;
+    read(required: {
+        chatId: string;
+    }, optional?: {
+        fromPosition?: number;
+        limit?: number;
+        includeToolEvents?: boolean;
+    }): Promise<{
+        messages: readonly (ChatMessage & {
+            position: number;
+        })[];
+        hasMore: boolean;
+    }>;
+}
 /** Authority for cross-owner retention must never reach ordinary request handlers. */
 export interface ChatHistoryMaintenance {
     /** Delete at most limit conversations; default 500, integer 1..500. */

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

@@ -88,8 +88,11 @@ function continuationEvents({ current, incoming }, _optional = {}) {
             break;
         }
     }
-    if (marker >= 0)
-        return [...recoveredRunEvents({ saved }, {}), ...incoming.slice(marker + 1)];
+    if (marker >= 0) {
+        const event = incoming[marker];
+        const notice = event.kind === 'status' && event.label === '' ? 'silent' : 'visible';
+        return [...recoveredRunEvents({ saved }, { notice }), ...incoming.slice(marker + 1)];
+    }
     return runContentFromEvents({ events: incoming }).length >= current.message.content.length ? incoming : saved;
 }
 /** Same kernel and message lock as checkpoint/settle. Claim changes run_id before any spawn;

package/dist/store/runtime/entry.d.ts

@@ -4,4 +4,5 @@ export * from "./chat-history-store.js";
 export * from "./run-guarded-chat-store.js";
 export type { ChatKernel, ChatDatabase } from "./kernel.js";
 export * from "./chat-expiry-sweep.js";
+export * from "./history-tools.js";
 //# sourceMappingURL=entry.d.ts.map

package/dist/store/runtime/entry.js

@@ -3,4 +3,5 @@ export * from "./run-ledger.js";
 export * from "./chat-history-store.js";
 export * from "./run-guarded-chat-store.js";
 export * from "./chat-expiry-sweep.js";
+export * from "./history-tools.js";
 //# sourceMappingURL=entry.js.map

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

@@ -0,0 +1,27 @@
+/** Model-facing history tools over an authenticated owner-scoped store; no database handles. */
+import { type AgentToolDefinition, type DerivedRiskByToolId, type ToolRegistration } from '@jini-ai/core';
+import { type RedactUserText } from '../../core/user-text-redaction.js';
+import type { ChatHistoryStore } from '../ports.js';
+export declare const HISTORY_MESSAGE_CHAR_CAP = 8000;
+export declare const HISTORY_TOTAL_CHAR_CAP = 40000;
+export declare const assistantHistoryDerivedRisk: DerivedRiskByToolId;
+/** Exported so host contract tests can pin each registration to its catalog entry. */
+export declare const assistantHistoryToolCatalog: ReadonlyMap<string, AgentToolDefinition>;
+/** Auth is resolved by the host using execution identity, never from model input. */
+export interface AssistantHistoryToolPorts {
+    getStore(required: {
+        principalId: string;
+    }, optional?: Record<string, never>): Promise<ChatHistoryStore>;
+}
+/** Build both history registrations, using the existing catalog/risk/metadata contract.
+ * @param ports Authenticated scoped-store port; denied/missing history must fail closed.
+ * @param options Optional stricter redaction policy (the secret-card policy is the default).
+ * @returns Read-only tool registrations. @throws ToolInputError for malformed or refused reads.
+ * @complexity Bounded projections; persistence owns search cost and message ordering.
+ */
+export declare function buildAssistantHistoryRegistrations({ ports }: {
+    ports: AssistantHistoryToolPorts;
+}, { redact }?: {
+    redact?: RedactUserText;
+}): ToolRegistration[];
+//# sourceMappingURL=history-tools.d.ts.map

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

@@ -0,0 +1,169 @@
+/** Model-facing history tools over an authenticated owner-scoped store; no database handles. */
+import { buildDomainRegistrations, indexCatalogById, requireInputRecord, ToolInputError } from '@jini-ai/core';
+import { redactUserText } from '../../core/user-text-redaction.js';
+import { assistantHistoryToolMetadata } from '../../core/history-tool-metadata.js';
+export const HISTORY_MESSAGE_CHAR_CAP = 8_000;
+export const HISTORY_TOTAL_CHAR_CAP = 40_000;
+const TOOL_EVENT_CAP = 50;
+export const assistantHistoryDerivedRisk = new Map([
+    ['assistant_chats_list', 'none'], ['assistant_chat_read', 'none'],
+]);
+/** Exported so host contract tests can pin each registration to its catalog entry. */
+export const assistantHistoryToolCatalog = indexCatalogById({ catalog: [
+        { name: 'assistant_chats_list', sideEffects: 'none', authorization: { permission: 'admin.assistant.use' },
+            description: "Lists the CURRENT user's own conversations on this site, newest first, optionally searching titles and message content. Returns id, title, updatedAt, messageCount and firstUserLine, with redacted, capped text. When the user refers to an earlier or interrupted chat ('continue what we were doing'), list first, then assistant_chat_read to read its tail, summarise the state and continue. No other user's chats are accessible; unavailable history is an error.",
+            inputSchema: { type: 'object', additionalProperties: false, properties: {
+                    query: { type: 'string', maxLength: 200 }, limit: { type: 'integer', minimum: 1, maximum: 50, default: 20 },
+                } } },
+        { name: 'assistant_chat_read', sideEffects: 'none', authorization: { permission: 'admin.assistant.use' },
+            description: "Reads one of the CURRENT user's own chats in stored message order. Omit fromPosition to read the latest tail (default 50 messages); use fromPosition and nextPosition for forward pagination. List chats first when resuming earlier work, read the tail, summarise the state, then continue. Returns redacted messages, positions, continuation and truncated flags; each serialized message is capped at 8,000 characters and the result at 40,000 characters. Tool events, when requested, contain only tool name and outcome, never payloads. Attachments are omitted. Missing and other-user chats receive the same refusal.",
+            inputSchema: { type: 'object', additionalProperties: false, required: ['chatId'], properties: {
+                    chatId: { type: 'string', minLength: 1, maxLength: 128 },
+                    fromPosition: { type: 'integer', minimum: 0 }, limit: { type: 'integer', minimum: 1, maximum: 100, default: 50 },
+                    includeToolEvents: { type: 'boolean', default: false },
+                } } },
+    ] });
+/** Cap a fresh projection including JSON escapes and tool summaries, before the total-page cap.
+ * The projection is local to this call, so trimming it cannot mutate stored messages or events.
+ * @complexity Bounded content/summary serialization; no I/O or unbounded output accumulation.
+ */
+function capMessage({ view }, _options = {}) {
+    while (JSON.stringify(view).length > HISTORY_MESSAGE_CHAR_CAP) {
+        view.truncated = true;
+        if (view.content.length > 0)
+            view.content = view.content.slice(0, Math.floor(view.content.length / 2));
+        else
+            view.toolEvents?.pop();
+    }
+    return view;
+}
+/** Only bounded names and status cross this boundary; malformed historical events are ignored.
+ * @complexity O(e) time/space in persisted events; output is capped at 50 summaries.
+ */
+function summarizeTools({ events, redact }, _options = {}) {
+    if (!Array.isArray(events))
+        return { items: [], truncated: false };
+    const outcomes = new Map();
+    for (const raw of events) {
+        const event = raw;
+        if (event?.kind === 'tool_result' && typeof event.toolUseId === 'string') {
+            outcomes.set(event.toolUseId, event.isError === true ? 'failed' : event.isError === false ? 'succeeded' : 'unknown');
+        }
+    }
+    const items = [];
+    let truncated = false;
+    for (const raw of events) {
+        const event = raw;
+        if (event?.kind !== 'tool_use' || typeof event.name !== 'string')
+            continue;
+        if (items.length === TOOL_EVENT_CAP) {
+            truncated = true;
+            break;
+        }
+        const name = redact({ text: event.name }).text;
+        if (name.length > 120)
+            truncated = true;
+        items.push({ name: name.slice(0, 120), outcome: outcomes.get(event.id ?? '') ?? 'unknown' });
+    }
+    return { items, truncated };
+}
+/** Validate advertised integer bounds even when a transport bypasses JSON schema validation. */
+function integerOption({ input, key, fallback, max, min = 1 }, _options = {}) {
+    const value = input[key] === undefined ? fallback : input[key];
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < min || value > max) {
+        throw new ToolInputError({ message: `${key} must be an integer from ${min} through ${max}.` });
+    }
+    return value;
+}
+/** Strict allowlist prevents model-supplied identity from ever reaching the host scope factory. */
+function inputRecord({ input, keys }, _options = {}) {
+    const record = requireInputRecord({ input });
+    if (Object.keys(record).some(key => !keys.includes(key)))
+        throw new ToolInputError({ message: 'Unexpected chat history input field. Use the published schema.' });
+    return record;
+}
+/** Build both history registrations, using the existing catalog/risk/metadata contract.
+ * @param ports Authenticated scoped-store port; denied/missing history must fail closed.
+ * @param options Optional stricter redaction policy (the secret-card policy is the default).
+ * @returns Read-only tool registrations. @throws ToolInputError for malformed or refused reads.
+ * @complexity Bounded projections; persistence owns search cost and message ordering.
+ */
+export function buildAssistantHistoryRegistrations({ ports }, { redact = redactUserText } = {}) {
+    return buildDomainRegistrations({ domain: 'assistant-history', catalogModule: 'chat/store/runtime/history-tools', catalog: assistantHistoryToolCatalog,
+        derivedRisk: assistantHistoryDerivedRisk, metadata: assistantHistoryToolMetadata,
+        handlers: {
+            assistant_chats_list: async (ctx) => {
+                const input = inputRecord({ input: ctx.input, keys: ['query', 'limit'] });
+                if (input.query !== undefined && (typeof input.query !== 'string' || input.query.length > 200))
+                    throw new ToolInputError({ message: 'query must be a string of at most 200 characters.' });
+                const limit = integerOption({ input, key: 'limit', fallback: 20, max: 50 });
+                const store = await ports.getStore({ principalId: ctx.principal.id }, {});
+                if (!store.history)
+                    throw new ToolInputError({ message: 'Chat history is unavailable on this site.' });
+                const rows = await store.history.list({}, { ...(input.query === undefined ? {} : { query: input.query }), limit });
+                let truncated = false;
+                const chats = rows.map(row => {
+                    // Redact BEFORE slicing: a cap must not turn a credential into an undetectable fragment.
+                    const title = redact({ text: row.title ?? '' }).text;
+                    const first = redact({ text: row.firstUserLine }).text.split(/\r?\n/, 1)[0];
+                    if (title.length > 300 || first.length > 500 || row.id.length > 128)
+                        truncated = true;
+                    return { id: redact({ text: row.id }).text.slice(0, 128), title: title.slice(0, 300), updatedAt: row.updatedAt,
+                        messageCount: row.messageCount, firstUserLine: first.slice(0, 500) };
+                });
+                // List is bounded too; serialized escaping can make text larger than its character count.
+                while (JSON.stringify({ chats, truncated }).length > HISTORY_TOTAL_CHAR_CAP) {
+                    chats.pop();
+                    truncated = true;
+                }
+                return { chats, truncated };
+            },
+            assistant_chat_read: async (ctx) => {
+                const input = inputRecord({ input: ctx.input, keys: ['chatId', 'fromPosition', 'limit', 'includeToolEvents'] });
+                if (typeof input.chatId !== 'string' || !input.chatId.trim() || input.chatId.length > 128)
+                    throw new ToolInputError({ message: 'chatId must be an id returned by assistant_chats_list.' });
+                const limit = integerOption({ input, key: 'limit', fallback: 50, max: 100 });
+                const fromPosition = input.fromPosition === undefined ? undefined : integerOption({ input, key: 'fromPosition', fallback: 0, max: Number.MAX_SAFE_INTEGER, min: 0 });
+                if (input.includeToolEvents !== undefined && typeof input.includeToolEvents !== 'boolean')
+                    throw new ToolInputError({ message: 'includeToolEvents must be boolean.' });
+                const store = await ports.getStore({ principalId: ctx.principal.id }, {});
+                if (!store.history)
+                    throw new ToolInputError({ message: 'Chat history is unavailable on this site.' });
+                if (!await store.get({ id: input.chatId }, {}))
+                    throw new ToolInputError({ message: 'Chat is unavailable to this caller. Choose an id from assistant_chats_list.' });
+                const page = await store.history.read({ chatId: input.chatId }, { ...(fromPosition === undefined ? {} : { fromPosition }), limit, includeToolEvents: input.includeToolEvents === true });
+                const messages = [];
+                let truncated = page.hasMore;
+                // Reserve result envelope/continuation space; measure serialized messages, including escapes.
+                let remaining = HISTORY_TOTAL_CHAR_CAP - 512;
+                const candidates = fromPosition === undefined ? [...page.messages].reverse() : page.messages;
+                for (const row of candidates) {
+                    const content = redact({ text: row.content }).text;
+                    const tools = input.includeToolEvents === true ? summarizeTools({ events: row.events, redact }) : undefined;
+                    const view = capMessage({ view: { id: redact({ text: row.id }).text.slice(0, 128), role: row.role === 'user' ? 'user' : 'assistant', position: row.position,
+                            content: content.slice(0, HISTORY_MESSAGE_CHAR_CAP), truncated: content.length > HISTORY_MESSAGE_CHAR_CAP || row.id.length > 128 || tools?.truncated === true,
+                            ...(tools ? { toolEvents: tools.items } : {}) } });
+                    if (JSON.stringify(view).length > remaining && messages.length > 0) {
+                        truncated = true;
+                        break;
+                    }
+                    // Advance only over returned positions; the next page must include the omitted row.
+                    messages.push(view);
+                    remaining -= JSON.stringify(view).length + 1;
+                    if (view.truncated)
+                        truncated = true;
+                }
+                if (fromPosition === undefined)
+                    messages.reverse();
+                const last = messages.at(-1), first = messages.at(0);
+                const omitted = messages.length < page.messages.length;
+                const hasMore = fromPosition !== undefined && (omitted || page.hasMore);
+                return { chatId: redact({ text: input.chatId }).text, messages, truncated, hasMore,
+                    ...(last ? { nextPosition: last.position + 1 } : {}),
+                    ...(first ? { firstPosition: first.position } : {}),
+                    hasMoreBefore: fromPosition === undefined && (omitted || page.hasMore) };
+            },
+        },
+    });
+}
+//# sourceMappingURL=history-tools.js.map

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

@@ -126,15 +126,18 @@ export function createChatRunLedger({ kernel: hostKernel, isDaemonRunId }, _opti
         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"])
+                const current = await kernel.run((db) => db.selectFrom("ai_chat_messages").select(["content", "events_json", "run_status"])
                     .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);
+                // A checkpoint is the run producing output, so an accepted (`queued`) row is now `running`;
+                // nothing else moves it there, and a streaming answer must not read as still waiting.
+                const runStatus = current.run_status === "queued" ? "running" : current.run_status;
                 const result = await kernel.run((db) => db
                     .updateTable("ai_chat_messages")
-                    .set({ content: progress.content, events_json: JSON.stringify(events) })
+                    .set({ content: progress.content, events_json: JSON.stringify(events), run_status: runStatus })
                     .where((eb) => eb.and([isRunRow(eb, progress), notTerminal(eb)]))
                     .executeTakeFirst());
                 if (Number(result.numUpdatedRows) > 0 && grown) {

package/dist/store/sql/store.js

@@ -212,6 +212,54 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
         return row?.max === null || row?.max === undefined ? 0 : Number(row.max) + 1;
     }
     const store = {
+        history: {
+            /** Literal search uses two scoped projections, not a transcript fetch per conversation.
+             * @complexity The database scans owned content for search; only limit rows cross the port.
+             */
+            async list(_required, { query, limit = 20 } = {}) {
+                if (!Number.isInteger(limit) || limit < 1 || limit > 50 || (query !== undefined && (typeof query !== 'string' || query.length > 200))) {
+                    throw new ChatStoreError({ code: 'invalid-input' });
+                }
+                const rows = await run(db => {
+                    let statement = ownedConversations(db).select(eb => eb.selectFrom('ai_chat_messages as first')
+                        .select('first.content').whereRef('first.conversation_id', '=', 'c.id').where('first.role', '=', 'user')
+                        .orderBy('first.position').limit(1).as('first_user_line'));
+                    if (query?.trim()) {
+                        // Escape LIKE wildcards: user search is literal text, never an SQL/FTS expression.
+                        const pattern = '%' + query.trim().toLowerCase().replace(/[!%_]/g, char => '!' + char) + '%';
+                        statement = statement.where(eb => eb.or([
+                            sql `lower(c.title) like ${pattern} escape '!'`,
+                            eb.exists(eb.selectFrom('ai_chat_messages as found').select('found.id')
+                                .whereRef('found.conversation_id', '=', 'c.id')
+                                .where(sql `lower(found.content) like ${pattern} escape '!'`)),
+                        ]));
+                    }
+                    return statement.orderBy('c.updated_at', 'desc').orderBy(ordinalId(kernel.dialect, 'c.id')).limit(limit).execute();
+                });
+                return rows.map(row => ({ ...toConversation(row), firstUserLine: row.first_user_line ?? '' }));
+            },
+            /** No attachment column is read. O(limit) rows; default tail is reversed into position order. */
+            async read({ chatId }, { fromPosition, limit = 50, includeToolEvents = false } = {}) {
+                if (!Number.isInteger(limit) || limit < 1 || limit > 100 || (fromPosition !== undefined && (!Number.isSafeInteger(fromPosition) || fromPosition < 0))) {
+                    throw new ChatStoreError({ code: 'invalid-input' });
+                }
+                const rows = await run(db => {
+                    let statement = ownedMessages(db, chatId).clearSelect().select([
+                        'm.id', 'm.role', 'm.content', 'm.position', 'm.created_at',
+                    ]);
+                    if (fromPosition !== undefined)
+                        statement = statement.where('m.position', '>=', fromPosition);
+                    return statement.select(includeToolEvents ? sql `m.events_json`.as('events_json') : sql `null`.as('events_json'))
+                        .orderBy('m.position', fromPosition === undefined ? 'desc' : 'asc').limit(limit + 1).execute();
+                });
+                const page = rows.slice(0, limit);
+                if (fromPosition === undefined)
+                    page.reverse();
+                return { messages: page.map(row => ({ id: row.id, role: row.role, content: row.content,
+                        position: Number(row.position), createdAt: Number(row.created_at),
+                        ...(includeToolEvents ? { events: row.events_json ? safeParse(row.events_json) : undefined } : {}), })), hasMore: rows.length > limit };
+            },
+        },
         async list() {
             const rows = await run((db) => ownedConversations(db).orderBy("c.updated_at", "desc").execute());
             return rows.map((row) => toConversation(row));
@@ -332,6 +380,10 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
         },
     };
     return {
+        history: {
+            list: (required, optional = {}) => atStoreBoundary({ operation: () => store.history.list(required, optional) }),
+            read: (required, optional = {}) => atStoreBoundary({ operation: () => store.history.read(required, optional) }),
+        },
         list: () => atStoreBoundary({ operation: () => store.list() }),
         get: (required, optional = {}) => atStoreBoundary({ operation: () => store.get(required, optional) }),
         create: (required, optional = {}) => atStoreBoundary({ operation: () => store.create(required, optional) }),

package/dist/testing/index.d.ts

@@ -0,0 +1,7 @@
+import type { ChatMessage } from '../core/index.js';
+/** `turns` user/assistant pairs; each reply carries `toolRowsPerTurn` finished Bash calls with output. */
+export declare function createLongTranscriptFixture({ turns, toolRowsPerTurn }: {
+    turns: number;
+    toolRowsPerTurn: number;
+}, _options?: Record<string, never>): ChatMessage[];
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.js

@@ -0,0 +1,22 @@
+/** `turns` user/assistant pairs; each reply carries `toolRowsPerTurn` finished Bash calls with output. */
+export function createLongTranscriptFixture({ turns, toolRowsPerTurn }, _options = {}) {
+    return Array.from({ length: turns }, (_, turn) => [
+        { id: `u${turn}`, role: 'user', content: `Step ${turn}`, createdAt: turn * 2 },
+        {
+            id: `a${turn}`,
+            role: 'assistant',
+            content: `Done with step ${turn}.`,
+            runStatus: 'succeeded',
+            createdAt: turn * 2 + 1,
+            events: [
+                ...Array.from({ length: toolRowsPerTurn }, (_, i) => [
+                    { kind: 'tool_use', id: `t${turn}-${i}`, name: 'Bash', input: { command: `ls ${i}` } },
+                    { kind: 'tool_result', toolUseId: `t${turn}-${i}`, content: 'file\n'.repeat(50), isError: false },
+                ]).flat(),
+                { kind: 'text', text: `Done with step ${turn}.` },
+                { kind: 'ext', name: 'render-probe', data: { turn } },
+            ],
+        },
+    ]).flat();
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/chat",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "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": {
@@ -14,6 +14,7 @@
     "runtime": "universal",
     "entries": {
       ".": "universal",
+      "./testing": "universal",
       "./core": "universal",
       "./react": "browser",
       "./react/chat-pane": "browser",
@@ -34,7 +35,10 @@
       "./browser/session-store": "browser",
       "./browser/page-actions": "browser",
       "./server/durable-runs": "node",
-      "./store/runtime": "node"
+      "./store/runtime": "node",
+      "./vanilla": "browser",
+      "./browser/lazy-loader": "browser",
+      "./vanilla/style.css": "browser"
     },
     "neutralEntries": [
       "src/store/contracts"
@@ -54,6 +58,11 @@
   "main": "./dist/core/index.js",
   "types": "./dist/core/index.d.ts",
   "exports": {
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js",
+      "default": "./dist/testing/index.js"
+    },
     ".": {
       "types": "./dist/core/index.d.ts",
       "import": "./dist/core/index.js",
@@ -155,7 +164,18 @@
       "types": "./dist/store/runtime/entry.d.ts",
       "import": "./dist/store/runtime/entry.js",
       "default": "./dist/store/runtime/entry.js"
-    }
+    },
+    "./vanilla": {
+      "types": "./dist/embed-widget/vanilla/index.d.ts",
+      "import": "./dist/embed-widget/vanilla/index.js",
+      "default": "./dist/embed-widget/vanilla/index.js"
+    },
+    "./browser/lazy-loader": {
+      "types": "./dist/embed-widget/browser/lazy-loader.d.ts",
+      "import": "./dist/embed-widget/browser/lazy-loader.js",
+      "default": "./dist/embed-widget/browser/lazy-loader.js"
+    },
+    "./vanilla/style.css": "./dist/embed-widget/vanilla/style.css"
   },
   "files": [
     "dist",
@@ -176,12 +196,12 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.2"
+    "@jini-ai/core": "^0.4.3"
   },
   "peerDependencies": {
     "react": "^18.3.0 || ^19.0.0",
     "react-dom": "^18.3.0 || ^19.0.0",
-    "@jini-ai/db": "^0.2.0 || ^0.3.0",
+    "@jini-ai/db": "^0.3.2",
     "kysely": "^0.29.6",
     "better-sqlite3": "^13.0.0",
     "@electric-sql/pglite": "0.5.8",
@@ -194,11 +214,11 @@
     "@radix-ui/react-select": "^2.3.7",
     "@radix-ui/react-slot": "^1.3.3",
     "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"
+    "@jini-ai/agent-runtime": "^0.4.5",
+    "@jini-ai/agentic": "^0.4.4",
+    "@jini-ai/protocol": "^0.4.4",
+    "@jini-ai/ui": "^0.4.8",
+    "@jini-ai/diagnostics": "^0.5.2"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -277,6 +297,7 @@
     "@types/react": "^19.2.0",
     "@types/react-dom": "^19.2.0",
     "@vitest/coverage-v8": "^2.1.9",
+    "zod": "^3.25.76",
     "jsdom": "^25.0.1",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
@@ -286,16 +307,19 @@
     "@electric-sql/pglite": "0.5.8",
     "pg": "8.23.0",
     "@ag-ui/core": "0.0.58",
-    "@jini-ai/protocol": "^0.4.2",
-    "@jini-ai/agent-runtime": "0.4.3",
-    "@jini-ai/ui": "^0.4.6",
-    "@jini-ai/db": "0.3.1",
-    "@jini-ai/agentic": "^0.4.3",
-    "@jini-ai/diagnostics": "^0.5.1",
-    "@jini-ai/core": "^0.4.2"
+    "@jini-ai/db": "0.3.2",
+    "@jini-ai/agentic": "^0.4.4",
+    "@jini-ai/protocol": "^0.4.4",
+    "@jini-ai/diagnostics": "^0.5.2",
+    "@jini-ai/agent-runtime": "0.4.5",
+    "@jini-ai/core": "^0.4.3",
+    "@jini-ai/ui": "^0.4.8"
   },
   "typesVersions": {
     "*": {
+      "testing": [
+        "./dist/testing/index.d.ts"
+      ],
       "core": [
         "./dist/core/index.d.ts"
       ],
@@ -349,11 +373,17 @@
       ],
       "store/runtime": [
         "./dist/store/runtime/entry.d.ts"
+      ],
+      "vanilla": [
+        "./dist/embed-widget/vanilla/index.d.ts"
+      ],
+      "browser/lazy-loader": [
+        "./dist/embed-widget/browser/lazy-loader.d.ts"
       ]
     }
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && mkdir -p dist/react/styles && cp src/react/styles/reference.css dist/react/styles/",
+    "build": "tsc -p tsconfig.json && mkdir -p dist/react/styles && cp src/react/styles/reference.css dist/react/styles/ && mkdir -p dist/embed-widget/vanilla && node --input-type=module -e \"import {writeFileSync,readFileSync} from 'node:fs'; import {CHAT_BUBBLE_STYLE} from './dist/embed-widget/browser/lazy-loader.js'; writeFileSync('dist/embed-widget/vanilla/style.css',CHAT_BUBBLE_STYLE+'\\n'+readFileSync('src/embed-widget/vanilla/style.css','utf8'));\"",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",