@jini-ai/chat 0.6.5 → 0.6.7

package/dist/core/durable-projection.js

@@ -21,6 +21,20 @@ function identity(event, usageOccurrences) {
 function textOf(events) {
     return events.filter((event) => event.kind === 'text').map((event) => event.text).join('');
 }
+/** Records `key` and reports whether it was new, so each identifiable event is merged once. */
+function claimNewKey({ key, keys }) {
+    if (keys.has(key))
+        return false;
+    keys.add(key);
+    return true;
+}
+const NO_ROLLOUT = /no rollout found for thread id/;
+/** The missing native resume diagnostic, in either the status or the raw-line form a runtime emits. */
+function isNoRolloutDiagnostic({ event }) {
+    if (event.kind === 'status')
+        return NO_ROLLOUT.test(`${event.label}\n${event.detail ?? ''}`);
+    return event.kind === 'raw' && NO_ROLLOUT.test(event.line);
+}
 /** Saved checkpoints can coalesce deltas and a completion may replay only a prefix. Keep the
  * saved projection, merge identifiable events, and append only text beyond its saved prefix. */
 export function mergeRunEvents({ saved, incoming }, _optional = {}) {
@@ -39,12 +53,8 @@ export function mergeRunEvents({ saved, incoming }, _optional = {}) {
             if (text)
                 result.push({ ...event, text });
         }
-        else {
-            const key = identity(event, incomingUsage);
-            if (!keys.has(key)) {
-                keys.add(key);
-                result.push(event);
-            }
+        else if (claimNewKey({ key: identity(event, incomingUsage), keys })) {
+            result.push(event);
         }
     }
     return result;
@@ -84,16 +94,13 @@ export function recoveredRunEvents({ saved }, { notice = 'visible' } = {}) {
         // A missing rollout is an expected reconstruction fallback, not a failed user turn. Keep an
         // invisible attempt marker for fencing/diagnostic offsets, and preserve all unrelated work.
         const attemptStart = saved.findLastIndex(event => event.kind === 'status' && event.code === 'run_recovering') + 1;
-        const diagnostic = saved.findIndex((event, index) => index >= attemptStart && ((event.kind === 'status' && /no rollout found for thread id/.test(`${event.label}\n${event.detail ?? ''}`)) ||
-            (event.kind === 'raw' && /no rollout found for thread id/.test(event.line))));
+        const diagnostic = saved.findIndex((event, index) => index >= attemptStart && isNoRolloutDiagnostic({ event }));
         const events = saved.filter((event, index) => {
             if (diagnostic < 0 || index < attemptStart)
                 return true;
-            if (event.kind === 'raw')
-                return !/no rollout found for thread id/.test(event.line);
-            if (event.kind === 'status')
-                return event.label !== 'Run failed — the agent process exited without answering' && !/no rollout found for thread id/.test(`${event.label}\n${event.detail ?? ''}`);
-            return true;
+            if (event.kind === 'status' && event.label === 'Run failed — the agent process exited without answering')
+                return false;
+            return !isNoRolloutDiagnostic({ event });
         });
         return [...events, { kind: 'status', code: 'run_recovering', label: '' }];
     }

package/dist/core/durable-runs/continuation.d.ts

@@ -11,6 +11,10 @@ export declare function hasUnknownToolCall({ events, toolId, input }: {
     toolId: string;
     input: unknown;
 }, _optional?: {}): boolean;
+/** Reconstruct one attempt from the accepted task and its saved work, including plugin consent.
+ * Returns a new request without changing the accepted input or transcript; invalid context JSON throws.
+ * @complexity O(e + t) time/space in saved events and transcript text; no external effects.
+ */
 export declare function continuationRequest({ run, native }: {
     run: DurableRun;
     native: boolean;

package/dist/core/durable-runs/continuation.js

@@ -22,6 +22,9 @@ export function hasUnknownToolCall({ events, toolId, input }, _optional = {}) {
     return events.some((event) => {
         if (event.kind !== "tool_use" || completed.has(event.id))
             return false;
+        // The read-only gateway either reads or refuses before execution; neither can leave a mutation.
+        if (/execute_readonly_delegated_tool$/.test(event.name))
+            return false;
         const call = delegatedCall(event);
         return call.toolId === toolId && canonicalToolInput({ value: call.input }, {}) === canonical;
     });
@@ -33,23 +36,49 @@ function toolHistory(events) {
         return JSON.stringify({ call: delegatedCall(event), result: result ?? "OUTCOME UNKNOWN: verify state before repeating" });
     }).join("\n");
 }
-export function continuationRequest({ run, native }, _optional = {}) {
-    const original = JSON.parse(run.request.contextRef);
+/** The accepted browser state predates this turn's Ask answer. A replacement attempt must
+ * carry the latest saved decision, including Skip, instead of asking from that frozen state.
+ * Scan backwards so recovery markers and unrelated extensions cannot hide the last answer.
+ */
+function latestAgentPluginState({ events, conversationId, accepted }, _optional = {}) {
+    for (let index = events.length - 1; index >= 0; index--) {
+        const event = events[index];
+        if (event.kind !== "ext" || event.name !== "agent_plugins")
+            continue;
+        const usage = event.data;
+        if (usage?.conversationId === conversationId && usage.state)
+            return usage.state;
+    }
+    return accepted;
+}
+function continuationPrompt({ run, native, acceptedPrompt, events }, _optional = {}) {
     // Native sessions may have disappeared on deploy. Reconstruction includes the saved answer
     // and tool results for every runtime; completed side effects must never be silently repeated.
     const transcript = run.transcript.map((message) => `${message.role}: ${message.content}`).join("\n\n");
-    const prompt = [
+    return [
         "Continue the interrupted answer from the saved work below. Preserve completed work. Do not repeat completed mutations.",
+        "Omission markers in the saved work are system housekeeping, not user content; do not mention them to the user or infer a user disclosure from them.",
         "Calls without a result have an unknown outcome: inspect current state before any retry. Expired plans or approvals must be re-planned and re-approved; never reuse them.",
-        "A pending question may be asked again when its process was lost. The interrupted segment remains visible; append the continuation.",
-        `Accepted task:\n${String(original.prompt ?? "")}`,
+        "Never re-ask a pending question in this turn. The interrupted segment remains visible; append the continuation.",
+        `Accepted task:\n${String(acceptedPrompt ?? "")}`,
         native ? "Native session is confirmed; continue its saved task." : `Saved conversation:\n${transcript}`,
         `Saved partial answer:\n${run.message.content}`,
-        `Saved tool calls and results:\n${toolHistory(run.message.events ?? [])}`,
+        `Saved tool calls and results:\n${toolHistory(events)}`,
     ].join("\n\n");
+}
+/** Reconstruct one attempt from the accepted task and its saved work, including plugin consent.
+ * Returns a new request without changing the accepted input or transcript; invalid context JSON throws.
+ * @complexity O(e + t) time/space in saved events and transcript text; no external effects.
+ */
+export function continuationRequest({ run, native }, _optional = {}) {
+    const original = JSON.parse(run.request.contextRef);
+    const events = run.message.events ?? [];
+    const agentPluginState = latestAgentPluginState({ events, conversationId: run.conversationId, accepted: original.agentPluginState }, {});
+    const prompt = continuationPrompt({ run, native, acceptedPrompt: original.prompt, events }, {});
     return {
         ...run.request,
         contextRef: JSON.stringify({ ...original, prompt, conversationId: run.conversationId,
+            ...(agentPluginState === undefined ? {} : { agentPluginState }),
             assistantMessageId: run.messageId, principalId: run.principalId,
             recoveryMode: native ? "native" : "reconstruction", recoverySessionId: native ? run.sessionId : undefined,
             // Old attachment claims have been consumed. Saved transcript/tool results carry their

package/dist/core/durable-runs/ledger-contracts.d.ts

@@ -40,7 +40,8 @@ export interface ChatRunLedger {
     /**
      * Saves what a still-running run has produced so far (content and events; the status stays), so
      * a process that dies mid-run leaves its partial answer for {@link reconcileInterrupted} to keep.
-     * A no-op once the row is terminal or belongs to another run. Resolves `true` when it wrote.
+     * A no-op once the row is terminal or belongs to another run. Resolves `true` when it wrote, or
+     * when the row already held exactly this checkpoint (accepted without rewriting the row).
      */
     checkpoint(progress: RunProgress, optional?: {}): Promise<boolean>;
     /** Serving-only discovery of unfinished rows. The injected recovery coordinator owns adopted

package/dist/core/durable-runs/policies.d.ts

@@ -2,5 +2,6 @@ export declare const RECOVERY_LIMIT = 3;
 export declare const RECOVERY_WINDOW_MS: number;
 export declare const RUN_STALENESS_MS: number;
 export declare const SAVED_WORK_NOTICE = "The assistant stopped after making no progress. Saved work is above.";
+export declare const AWAITING_ANSWER_NOTICE = "The assistant stopped while waiting for your answer. Saved work is above.";
 export declare const EXHAUSTED_NOTICE = "The assistant could not continue this answer. Saved work is above.";
 //# sourceMappingURL=policies.d.ts.map

package/dist/core/durable-runs/policies.js

@@ -2,5 +2,6 @@ export const RECOVERY_LIMIT = 3;
 export const RECOVERY_WINDOW_MS = 5 * 60_000;
 export const RUN_STALENESS_MS = 30 * 60_000;
 export const SAVED_WORK_NOTICE = "The assistant stopped after making no progress. Saved work is above.";
+export const AWAITING_ANSWER_NOTICE = "The assistant stopped while waiting for your answer. Saved work is above.";
 export const EXHAUSTED_NOTICE = "The assistant could not continue this answer. Saved work is above.";
 //# sourceMappingURL=policies.js.map

package/dist/core/durable-runs/ports.d.ts

@@ -1,5 +1,5 @@
 import type { AgentEvent, ChatMessage } from "../index.js";
-import type { RunRef, RunSettlement } from "./ledger-contracts.js";
+import type { RunRef, RunSettlement } from "./run-contracts.js";
 export interface AcceptedRunRequest {
     readonly agentId?: string;
     readonly contextRef: string;
@@ -24,14 +24,18 @@ export interface DurableRun extends RunRef {
     } | null;
     readonly attemptBase: readonly AgentEvent[];
 }
+/** A run without its conversation transcript: what a fence, lock or tool guard reads. `message`
+ * still carries the run's own saved events; only `load`/`accept`/`cancelPending` read every message. */
+export type DurableRunHead = Omit<DurableRun, "transcript">;
 export interface DurableRunStore {
     load(required: {
         messageId: string;
     }, optional: {}): Promise<DurableRun | null>;
+    /** Reads only this run's message and attempt rows; `load` when the transcript is needed. */
     find(required: {
         runId: string;
         principalId?: string;
-    }, optional: {}): Promise<DurableRun | null>;
+    }, optional: {}): Promise<DurableRunHead | null>;
     accept(required: RunRef & {
         principalId: string;
         workspaceId: string;

package/dist/core/index.d.ts

@@ -5,6 +5,7 @@
  */
 export * from './events.js';
 export * from './messages.js';
+export * from './conversation-title.js';
 export * from './partial-json.js';
 export * from './tool-events.js';
 export * from './tool-output.js';
@@ -36,4 +37,5 @@ export * from './user-text-redaction.js';
 export * from './history-tool-metadata.js';
 export { turnUsage, conversationUsage, replySegments, isReplyBoundary, MID_RUN_USER_MESSAGE_EVENT_NAME, type ChatUsageSummary } from './turn-usage.js';
 export { formatUsageCost } from './usage-format.js';
+export * from './accepted-input.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -5,6 +5,7 @@
  */
 export * from './events.js';
 export * from './messages.js';
+export * from './conversation-title.js';
 export * from './partial-json.js';
 export * from './tool-events.js';
 export * from './tool-output.js';
@@ -35,4 +36,5 @@ export * from './user-text-redaction.js';
 export * from './history-tool-metadata.js';
 export { turnUsage, conversationUsage, replySegments, isReplyBoundary, MID_RUN_USER_MESSAGE_EVENT_NAME } from './turn-usage.js';
 export { formatUsageCost } from './usage-format.js';
+export * from './accepted-input.js';
 //# sourceMappingURL=index.js.map

package/dist/core/messages.d.ts

@@ -33,6 +33,8 @@ export interface ChatAttachment {
  * host layers those on top via its own message extension, not this type.
  */
 export interface ChatMessage {
+    /** A normal send stays outside recall until the transport accepts it. */
+    inputPending?: boolean;
     /** Transient safe receipt; storage requires no new column. */
     secretRedaction?: import('./user-text-redaction.js').SecretRedactionSignal;
     id: string;

package/dist/core/partial-json.d.ts

@@ -16,25 +16,24 @@
  * open-container stack, then closing whatever is still open.
  *
  * @param buf - A possibly-incomplete JSON text (a streamed prefix).
- * @returns A best-effort syntactically-closed JSON text. Not guaranteed to
- *   parse (e.g. an empty buffer round-trips unchanged) — callers should still
+ * @returns Empty text above 64 Ki characters or for non-JSON tails that never settle; otherwise
+ *   best-effort closed JSON. Not guaranteed to parse (e.g. an empty buffer round-trips unchanged) — callers should still
  *   wrap consumption in `JSON.parse`/try-catch (see {@link parsePartialJson}).
  * @complexity O(n) time / O(d) space in the input length `n` and max nesting
- *   depth `d` — one linear scan plus a bounded fixed-point cleanup loop over
- *   the (already shrinking) tail.
+ *   depth `d` — one linear scan plus at most 8 linear cleanup passes over the tail.
  */
 export declare function repairJsonPrefix({ buf }: {
     buf: string;
-}): string;
+}, _optional?: {}): string;
 /**
  * Best-effort parse of a (possibly truncated) JSON prefix.
  *
  * @param buf - A possibly-incomplete JSON text.
- * @returns The parsed value, or `null` on empty input or an unrecoverable
+ * @returns The parsed value, or `null` on input above 64 Ki characters, empty input or an unrecoverable
  *   parse failure — callers should fall back to their last good value.
  * @complexity O(n) — dominated by {@link repairJsonPrefix}.
  */
 export declare function parsePartialJson({ buf }: {
     buf: string;
-}): unknown;
+}, _optional?: {}): unknown;
 //# sourceMappingURL=partial-json.d.ts.map

package/dist/core/partial-json.js

@@ -10,32 +10,32 @@
  * structure that simply hasn't finished — not arbitrary corruption. Callers
  * should still keep their last good parsed result as a fallback.
  */
-/**
- * Repair a truncated JSON prefix into the largest valid JSON text that can be
- * parsed, by walking the buffer once to track string/escape state and the
- * open-container stack, then closing whatever is still open.
- *
- * @param buf - A possibly-incomplete JSON text (a streamed prefix).
- * @returns A best-effort syntactically-closed JSON text. Not guaranteed to
- *   parse (e.g. an empty buffer round-trips unchanged) — callers should still
- *   wrap consumption in `JSON.parse`/try-catch (see {@link parsePartialJson}).
- * @complexity O(n) time / O(d) space in the input length `n` and max nesting
- *   depth `d` — one linear scan plus a bounded fixed-point cleanup loop over
- *   the (already shrinking) tail.
- */
-export function repairJsonPrefix({ buf }) {
+// Bound repair and JSON.parse work for untrusted model-generated structured output.
+const MAX_STRUCTURED_INPUT_CHARS = 64 * 1024;
+// A valid streamed prefix settles in two cleanup passes (cut value, then its key/comma). Input
+// needing more is not JSON (`[t,t,t,…`), and each extra pass would rescan the whole buffer.
+const MAX_TAIL_CLEANUP_PASSES = 8;
+/** Linear form of `/[,\s]+$/`, which V8 retries from every separator in a long run (quadratic). */
+function trimTrailingSeparators({ text }, _optional = {}) {
+    let end = text.length;
+    while (end > 0 && /[,\s]/.test(text[end - 1]))
+        end -= 1;
+    return text.slice(0, end);
+}
+/** Consume one quoted character; an escaped quote does not end the string. */
+function advanceJsonString({ c, esc }, _optional = {}) {
+    if (esc)
+        return { inStr: true, esc: false };
+    return { inStr: c !== '"', esc: c === '\\' };
+}
+/** Track strings/escapes and owed container closers in one pass over a bounded JSON prefix. */
+function scanJsonPrefix({ buf }, _optional = {}) {
     const stack = []; // closers owed, e.g. ['}', ']']
     let inStr = false;
     let esc = false;
-    for (let i = 0; i < buf.length; i++) {
-        const c = buf[i];
+    for (const c of buf) {
         if (inStr) {
-            if (esc)
-                esc = false;
-            else if (c === '\\')
-                esc = true;
-            else if (c === '"')
-                inStr = false;
+            ({ inStr, esc } = advanceJsonString({ c, esc }));
             continue;
         }
         if (c === '"')
@@ -47,19 +47,23 @@ export function repairJsonPrefix({ buf }) {
         else if (c === '}' || c === ']')
             stack.pop();
     }
-    let out = buf;
-    // 1. Close a string cut off mid-value (or mid-key). First neutralize a
-    //    dangling escape at the cut point, otherwise the closing quote would be
-    //    swallowed (`...x\` + `"` → escaped quote) or a partial `\uXXXX` would
-    //    be an invalid escape — either makes JSON.parse fail and collapses the
-    //    live preview. Common in prompts that mention Windows paths, regexes,
-    //    or escaped quotes.
-    if (inStr) {
-        out = out.replace(/\\u[0-9a-fA-F]{0,3}$/, ''); // incomplete \uXXXX
-        if (/(?:^|[^\\])(?:\\\\)*\\$/.test(out))
-            out = out.slice(0, -1); // lone trailing backslash
-        out += '"';
-    }
+    return { stack, inStr };
+}
+/** Close a string cut off mid-value (or mid-key). First neutralize a
+ * dangling escape at the cut point, otherwise the closing quote would be
+ * swallowed (`...x\` + `"` → escaped quote) or a partial `\uXXXX` would
+ * be an invalid escape — either makes JSON.parse fail and collapses the
+ * live preview. Common in prompts that mention Windows paths, regexes,
+ * or escaped quotes.
+ */
+function closeJsonString({ out }, _optional = {}) {
+    out = out.replace(/\\u[0-9a-fA-F]{0,3}$/, ''); // incomplete \uXXXX
+    if (/(?:^|[^\\])(?:\\\\)*\\$/.test(out))
+        out = out.slice(0, -1); // lone trailing backslash
+    return out + '"';
+}
+/** Returns null when the tail never settles within the pass bound. */
+function trimIncompleteTail({ out }, _optional = {}) {
     // 2. Trim trailing structural noise that can't be completed into a value:
     //    a dangling comma, a `"key":` with no value yet, and an unfinished
     //    *scalar* value cut mid-token (a partial `true`/`false`/`null`, or a
@@ -70,42 +74,72 @@ export function repairJsonPrefix({ buf }) {
     //    `1.5`, `1e3`) are not prefixes of these patterns, so they survive.
     const valueStart = '([:[,]\\s*)';
     let prev;
+    let passes = 0;
     do {
+        if (++passes > MAX_TAIL_CLEANUP_PASSES)
+            return null;
         prev = out;
-        out = out.replace(/[,\s]+$/, '');
+        out = trimTrailingSeparators({ text: out });
         out = out.replace(/"(?:[^"\\]|\\.)*"\s*:\s*$/, ''); // key + colon, no value
         out = out.replace(new RegExp(`${valueStart}(?:tru|tr|t|fals|fal|fa|f|nul|nu|n)$`), '$1'); // partial bool/null
-        out = out.replace(new RegExp(`${valueStart}-?(?:\\d+\\.?\\d*|\\d*\\.\\d+)?[eE][+-]?$`), '$1'); // dangling exponent
+        out = out.replace(new RegExp(`${valueStart}-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)?[eE][+-]?$`), '$1'); // dangling exponent
         out = out.replace(new RegExp(`${valueStart}-?\\d*\\.$`), '$1'); // number ending in '.'
         out = out.replace(new RegExp(`${valueStart}-$`), '$1'); // lone minus
         out = out.replace(/"(?:[^"\\]|\\.)*"\s*:\s*$/, ''); // key + colon exposed by the trims above
-        out = out.replace(/[,\s]+$/, '');
+        out = trimTrailingSeparators({ text: out });
     } while (out !== prev);
-    // A bare trailing key (string with no following colon) only happens when
-    // the *innermost* open container is an object. Drop it so we don't emit
-    // `{"hea"}` which is invalid (key without value).
+    return out;
+}
+/**
+ * Repair a truncated JSON prefix into the largest valid JSON text that can be
+ * parsed, by walking the buffer once to track string/escape state and the
+ * open-container stack, then closing whatever is still open.
+ *
+ * @param buf - A possibly-incomplete JSON text (a streamed prefix).
+ * @returns Empty text above 64 Ki characters or for non-JSON tails that never settle; otherwise
+ *   best-effort closed JSON. Not guaranteed to parse (e.g. an empty buffer round-trips unchanged) — callers should still
+ *   wrap consumption in `JSON.parse`/try-catch (see {@link parsePartialJson}).
+ * @complexity O(n) time / O(d) space in the input length `n` and max nesting
+ *   depth `d` — one linear scan plus at most 8 linear cleanup passes over the tail.
+ */
+export function repairJsonPrefix({ buf }, _optional = {}) {
+    if (buf.length > MAX_STRUCTURED_INPUT_CHARS)
+        return '';
+    const { stack, inStr } = scanJsonPrefix({ buf });
+    const settled = trimIncompleteTail({ out: inStr ? closeJsonString({ out: buf }) : buf });
+    if (settled === null)
+        return '';
+    let out = dropPendingKey({ out: settled, stack });
+    // 3. Close every still-open container, innermost first.
+    for (let i = stack.length - 1; i >= 0; i--)
+        out += stack[i];
+    return out;
+}
+// A bare trailing key (string with no following colon) only happens when
+// the *innermost* open container is an object. Drop it so we don't emit
+// `{"hea"}` which is invalid (key without value).
+function dropPendingKey({ out, stack }, _optional = {}) {
     if (stack[stack.length - 1] === '}' && /"(?:[^"\\]|\\.)*"\s*$/.test(out)) {
         const trimmed = out.replace(/"(?:[^"\\]|\\.)*"\s*$/, '');
         // Only drop it if what precedes is a container/comma boundary (i.e. the
         // string really is a pending key, not a completed value like `:"x"`).
         if (/[{,]\s*$/.test(trimmed)) {
-            out = trimmed.replace(/[,\s]+$/, '');
+            out = trimTrailingSeparators({ text: trimmed });
         }
     }
-    // 3. Close every still-open container, innermost first.
-    for (let i = stack.length - 1; i >= 0; i--)
-        out += stack[i];
     return out;
 }
 /**
  * Best-effort parse of a (possibly truncated) JSON prefix.
  *
  * @param buf - A possibly-incomplete JSON text.
- * @returns The parsed value, or `null` on empty input or an unrecoverable
+ * @returns The parsed value, or `null` on input above 64 Ki characters, empty input or an unrecoverable
  *   parse failure — callers should fall back to their last good value.
  * @complexity O(n) — dominated by {@link repairJsonPrefix}.
  */
-export function parsePartialJson({ buf }) {
+export function parsePartialJson({ buf }, _optional = {}) {
+    if (buf.length > MAX_STRUCTURED_INPUT_CHARS)
+        return null;
     const trimmed = buf.trim();
     if (!trimmed)
         return null;

package/dist/core/persistence/title.js

@@ -126,8 +126,9 @@ function truncateTitle(title) {
     const lastSpace = prefix.lastIndexOf(' ');
     return (lastSpace > 0 ? prefix.slice(0, lastSpace) : prefix).trimEnd();
 }
+/** Callers pass only non-empty words (`trimLatinTitle` filters blanks before mapping). */
 function toTitleCase(word) {
-    return word ? word.charAt(0).toUpperCase() + word.slice(1).toLowerCase() : word;
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
 }
 function trimLatinTitle(input, { casing }) {
     const words = input
@@ -164,7 +165,8 @@ export function deriveConversationTitle({ prompt }, { casing = 'title' } = {}) {
     const cleaned = cleanPrompt(prompt);
     if (!cleaned)
         return '';
-    const firstClause = cleaned.split(/[\n\r。！？!?]/)[0]?.trim() ?? cleaned;
+    // `split` always yields a first element, even for a string that starts with a separator.
+    const firstClause = cleaned.split(/[\n\r。！？!?]/)[0].trim();
     if (!firstClause)
         return '';
     const title = CJK_PATTERN.test(firstClause) ? trimCjkTitle(firstClause) : trimLatinTitle(firstClause, { casing });

package/dist/core/question-answer.d.ts

@@ -0,0 +1,23 @@
+/** Read a classified result or delivered callback as plain user text. Decline wins over other fields;
+ * expiry, invalid answers and unrecognized results produce no user message.
+ * @returns Answer text, or undefined when no supported human answer is present; never throws.
+ * @example questionAnswerText({ answer: { submitted: true, freeText: 'Custom theme' } })
+ * @complexity O(p + s*m) time, O(s) space for p single options, s selections, m multi options; no I/O.
+ */
+export declare function questionAnswerText({ answer, input }: {
+    answer: unknown;
+    input?: unknown;
+}, _options?: {}): string | undefined;
+/** Decode the persisted JSON result; failed tools and non-answer payloads never become user text.
+ * @returns Plain answer text or undefined for missing, failed or malformed results; never throws.
+ * @example questionAnswerFromResult({ result: { content: '{"submitted":true,"choice":"Blue"}', isError: false } })
+ * @complexity O(r + p + s*m) time, O(r + s) space including JSON decoding of r result characters.
+ */
+export declare function questionAnswerFromResult({ result, input }: {
+    result: {
+        content: string;
+        isError: boolean;
+    } | undefined;
+    input?: unknown;
+}, _options?: {}): string | undefined;
+//# sourceMappingURL=question-answer.d.ts.map

package/dist/core/question-answer.js

@@ -0,0 +1,66 @@
+/** @module question-answer — plain transcript text from the ask-choice result contract. */
+function record(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}
+/** Resolve a stored option value through the question that offered it. Unknown values stay readable. */
+function optionLabel(group, value) {
+    const options = record(group).options;
+    if (!Array.isArray(options))
+        return value;
+    const option = options.find(candidate => record(candidate).value === value);
+    const label = record(option).label;
+    return typeof label === 'string' ? label : value;
+}
+function selectedAnswerText({ result, input }, _options = {}) {
+    const question = record(input);
+    const labels = [];
+    if (typeof result.choice === 'string')
+        labels.push(optionLabel(question.singleSelect, result.choice));
+    if (Array.isArray(result.selections)) {
+        for (const selection of result.selections) {
+            if (typeof selection === 'string')
+                labels.push(optionLabel(question.multiSelect, selection));
+        }
+    }
+    if (labels.length > 0)
+        return labels.join(', ');
+    return Array.isArray(result.selections) && result.selections.length === 0 ? 'None selected' : undefined;
+}
+/** Read a classified result or delivered callback as plain user text. Decline wins over other fields;
+ * expiry, invalid answers and unrecognized results produce no user message.
+ * @returns Answer text, or undefined when no supported human answer is present; never throws.
+ * @example questionAnswerText({ answer: { submitted: true, freeText: 'Custom theme' } })
+ * @complexity O(p + s*m) time, O(s) space for p single options, s selections, m multi options; no I/O.
+ */
+export function questionAnswerText({ answer, input }, _options = {}) {
+    const result = record(answer);
+    if ((result.submitted === false && result.reason === 'cancelled') || result.__dismissed === true)
+        return 'Declined';
+    if (result.submitted === false)
+        return undefined;
+    const freeText = result.freeText ?? result.__typedAnswer;
+    if (typeof freeText === 'string' && freeText.trim())
+        return freeText.trim();
+    return selectedAnswerText({ result, input });
+}
+/** Decode the persisted JSON result; failed tools and non-answer payloads never become user text.
+ * @returns Plain answer text or undefined for missing, failed or malformed results; never throws.
+ * @example questionAnswerFromResult({ result: { content: '{"submitted":true,"choice":"Blue"}', isError: false } })
+ * @complexity O(r + p + s*m) time, O(r + s) space including JSON decoding of r result characters.
+ */
+export function questionAnswerFromResult({ result, input }, _options = {}) {
+    if (!result || result.isError)
+        return undefined;
+    let answer;
+    try {
+        answer = JSON.parse(result.content);
+    }
+    catch {
+        return undefined;
+    }
+    const fields = record(answer);
+    if (fields.submitted !== true && !(fields.submitted === false && fields.reason === 'cancelled'))
+        return undefined;
+    return questionAnswerText({ answer, input });
+}
+//# sourceMappingURL=question-answer.js.map

package/dist/core/question-form/format.d.ts

@@ -10,18 +10,18 @@ export declare function formatFormAnswers({ form, answers }: {
     form: QuestionForm;
     answers: Record<string, string | string[]>;
 }): string;
+type OptionHolder = {
+    options?: FormOption[] | undefined;
+};
 /** Resolve a submitted answer value back to its display label, or the value itself when unmatched. */
 export declare function formOptionLabelForValue({ question, value }: {
-    question: {
-        options?: FormOption[] | undefined;
-    };
+    question: OptionHolder;
     value: string;
 }): string;
 /** Resolve a label or value to the canonical option `value`, or the input itself when unmatched. */
 export declare function formOptionValueForLabel({ question, labelOrValue }: {
-    question: {
-        options?: FormOption[] | undefined;
-    };
+    question: OptionHolder;
     labelOrValue: string;
 }): string;
+export {};
 //# sourceMappingURL=format.d.ts.map

package/dist/core/question-form/format.js

@@ -21,25 +21,26 @@ export function formatFormAnswers({ form, answers }) {
     const lines = [];
     lines.push(`[form answers — ${form.id}]`);
     for (const q of form.questions) {
-        const v = safe.answers[q.id];
-        let display;
-        if (Array.isArray(v)) {
-            display = v.length > 0 ? v.map((value) => formOptionDisplayForValue(q, value)).join(', ') : '(skipped)';
-        }
-        else if (typeof v === 'string') {
-            display = v.trim().length > 0 ? formOptionDisplayForValue(q, v.trim()) : '(skipped)';
-        }
-        else {
-            display = '(skipped)';
-        }
-        lines.push(`- ${q.label}: ${display}`);
+        lines.push(`- ${q.label}: ${answerDisplay(q, safe.answers[q.id])}`);
     }
     if (safe.secretRedacted || form.questions.some(question => isSecretQuestion({ question })))
         lines.push(CREDENTIAL_CARD_GUIDANCE);
     return redactUserText({ text: lines.join('\n') }).text;
 }
+// Array entries are shown as given; a string answer is trimmed first. An
+// empty answer of either shape reads as skipped.
+function answerDisplay(question, answer) {
+    if (Array.isArray(answer)) {
+        return answer.length > 0 ? answer.map((value) => formOptionDisplayForValue(question, value)).join(', ') : '(skipped)';
+    }
+    const value = typeof answer === 'string' ? answer.trim() : '';
+    return value ? formOptionDisplayForValue(question, value) : '(skipped)';
+}
+function findOption(question, labelOrValue) {
+    return question.options?.find((option) => option.value === labelOrValue || option.label === labelOrValue);
+}
 function formOptionDisplayForValue(question, value) {
-    const match = question.options?.find((option) => option.value === value || option.label === value);
+    const match = findOption(question, value);
     if (!match)
         return value;
     if (match.value === match.label)
@@ -48,12 +49,10 @@ function formOptionDisplayForValue(question, value) {
 }
 /** Resolve a submitted answer value back to its display label, or the value itself when unmatched. */
 export function formOptionLabelForValue({ question, value }) {
-    const match = question.options?.find((option) => option.value === value || option.label === value);
-    return match?.label ?? value;
+    return findOption(question, value)?.label ?? value;
 }
 /** Resolve a label or value to the canonical option `value`, or the input itself when unmatched. */
 export function formOptionValueForLabel({ question, labelOrValue }) {
-    const match = question.options?.find((option) => option.value === labelOrValue || option.label === labelOrValue);
-    return match?.value ?? labelOrValue;
+    return findOption(question, labelOrValue)?.value ?? labelOrValue;
 }
 //# sourceMappingURL=format.js.map