@jini-ai/chat 0.6.15-rc.2 → 0.6.15

package/dist/react/hooks/useConversation.js

@@ -52,7 +52,7 @@ export function useConversation(options) {
     useEffect(() => {
         const source = options.refreshSignal;
         if (!source || run.isStreaming)
-            return;
+            return undefined;
         let disposed = false, pending = false, timer;
         const refresh = async () => {
             if (pending)
@@ -61,7 +61,7 @@ export function useConversation(options) {
             try {
                 const saved = await source.loadMessages();
                 if (!disposed)
-                    setMessagesState(prev => [...new Map([...prev, ...saved].map(message => [message.id, message])).values()]);
+                    setMessagesState(prev => mergeSavedMessages({ previous: prev, saved }));
             }
             catch (error) {
                 if (!disposed)
@@ -143,14 +143,14 @@ export function useConversation(options) {
                 return m;
             // A plain if/else chain (not a nested ternary) — deliberately, so
             // each of the four mapped statuses is its own independently
-            // trackable branch under coverage instrumentation. The initial
+            // trackable branch under coverage instrumentation. The fallback
             // value is asserted non-null: this reconciliation effect only ever
             // runs after `sendMessage`/`retry` has called `run.start()`/
             // `reattach` (both set the message's `runStatus: 'queued'` via
             // `activeAssistantIdRef` first), so `m.runStatus` is always defined
             // and `run.status` is never `'idle'` by the time this callback
             // fires — one of the four branches below always reassigns it.
-            let runStatus = m.runStatus;
+            let runStatus;
             if (run.status === 'streaming')
                 runStatus = 'running';
             else if (run.status === 'done')
@@ -159,6 +159,8 @@ export function useConversation(options) {
                 runStatus = 'failed';
             else if (run.status === 'canceled')
                 runStatus = 'canceled';
+            else
+                runStatus = m.runStatus;
             const nextRunId = run.runId ?? m.runId;
             const events = projectAcceptedInputEvents({ events: mergeRunEvents({ saved: m.events, incoming: run.events }, {}) });
             return {
@@ -274,4 +276,7 @@ export function useConversation(options) {
         suppressScroll,
     }), [messages, conversationId, run.isStreaming, run.error, sendRefused, scrollIntent, sendMessage, cancel, retry, setMessages, acknowledgeScroll, suppressScroll]);
 }
+function mergeSavedMessages({ previous, saved }) {
+    return [...new Map([...previous, ...saved].map(message => [message.id, message])).values()];
+}
 //# sourceMappingURL=useConversation.js.map

package/dist/react/hooks/useExtEventGroups.js

@@ -26,12 +26,14 @@ function addExtEvent(state, { name, data }) {
 function visitEvent(state, ev) {
     if (ev.kind === 'tool_use') {
         state.openCalls.set(ev.id, { name: ev.name, input: ev.input });
+        return;
     }
-    else if (ev.kind === 'tool_result') {
+    if (ev.kind === 'tool_result') {
         state.openCalls.delete(ev.toolUseId);
         state.results.set(ev.toolUseId, { content: ev.content, isError: ev.isError });
+        return;
     }
-    else if (ev.kind === 'ext') {
+    if (ev.kind === 'ext') {
         addExtEvent(state, ev);
     }
 }

package/dist/react/hooks/useLatestOperation.js

@@ -48,7 +48,8 @@ export function useLatestOperation(_requiredArgs) {
         generationRef.current += 1;
     }, []);
     const run = useCallback(async ({ body, onError }) => {
-        const generation = ++generationRef.current;
+        generationRef.current += 1;
+        const generation = generationRef.current;
         const isCurrent = () => mountedRef.current && generation === generationRef.current;
         const token = {
             isCurrent,

package/dist/react/hooks/useQuestionForms.js

@@ -66,23 +66,17 @@ export function parseSubmittedAnswers({ form, userMessageContent }) {
         // `i < lines.length` is the loop condition, so this index is always
         // in-bounds and defined — same reasoning as `header` above.
         const line = lines[i];
-        const m = /^[-*]\s*([^:]+):\s*(.*)$/.exec(line);
-        if (!m)
+        const parsed = submittedAnswerLine({ line });
+        if (!parsed)
             continue;
-        // Both capture groups are required (non-optional) in this pattern, so
-        // they're always defined once `m` is non-null — TS just can't express
-        // that for regex capture groups.
-        const labelKey = m[1].trim().toLowerCase();
-        const value = m[2].trim();
-        const id = labelToId.get(labelKey);
-        if (!id)
-            continue;
-        // `id` only ever comes from `labelToId`, which was populated from this
-        // same `form.questions` array immediately above, so a question with
-        // this exact `id` is always found — the `!` reflects that invariant
-        // rather than gaming an untestable defensive branch.
-        const question = form.questions.find((x) => x.id === id);
-        answers[id] = decodeAnswerValue(question, value);
+        const id = labelToId.get(parsed.labelKey);
+        if (id) {
+            // `id` only ever comes from `labelToId`, populated from this same `form.questions` array,
+            // so this exact question exists; the assertion reflects that invariant rather than adding
+            // an untestable defensive branch.
+            const question = form.questions.find((x) => x.id === id);
+            answers[id] = decodeAnswerValue(question, parsed.value);
+        }
     }
     return Object.keys(answers).length > 0 ? answers : null;
 }
@@ -97,12 +91,28 @@ function decodeAnswerValue(question, value) {
     return value.toLowerCase() === '(skipped)' ? '' : formOptionValueForLabel({ question: question, labelOrValue: parseSubmittedOptionToken(value) });
 }
 function parseSubmittedOptionToken(raw) {
-    const match = /\s+\[value:\s*([^\]]+)\]\s*$/i.exec(raw);
-    if (!match)
+    const trimmed = raw.trimEnd();
+    if (!trimmed.endsWith(']'))
+        return raw.trim();
+    const end = trimmed.length - 1;
+    // The value cannot cross an earlier ']'; search the remaining suffix once, from the start
+    // of each whitespace run, retaining the first eligible (possibly nested) value marker.
+    const base = trimmed.lastIndexOf(']', end - 1) + 1;
+    const marker = /(?<!\s)\s+\[value:/i.exec(trimmed.slice(base, end));
+    if (!marker)
         return raw.trim();
-    // The single capture group is non-optional in this pattern, so it's
-    // always defined once `match` is non-null — same regex-capture-group
-    // caveat as `parseSubmittedAnswers` above.
-    return match[1].trim();
+    const value = trimmed.slice(base + marker.index + marker[0].length, end);
+    return value.length > 0 ? value.trim() : raw.trim();
+}
+function submittedAnswerLine({ line }) {
+    const label = /^[-*]([^:]+):/.exec(line);
+    if (!label)
+        return null;
+    const value = /^(.*)$/.exec(line.slice(label[0].length).trimStart());
+    if (!value)
+        return null;
+    // Each capture is required in its own pattern and is defined after a successful match;
+    // TypeScript cannot express that invariant for RegExpExecArray's numeric capture slots.
+    return { labelKey: label[1].trim().toLowerCase(), value: value[1].trim() };
 }
 //# sourceMappingURL=useQuestionForms.js.map

package/dist/react/hooks/useRunStream.js

@@ -118,7 +118,8 @@ export function useRunStream({ transport }) {
     }, []);
     const start = useCallback(async (input) => {
         teardownSubscription();
-        const generation = ++generationRef.current;
+        generationRef.current += 1;
+        const generation = generationRef.current;
         runIdRef.current = null;
         const subscriptionAbort = new AbortController();
         const cancelAbort = new AbortController();
@@ -150,7 +151,8 @@ export function useRunStream({ transport }) {
     }, [makeHandlers, teardownSubscription, transport]);
     const reattach = useCallback(async (runId, initialEvents = []) => {
         teardownSubscription();
-        const generation = ++generationRef.current;
+        generationRef.current += 1;
+        const generation = generationRef.current;
         runIdRef.current = runId;
         const subscriptionAbort = new AbortController();
         const cancelAbort = new AbortController();

package/dist/react/message-blocks.js

@@ -100,9 +100,11 @@ function placeEvent({ state, ev }, { slotOf, includeThinking }) {
     // Emitted per boundary, before any slot dedupe below, so every reply gets its own end marker.
     if (isReplyBoundary({ event: ev }))
         placeReplyEnd({ state });
-    if (ev.kind === 'ext')
+    if (ev.kind === 'ext') {
         placeExt({ state, ev }, { slotOf });
-    else if (ev.kind === 'tool_use')
+        return;
+    }
+    if (ev.kind === 'tool_use')
         placeToolUse({ state, id: ev.id });
 }
 /**

package/dist/react/styles/reference.css

@@ -43,6 +43,15 @@
   min-width: 0;
 }
 
+/* The picker, plus menu and send share this <div>; flex keeps them on one line, and it wraps
+   whole to its own line when the footer runs out of room. */
+.jini-composer-footer-trailing {
+  display: flex;
+  align-items: center;
+  min-width: 0;
+  margin-left: auto;
+}
+
 /* The grouped add menu and slash autocomplete anchor to the composer rather than escaping the
    host's layout. Visual tokens remain the host's responsibility. */
 .jini-composer,

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

@@ -2,7 +2,7 @@ import { recoveredRunEvents } from "../../core/index.js";
 import { classifyAgentServiceFailure } from "@jini-ai/agent-runtime";
 import { continuationRequest } from "../../core/durable-runs/continuation.js";
 import { isAwaitingAnswer } from "../../core/run-activity.js";
-import { RECOVERY_LIMIT, RECOVERY_WINDOW_MS, RUN_STALENESS_MS, SAVED_WORK_NOTICE, AWAITING_ANSWER_NOTICE, EXHAUSTED_NOTICE } from "../../core/durable-runs/policies.js";
+import { RECOVERY_LIMIT, RUN_STALENESS_MS, SAVED_WORK_NOTICE, AWAITING_ANSWER_NOTICE, EXHAUSTED_NOTICE } from "../../core/durable-runs/policies.js";
 export { RECOVERY_LIMIT, RECOVERY_WINDOW_MS, RUN_STALENESS_MS, SAVED_WORK_NOTICE, AWAITING_ANSWER_NOTICE, EXHAUSTED_NOTICE } from "../../core/durable-runs/policies.js";
 // Older saved run error frames hold only their message: the daemon's MCP_BRIDGE_UNAVAILABLE
 // code was dropped, so the bridge failure is still matched by its text.
@@ -57,10 +57,8 @@ function attemptDiagnostics({ run }, _optional = {}) {
 /** 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. */
 function needsHumanRepair({ diagnostics }, _optional = {}) {
-    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 true;
-    return /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);
+    const hasRejectedStatus = REQUEST_STATUS_PATTERNS.some(pattern => [...diagnostics.matchAll(pattern)].some(match => match[1] !== "408" && match[1] !== "429"));
+    return hasRejectedStatus || HUMAN_REPAIR_PATTERNS.some(pattern => pattern.test(diagnostics));
 }
 function attemptFailure({ diagnostics }, _optional = {}) {
     // MCP_BRIDGE_UNAVAILABLE needs bridge repair; another attempt repeats the same failure.
@@ -282,4 +280,14 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
         },
     };
 }
+const REQUEST_STATUS_PATTERNS = [
+    /\bhttp(?:[ /]?\d(?:\.\d)?)?[\s:=#-]*(4\d\d)\b/gi,
+    /\b(?:status|error|response)(?:[ _-]?code)?[\s:=#-]*(4\d\d)\b/gi,
+    /\bcode(?=\s*[:=#])[\s:=#-]*(4\d\d)\b/gi,
+];
+const HUMAN_REPAIR_PATTERNS = [
+    /another answer in this chat is still running|invalid[_ -]?request|context[_ -](length|window)|maximum context/i,
+    /model.*(?:not[_ -]found|does not exist|not supported)|unsupported|does not support|permission denied|forbidden/i,
+    /insufficient[_ -]?(quota|balance|credit|funds)|credit balance is too low|exceeded your current quota|quota[_ -]?exceeded|usage limit|billing|payment required/i,
+];
 //# sourceMappingURL=recover.js.map

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

@@ -124,6 +124,7 @@ export function createAssistantRunFinalizer(args, options = {}) {
             await scheduler.sleep({ delayMs: reconnectDelayMs });
         }
         // Exhaustion alone is not evidence of a terminal run; the host can reattach or repair at boot.
+        return undefined;
     }
     return {
         watch({ principalId, conversationId, message }) {

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

@@ -42,9 +42,8 @@ export function createChatHistoryStore({ kernel: hostKernel, scope, isDaemonRunI
     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);
+    const createStore = storeFactory(kernel.transport);
+    const store = createStore(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.
@@ -53,4 +52,11 @@ export function createChatHistoryStore({ kernel: hostKernel, scope, isDaemonRunI
         },
     };
 }
+function storeFactory(transport) {
+    if (transport === "better-sqlite3")
+        return createSqliteChatStore;
+    if (transport === "pglite" || transport === "pglite-socket")
+        return createPgliteChatStore;
+    return createPostgresChatStore;
+}
 //# sourceMappingURL=chat-history-store.js.map

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

@@ -12,12 +12,18 @@ export class RunSlotBusyError extends Error {
     constructor() { super(RUN_SLOT_BUSY); }
 }
 function isAcceptedUserShape({ message }, _optional = {}) {
-    return Boolean(message) && typeof message.id === "string" && Boolean(message.id) && message.role === "user" && typeof message.content === "string"
-        && (message.createdAt === undefined || Number.isFinite(message.createdAt));
+    if (!message || typeof message.id !== "string" || !message.id)
+        return false;
+    if (message.role !== "user" || typeof message.content !== "string")
+        return false;
+    return message.createdAt === undefined || Number.isFinite(message.createdAt);
 }
 function areAcceptedAttachments({ attachments }, _optional = {}) {
-    return Array.isArray(attachments) && attachments.every((attachment) => attachment && typeof attachment.path === "string" && typeof attachment.name === "string"
-        && (attachment.kind === "file" || attachment.kind === "image"));
+    return Array.isArray(attachments) && attachments.every((attachment) => {
+        if (!attachment || typeof attachment.path !== "string" || typeof attachment.name !== "string")
+            return false;
+        return attachment.kind === "file" || attachment.kind === "image";
+    });
 }
 function acceptedUserMessage({ request, now }, _optional = {}) {
     const context = JSON.parse(request.contextRef);
@@ -247,6 +253,10 @@ export function createDurableRunStore({ kernel: hostKernel, isDaemonRunId }, _op
             return load({ messageId: required.messageId }, {});
         });
     }
+    async function writeAttemptMetadata({ values, updates }) {
+        await kernel.run(db => db.insertInto("assistant_run_attempts").values(values)
+            .onConflict(oc => oc.column("message_id").doUpdateSet(updates)).execute());
+    }
     async function advance({ run, nextRunId, now, events }, _options = {}) {
         return kernel.transaction(async () => {
             await kernel.lockKey(runLockKey(run));
@@ -261,17 +271,17 @@ export function createDurableRunStore({ kernel: hostKernel, isDaemonRunId }, _op
                 .where("run_status", "in", ["queued", "running"]).executeTakeFirst());
             if (Number(result.numUpdatedRows) === 0)
                 return false;
-            await kernel.run((db) => db.insertInto("assistant_run_attempts").values({
-                message_id: run.messageId, engine: run.engine, accepted_json: JSON.stringify(run.request),
-                recovery_count: current.recoveryCount + 1, recovery_deadline: current.recoveryDeadline ?? now + RECOVERY_WINDOW_MS,
-                recovery_elapsed_ms: 0, attempt_started_at: now,
-                last_progress_at: current.lastProgressAt, cancel_reason: null, session_id: null,
-                session_confirmed: 0, child_pid: null, child_started_at: null, attempt_base_json: JSON.stringify(projection),
-            }).onConflict((oc) => oc.column("message_id").doUpdateSet({
-                recovery_count: current.recoveryCount + 1, recovery_deadline: current.recoveryDeadline ?? now + RECOVERY_WINDOW_MS,
-                attempt_started_at: now,
-                session_id: null, session_confirmed: 0, child_pid: null, child_started_at: null, attempt_base_json: JSON.stringify(projection),
-            })).execute());
+            await writeAttemptMetadata({ values: {
+                    message_id: run.messageId, engine: run.engine, accepted_json: JSON.stringify(run.request),
+                    recovery_count: current.recoveryCount + 1, recovery_deadline: current.recoveryDeadline ?? now + RECOVERY_WINDOW_MS,
+                    recovery_elapsed_ms: 0, attempt_started_at: now,
+                    last_progress_at: current.lastProgressAt, cancel_reason: null, session_id: null,
+                    session_confirmed: 0, child_pid: null, child_started_at: null, attempt_base_json: JSON.stringify(projection),
+                }, updates: {
+                    recovery_count: current.recoveryCount + 1, recovery_deadline: current.recoveryDeadline ?? now + RECOVERY_WINDOW_MS,
+                    attempt_started_at: now,
+                    session_id: null, session_confirmed: 0, child_pid: null, child_started_at: null, attempt_base_json: JSON.stringify(projection),
+                } });
             return true;
         });
     }
@@ -290,8 +300,7 @@ export function createDurableRunStore({ kernel: hostKernel, isDaemonRunId }, _op
             const run = await lockedRun({ runId });
             if (!run)
                 return;
-            await kernel.run((db) => db.insertInto("assistant_run_attempts").values({ ...metadataForRun({ run }, {}), cancel_reason: reason })
-                .onConflict((oc) => oc.column("message_id").doUpdateSet({ cancel_reason: reason })).execute());
+            await writeAttemptMetadata({ values: { ...metadataForRun({ run }, {}), cancel_reason: reason }, updates: { cancel_reason: reason } });
         });
     }
     async function cancelPending(required, _options = {}) {
@@ -313,19 +322,21 @@ export function createDurableRunStore({ kernel: hostKernel, isDaemonRunId }, _op
             return load({ messageId: required.messageId }, {});
         });
     }
+    async function saveAgentSession({ run, sessionId }) {
+        await kernel.run((db) => db.insertInto("assistant_agent_sessions").values({ conversation_id: run.conversationId,
+            agent_id: run.request.agentId ?? "claude", session_id: sessionId, updated_at: Date.now() })
+            .onConflict((oc) => oc.columns(["conversation_id", "agent_id"]).doUpdateSet({ session_id: sessionId, updated_at: Date.now() })).execute());
+    }
     async function captureSession({ runId, sessionId, child, confirmed = true }, _options = {}) {
         return kernel.transaction(async () => {
             const run = await lockedRun({ runId });
             if (!run || !attemptCanExecute({ run }, {}))
                 return false;
             const fields = { session_id: sessionId, session_confirmed: confirmed ? 1 : 0, ...(child ? { child_pid: child.pid, child_started_at: child.startedAt } : {}) };
-            await kernel.run((db) => db.insertInto("assistant_run_attempts").values({ ...metadataForRun({ run }, {}), ...fields })
-                .onConflict((oc) => oc.column("message_id").doUpdateSet(fields)).execute());
+            await writeAttemptMetadata({ values: { ...metadataForRun({ run }, {}), ...fields }, updates: fields });
             // Session and generation share the same lock/transaction; an old callback cannot write
             // the conversation's locator in the gap between a successful guard and a later CAS.
-            await kernel.run((db) => db.insertInto("assistant_agent_sessions").values({ conversation_id: run.conversationId,
-                agent_id: run.request.agentId ?? "claude", session_id: sessionId, updated_at: Date.now() })
-                .onConflict((oc) => oc.columns(["conversation_id", "agent_id"]).doUpdateSet({ session_id: sessionId, updated_at: Date.now() })).execute());
+            await saveAgentSession({ run, sessionId });
             return true;
         });
     }
@@ -384,8 +395,7 @@ export function createDurableRunStore({ kernel: hostKernel, isDaemonRunId }, _op
                 elapsed = Math.max(0, RECOVERY_WINDOW_MS - (deadline - now));
                 deadline = null;
             }
-            await kernel.run((db) => db.insertInto("assistant_run_attempts").values({ ...row, recovery_deadline: deadline, recovery_elapsed_ms: elapsed })
-                .onConflict((oc) => oc.column("message_id").doUpdateSet({ recovery_deadline: deadline, recovery_elapsed_ms: elapsed })).execute());
+            await writeAttemptMetadata({ values: { ...row, recovery_deadline: deadline, recovery_elapsed_ms: elapsed }, updates: { recovery_deadline: deadline, recovery_elapsed_ms: elapsed } });
         });
     }
     return { load, find, accept, advance, cancel, cancelPending, captureSession, clearSession, guardTool, completeTool, recoveryClock };

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

@@ -131,7 +131,7 @@ export function createChatRunLedger({ kernel: hostKernel, isDaemonRunId }, { now
             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());
+                    .where(activeRunPredicate({ run: settlement })).executeTakeFirst());
                 if (!saved)
                     return false;
                 const content = settlement.content.length >= saved.content.length ? settlement.content : saved.content;
@@ -149,7 +149,7 @@ export function createChatRunLedger({ kernel: hostKernel, isDaemonRunId }, { now
                     run_status: settlement.status,
                     ended_at: settlement.endedAt,
                 })
-                    .where((eb) => eb.and([isRunRow(eb, settlement), notTerminal(eb)]))
+                    .where(activeRunPredicate({ run: settlement }))
                     .executeTakeFirst());
                 if (Number(result.numUpdatedRows) === 0)
                     return false;
@@ -165,7 +165,7 @@ export function createChatRunLedger({ kernel: hostKernel, isDaemonRunId }, { now
             return kernel.transaction(async () => {
                 await kernel.lockKey(runLockKey(progress));
                 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());
+                    .where(activeRunPredicate({ run: progress })).executeTakeFirst());
                 if (!current || progress.content.length < current.content.length)
                     return false;
                 const { eventsJson, runStatus, grown, unchanged } = planCheckpoint({ current, progress });
@@ -178,7 +178,7 @@ export function createChatRunLedger({ kernel: hostKernel, isDaemonRunId }, { now
                 const result = await kernel.run((db) => db
                     .updateTable("ai_chat_messages")
                     .set({ content: progress.content, events_json: eventsJson, run_status: runStatus })
-                    .where((eb) => eb.and([isRunRow(eb, progress), notTerminal(eb)]))
+                    .where(activeRunPredicate({ run: progress }))
                     .executeTakeFirst());
                 if (Number(result.numUpdatedRows) > 0 && grown) {
                     // Progress earns a fresh recovery budget. Replayed prefixes and the coordinator's
@@ -246,4 +246,7 @@ export function createChatRunLedger({ kernel: hostKernel, isDaemonRunId }, { now
         },
     };
 }
+function activeRunPredicate({ run }) {
+    return (eb) => eb.and([isRunRow(eb, run), notTerminal(eb)]);
+}
 //# sourceMappingURL=run-ledger.js.map

package/dist/store/sql/boundary.js

@@ -6,7 +6,9 @@ export function validateKernel({ kernel, transports, dialect }) {
 }
 /** Copy primitive identity fields so subsequent caller mutation cannot rebind the store. */
 export function copyScope({ scope }) {
-    if (!scope || typeof scope.scopeId !== 'string' || !scope.scopeId || typeof scope.ownerId !== 'string' || !scope.ownerId || !['user', 'guest'].includes(scope.ownerKind)) {
+    if (!scope || typeof scope.scopeId !== 'string' || !scope.scopeId)
+        throw new ChatStoreError({ code: 'invalid-input' });
+    if (typeof scope.ownerId !== 'string' || !scope.ownerId || !['user', 'guest'].includes(scope.ownerKind)) {
         throw new ChatStoreError({ code: 'invalid-input' });
     }
     return { scopeId: scope.scopeId, ownerKind: scope.ownerKind, ownerId: scope.ownerId };

package/dist/store/sql/cursor.js

@@ -1,3 +1,4 @@
+import { trimCharsEnd } from '@jini-ai/core/primitives';
 import { ChatStoreError } from '../errors.js';
 /** Reject bad limits before accessing any storage. */
 export function pageLimit({ options }) {
@@ -14,7 +15,7 @@ function ownerTuple(scope) {
 export function encodeCursor({ kind, scope, conversation, anchor }) {
     const bytes = new TextEncoder().encode(JSON.stringify([1, kind, ownerTuple(scope), conversation, anchor]));
     const binary = Array.from(bytes, byte => String.fromCharCode(byte)).join('');
-    return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '');
+    return trimCharsEnd({ text: btoa(binary).replaceAll('+', '-').replaceAll('/', '_'), chars: '=' });
 }
 /** Every structural failure is the same refusal; callers never learn which check rejected it. */
 function invalidCursor() {
@@ -38,7 +39,9 @@ function decodeBody({ cursor }) {
 }
 /** Version, exact length, read kind and conversation binding. */
 function readEnvelope({ value, kind, conversation }) {
-    if (!Array.isArray(value) || value.length !== 5 || value[0] !== 1 || value[1] !== kind || value[3] !== conversation)
+    if (!Array.isArray(value) || value.length !== 5)
+        invalidCursor();
+    if (value[0] !== 1 || value[1] !== kind || value[3] !== conversation)
         invalidCursor();
     return value;
 }
@@ -50,7 +53,9 @@ function assertOwner({ owner, scope }) {
 }
 /** A [finite number, string] pair; message positions must also be non-negative safe integers. */
 function readAnchor({ anchor, kind }) {
-    if (!Array.isArray(anchor) || anchor.length !== 2 || typeof anchor[0] !== 'number' || !Number.isFinite(anchor[0]) || typeof anchor[1] !== 'string') {
+    if (!Array.isArray(anchor) || anchor.length !== 2)
+        invalidCursor();
+    if (typeof anchor[0] !== 'number' || !Number.isFinite(anchor[0]) || typeof anchor[1] !== 'string') {
         invalidCursor();
     }
     if (kind === 'messages' && (!Number.isSafeInteger(anchor[0]) || anchor[0] < 0))

package/dist/store/sql/store.js

@@ -1,3 +1,5 @@
+const MESSAGE_POSITION = 'm.position';
+const CONVERSATION_UPDATED_AT = 'c.updated_at';
 /** One SQL query body upstreamed from the existing host adapter; no resource/schema ownership. */
 // Legacy project/conversation CRUD trusts access to a local database file; this owner-bound store
 // serves shared databases instead. Choose by trust model: borrowing a handle must not grant access
@@ -96,7 +98,9 @@ function runFields(row) {
 }
 /** Reject an unbounded or malformed history read before any query runs. */
 function assertHistoryReadBounds({ limit, fromPosition }) {
-    if (!Number.isInteger(limit) || limit < 1 || limit > 100 || (fromPosition !== undefined && (!Number.isSafeInteger(fromPosition) || fromPosition < 0))) {
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+        throw new ChatStoreError({ code: 'invalid-input' });
+    if (fromPosition !== undefined && (!Number.isSafeInteger(fromPosition) || fromPosition < 0)) {
         throw new ChatStoreError({ code: 'invalid-input' });
     }
 }
@@ -139,7 +143,7 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
             "c.title",
             "c.title_source",
             "c.created_at",
-            "c.updated_at",
+            CONVERSATION_UPDATED_AT,
             "c.expires_at",
             eb
                 .selectFrom("ai_chat_messages as m")
@@ -182,7 +186,7 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
     }
     /** Read owned messages in persisted position order; foreign IDs produce no rows. */
     async function messages({ conversationId }, _optional = {}) {
-        const rows = await run(db => ownedMessages(db, conversationId).orderBy('m.position').execute());
+        const rows = await run(db => ownedMessages(db, conversationId).orderBy(MESSAGE_POSITION).execute());
         return rows.map(toMessage);
     }
     /** Writes and projects one message inside the borrowed transaction; null for absent/foreign IDs. */
@@ -226,18 +230,7 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
                 started_at: m.startedAt ?? null,
                 ended_at: m.endedAt ?? null,
             })
-                .onConflict((oc) => oc
-                .column("id")
-                .doUpdateSet((eb) => ({
-                content: eb.ref("excluded.content"),
-                events_json: eb.ref("excluded.events_json"),
-                attachments_json: eb.ref("excluded.attachments_json"),
-                run_id: eb.ref("excluded.run_id"),
-                run_status: eb.ref("excluded.run_status"),
-                started_at: eb.ref("excluded.started_at"),
-                ended_at: eb.ref("excluded.ended_at"),
-            }))
-                .where((eb) => eb("ai_chat_messages.conversation_id", "=", eb.ref("excluded.conversation_id"))))
+                .onConflict(updateOwnedMessageConflict)
                 .execute());
             // A new message is activity: the list orders by `updated_at`.
             await run((db) => db.updateTable("ai_chats").set({ updated_at: clock.nowMs() }).where("id", "=", conversationId).execute());
@@ -260,7 +253,9 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
              * @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))) {
+                if (!Number.isInteger(limit) || limit < 1 || limit > 50)
+                    throw new ChatStoreError({ code: 'invalid-input' });
+                if (query !== undefined && (typeof query !== 'string' || query.length > 200)) {
                     throw new ChatStoreError({ code: 'invalid-input' });
                 }
                 const rows = await run(db => {
@@ -277,7 +272,7 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
                                 .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 statement.orderBy(CONVERSATION_UPDATED_AT, 'desc').orderBy(ordinalId(kernel.dialect, 'c.id')).limit(limit).execute();
                 });
                 return rows.map(row => ({ ...toConversation(row), firstUserLine: row.first_user_line ?? '' }));
             },
@@ -286,12 +281,12 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
                 assertHistoryReadBounds({ limit, fromPosition });
                 const rows = await run(db => {
                     let statement = ownedMessages(db, chatId).clearSelect().select([
-                        'm.id', 'm.role', 'm.content', 'm.position', 'm.created_at',
+                        'm.id', 'm.role', 'm.content', MESSAGE_POSITION, 'm.created_at',
                     ]);
                     if (fromPosition !== undefined)
-                        statement = statement.where('m.position', '>=', fromPosition);
+                        statement = statement.where(MESSAGE_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();
+                        .orderBy(MESSAGE_POSITION, fromPosition === undefined ? 'desc' : 'asc').limit(limit + 1).execute();
                 });
                 const page = rows.slice(0, limit);
                 if (fromPosition === undefined)
@@ -300,7 +295,7 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
             },
         },
         async list() {
-            const rows = await run((db) => ownedConversations(db).orderBy("c.updated_at", "desc").execute());
+            const rows = await run((db) => ownedConversations(db).orderBy(CONVERSATION_UPDATED_AT, "desc").execute());
             return rows.map((row) => toConversation(row));
         },
         get,
@@ -387,10 +382,10 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
                 let query = ownedConversations(db);
                 if (anchor)
                     query = query.where(eb => eb.or([
-                        eb('c.updated_at', '<', anchor[0]),
-                        eb.and([eb('c.updated_at', '=', anchor[0]), eb(id, '>', anchor[1])]),
+                        eb(CONVERSATION_UPDATED_AT, '<', anchor[0]),
+                        eb.and([eb(CONVERSATION_UPDATED_AT, '=', anchor[0]), eb(id, '>', anchor[1])]),
                     ]));
-                return query.orderBy('c.updated_at', 'desc').orderBy(id, 'asc').limit(limit + 1).execute();
+                return query.orderBy(CONVERSATION_UPDATED_AT, 'desc').orderBy(id, 'asc').limit(limit + 1).execute();
             });
             const items = rows.slice(0, limit).map(row => toConversation(row));
             const last = items.at(-1);
@@ -404,13 +399,13 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
             const id = ordinalId(kernel.dialect, 'm.id');
             // One join, at most limit+1 rows, including the ownership check; no parent pre-read.
             const rows = await run(db => {
-                let query = ownedMessages(db, input.conversationId).select('m.position');
+                let query = ownedMessages(db, input.conversationId).select(MESSAGE_POSITION);
                 if (anchor)
                     query = query.where(eb => eb.or([
-                        eb('m.position', '>', anchor[0]),
-                        eb.and([eb('m.position', '=', anchor[0]), eb(id, '>', anchor[1])]),
+                        eb(MESSAGE_POSITION, '>', anchor[0]),
+                        eb.and([eb(MESSAGE_POSITION, '=', anchor[0]), eb(id, '>', anchor[1])]),
                     ]));
-                return query.orderBy('m.position', 'asc').orderBy(id, 'asc').limit(limit + 1).execute();
+                return query.orderBy(MESSAGE_POSITION, 'asc').orderBy(id, 'asc').limit(limit + 1).execute();
             });
             const page = rows.slice(0, limit), last = page.at(-1);
             return { items: page.map(toMessage), ...(rows.length > limit && last ? {
@@ -435,4 +430,17 @@ export function createSqlChatStore({ kernel, scope: inputScope }, { clock = crea
         pageMessages: (required, optional = {}) => atStoreBoundary({ operation: () => store.pageMessages(required, optional) }),
     };
 }
+function updateOwnedMessageConflict(oc) {
+    return oc.column("id")
+        .doUpdateSet((eb) => ({
+        content: eb.ref("excluded.content"),
+        events_json: eb.ref("excluded.events_json"),
+        attachments_json: eb.ref("excluded.attachments_json"),
+        run_id: eb.ref("excluded.run_id"),
+        run_status: eb.ref("excluded.run_status"),
+        started_at: eb.ref("excluded.started_at"),
+        ended_at: eb.ref("excluded.ended_at"),
+    }))
+        .where((eb) => eb("ai_chat_messages.conversation_id", "=", eb.ref("excluded.conversation_id")));
+}
 //# sourceMappingURL=store.js.map