@deepseek-harness-tui/dsh-tui 0.13.0 → 0.14.0

package/lib/types/channel/questions.js

@@ -0,0 +1,286 @@
+/**
+ * Ask-user-question store, the UI-side half of every structured ask: the
+ * DSH user-interaction seam (`ctx.userQuestions`, the model-facing
+ * `ask_user_question` tool), local wizards (`/provider`, `/login`) and a
+ * non-DSH session's `question.request` events (Claude `AskUserQuestion`,
+ * `ExitPlanMode`) all park here. The store surfaces one question at a time to
+ * the TUI questionnaire and settles the asker's promise when the user
+ * answers, cancels, or the asker's abort signal fires.
+ *
+ * Queue semantics mirror the official dsh-tui chat/questions machine: asks
+ * arrive one at a time in practice (the tool blocks until answered), but
+ * concurrent asks from subagents are drained FIFO.
+ *
+ * This store owns the interaction only. The answered-questionnaire transcript
+ * record belongs to the projection: it is folded from the persisted tool result
+ * (`channel/question-record.ts`, issue #1009), never pushed from here, so it
+ * survives `/resume`, rewind and replay.
+ *
+ * Backend-neutral (`verify:boundary`): the request/answer shapes are the
+ * store's own (structurally the DSH protocol's, so `src/dsh-adapter/` passes
+ * its official types straight through), and the interruption error is
+ * injected: the DSH store rejects with the protocol's `UserQuestionError`
+ * (`src/dsh-adapter/questions.ts`), which dsh-plan-mode keys on.
+ */
+import { assertCapabilityShadowPolicy, defaultAdapterRuntime, } from '../adapter/kernel/runtime.js';
+/** The default interruption error (a host may inject its protocol's own). */
+export class QuestionInterruptedError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = 'QuestionInterruptedError';
+        this.code = code;
+    }
+}
+/** Whether `error` is an ask rejected by the user or by an abort (either
+ *  store's interruption error carries the code). */
+export function isQuestionInterruption(error) {
+    const code = typeof error === 'object' && error !== null ? error.code : undefined;
+    return code === 'ASK_CANCELLED' || code === 'ASK_ABORTED';
+}
+function isDefined(value) {
+    return value !== undefined;
+}
+function copyDraft(draft) {
+    return {
+        selected: [...draft.selected],
+        ...(draft.custom !== undefined ? { custom: draft.custom } : {}),
+    };
+}
+function selectionFromAnswer(answer) {
+    return copyDraft(answer);
+}
+/**
+ * Ask-user-question store: parks asks, surfaces one question at a time to
+ * the TUI, and settles each ask when the user answers or the batch is
+ * interrupted. The TUI subscribes for re-renders and answers via
+ * {@link QuestionStore.answerCurrent}.
+ */
+export class QuestionStore {
+    /** The adapter runtime the shadow-policy guard is evaluated against. */
+    runtime;
+    interruption;
+    constructor(options = {}) {
+        this.runtime = options.runtime ?? defaultAdapterRuntime();
+        this.interruption = options.interruption ?? ((message, code) => new QuestionInterruptedError(message, code));
+    }
+    queue = [];
+    active;
+    listeners = new Set();
+    batchSeq = 0;
+    /**
+     * Cached snapshot: useSyncExternalStore requires a stable reference while
+     * nothing changed (a fresh object per call would loop re-renders).
+     */
+    snapshotCache = null;
+    /**
+     * Subscribe to store changes (useSyncExternalStore contract).
+     * @param listener - Called after every mutation that changes the snapshot.
+     * @returns An unsubscribe function removing the listener.
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /**
+     * The question the TUI should render now, or null when idle.
+     * @returns The cached snapshot; the reference is stable between mutations.
+     */
+    getSnapshot() {
+        return this.snapshotCache;
+    }
+    /**
+     * Whether a panel callback still belongs to the question it was rendered
+     * for. One stdin batch can deliver → and then Enter to the panel that
+     * was mounted for the first key, after the store has already moved.
+     */
+    stillCurrent(key) {
+        return this.snapshotCache?.key === key;
+    }
+    emit() {
+        for (const listener of this.listeners)
+            listener();
+    }
+    /** Rebuild the cached snapshot after any mutation of active/index. */
+    rebuildSnapshot() {
+        const pending = this.active;
+        if (pending === undefined) {
+            this.snapshotCache = null;
+            return;
+        }
+        const question = pending.request.questions[pending.index];
+        const savedDraft = pending.drafts[pending.index];
+        const savedAnswer = pending.answers[pending.index];
+        this.snapshotCache = question === undefined ? null : {
+            key: `${pending.batchId}-${pending.index}`,
+            question,
+            position: pending.index + 1,
+            total: pending.request.questions.length,
+            answered: pending.index,
+            ...(savedDraft !== undefined
+                ? { draft: savedDraft }
+                : savedAnswer !== undefined
+                    ? { draft: selectionFromAnswer(savedAnswer) }
+                    : {}),
+            canGoBack: pending.index > 0,
+            canGoForward: pending.index + 1 < pending.request.questions.length,
+        };
+    }
+    /**
+     * Asker entry point for the DSH `ask_user_question` provider, local wizards
+     * (e.g. `/provider`) and the channel's backend question bridge.
+     * @param request - The ask request: questions plus optional abort signal.
+     * @param options - `redact` hides answer text from the answered-questionnaire
+     *   transcript record (use for batches that collect secrets such as API keys).
+     * @returns A promise settling with the collected answers when the user
+     *   submits the batch, or rejecting when the ask is interrupted.
+     */
+    ask(request, options) {
+        assertCapabilityShadowPolicy('host.presentation.ask', this.runtime.mode, this.runtime.slices);
+        return new Promise((resolve, reject) => {
+            const pending = {
+                request,
+                batchId: ++this.batchSeq,
+                index: 0,
+                answers: new Array(request.questions.length),
+                drafts: new Array(request.questions.length),
+                ...(options?.redact ? { redact: true } : {}),
+                resolve,
+                reject,
+                onAbort: () => {
+                    if (this.active === pending) {
+                        this.active = undefined;
+                        this.rebuildSnapshot();
+                        this.fail(pending);
+                        this.startNext();
+                        this.emit();
+                        return;
+                    }
+                    const at = this.queue.indexOf(pending);
+                    if (at >= 0)
+                        this.queue.splice(at, 1);
+                    this.fail(pending);
+                },
+            };
+            request.signal?.addEventListener('abort', pending.onAbort, { once: true });
+            this.queue.push(pending);
+            this.startNext();
+        });
+    }
+    /** Advance to the next queued ask, if any. */
+    startNext() {
+        if (this.active !== undefined || this.queue.length === 0)
+            return;
+        this.active = this.queue.shift();
+        this.rebuildSnapshot();
+        this.emit();
+    }
+    /**
+     * The user submitted an answer for the current question; replaces any
+     * previous answer at that position, advances to the next unanswered
+     * question, and settles the batch once every question is answered.
+     * @param selection - Selected option labels plus optional custom text.
+     */
+    answerCurrent(selection) {
+        const pending = this.active;
+        const question = pending?.request.questions[pending.index];
+        if (pending === undefined || question === undefined)
+            return;
+        const answer = {
+            id: question.id,
+            selected: [...selection.selected],
+            ...(selection.custom !== undefined && selection.custom !== ''
+                ? { custom: selection.custom }
+                : {}),
+        };
+        pending.answers[pending.index] = answer;
+        pending.drafts[pending.index] = copyDraft(selection);
+        // The answers array is sparse until each question is committed. `every`
+        // skips holes, so a peek-ahead answer would look complete and settle
+        // early. Read every index explicitly.
+        const complete = pending.request.questions.every((_, index) => pending.answers[index] !== undefined);
+        if (complete) {
+            // Batch complete: settle the asker's promise and drain the next queued
+            // ask if any. Filling the last gap after a → peek counts — the user
+            // should not have to walk onto an already-answered tail just to submit.
+            // The transcript record is NOT written here — it is projected from the
+            // persisted tool result (issue #1009), so it survives `/resume`,
+            // rewind and every replay.
+            const answers = pending.answers.filter(isDefined);
+            this.active = undefined;
+            pending.resolve({ answers });
+            this.startNext();
+        }
+        else {
+            const after = pending.request.questions.findIndex((_, index) => index > pending.index && pending.answers[index] === undefined);
+            const firstGap = pending.request.questions.findIndex((_, index) => pending.answers[index] === undefined);
+            pending.index = after >= 0 ? after : firstGap;
+        }
+        this.rebuildSnapshot();
+        this.emit();
+    }
+    /**
+     * Navigate to the next question without committing the current one. The
+     * caller supplies the panel's draft so a peek forward does not discard
+     * in-progress text. No-op on the last question — Enter still owns submit.
+     */
+    forwardCurrent(draft) {
+        const pending = this.active;
+        if (pending === undefined || pending.index + 1 >= pending.request.questions.length)
+            return;
+        if (draft !== undefined) {
+            pending.drafts[pending.index] = copyDraft(draft);
+        }
+        pending.index += 1;
+        this.rebuildSnapshot();
+        this.emit();
+    }
+    /**
+     * Navigate to the previous question without cancelling the batch. The
+     * caller supplies the panel's current draft so partially typed text can be
+     * restored when the user returns.
+     */
+    backCurrent(draft) {
+        const pending = this.active;
+        if (pending === undefined || pending.index <= 0)
+            return;
+        if (draft !== undefined) {
+            pending.drafts[pending.index] = copyDraft(draft);
+        }
+        pending.index -= 1;
+        this.rebuildSnapshot();
+        this.emit();
+    }
+    /** The user interrupted the questionnaire (Esc / Ctrl+C). */
+    cancelCurrent() {
+        const pending = this.active;
+        if (pending === undefined)
+            return;
+        this.active = undefined;
+        this.rebuildSnapshot();
+        this.cancel(pending);
+        this.startNext();
+        this.emit();
+    }
+    /** Reject the active and all queued asks (plugin teardown). */
+    rejectAll() {
+        const active = this.active;
+        this.active = undefined;
+        this.rebuildSnapshot();
+        if (active !== undefined)
+            this.fail(active);
+        for (const pending of this.queue.splice(0))
+            this.fail(pending);
+        this.emit();
+    }
+    /** User-initiated cancel — the asker learns the user wants to speak. */
+    cancel(pending) {
+        pending.reject(this.interruption('the user cancelled ask_user_question', 'ASK_CANCELLED'));
+    }
+    /** Asker-side interruption: abort signal fired or plugin teardown. */
+    fail(pending) {
+        pending.reject(this.interruption('ask_user_question was interrupted before the user answered', 'ASK_ABORTED'));
+    }
+}

package/lib/types/channel/sanitize.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The render-path sanitization contract for plugin-supplied text — the
+ * single implementation behind every managed-UI seam (dialogs, status line,
+ * entry renderers, rewind modes, decision notices). TUI-PROP-009 Track A
+ * makes these rules normative, so they live in exactly one place:
+ *
+ * - C0/C1 control chars are stripped (replaced by a space) — plugin text
+ *   must never smuggle escape sequences onto the screen;
+ * - whitespace collapses to single spaces (render paths are single-line);
+ * - width is capped in terminal CELLS (never string.length) with an
+ *   ellipsis.
+ *
+ * Non-scalar input is DROPPED, never `String()`-coerced — `String({})`
+ * would put "[object Object]" on the render path. Scalars
+ * (string/number/boolean) coerce through String() first.
+ */
+/** Sanitize an already-string value for the render path. */
+export declare function cleanRenderText(value: string, maxCells: number): string;
+/**
+ * Sanitize an untrusted (possibly non-string) value. Non-scalars — objects,
+ * arrays, functions, symbols, null/undefined — yield '' so the caller takes
+ * its drop/refuse path; scalars coerce then sanitize.
+ */
+export declare function cleanScalarText(value: unknown, maxCells: number): string;
+/**
+ * Truncate to a cell budget WITHOUT ellipsis, whitespace folding, or any
+ * other mutation — the editing-path counterpart of {@link cleanRenderText}.
+ * An input panel caps what the user types/pastes; inserting '…' or
+ * collapsing their spaces would corrupt text they can still edit.
+ */
+export declare function capCells(value: string, maxCells: number): string;
+/** C0/C1 control chars → space, nothing else touched. The single-line
+ *  input panel flattens pasted chunks with this (newlines become spaces —
+ *  the panel has no second row for them). */
+export declare function flattenInline(value: string): string;
+/**
+ * Single-line field ingress for terminal/clipboard paste: strip COMPLETE
+ * ANSI/OSC sequences first (paste content is user-controlled bytes — a
+ * smuggled ESC[… would otherwise break out of the render path), then flatten
+ * every remaining C0/C1 control char to a space. Unlike {@link flattenInline},
+ * this never leaves `[31m`-style residue behind; the two regexes mirror
+ * {@link cleanRenderText}'s strip, and the final pass covers the rest.
+ */
+export declare function flattenPasteInline(value: string): string;
+/** Toast-bound plugin text (veto reasons, handled notices, rewind summaries)
+ *  and single-line transcript notices are render-path data too: same
+ *  sanitization, toast-width cap. */
+export declare const NOTICE_CELLS = 200;
+//# sourceMappingURL=sanitize.d.ts.map

package/lib/types/channel/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../src/channel/sanitize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAevE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGxE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQhE;AAED;;6CAE6C;AAC7C,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGnD;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKxD;AAED;;qCAEqC;AACrC,eAAO,MAAM,YAAY,MAAM,CAAA"}

package/lib/types/channel/sanitize.js

@@ -0,0 +1,88 @@
+/**
+ * The render-path sanitization contract for plugin-supplied text — the
+ * single implementation behind every managed-UI seam (dialogs, status line,
+ * entry renderers, rewind modes, decision notices). TUI-PROP-009 Track A
+ * makes these rules normative, so they live in exactly one place:
+ *
+ * - C0/C1 control chars are stripped (replaced by a space) — plugin text
+ *   must never smuggle escape sequences onto the screen;
+ * - whitespace collapses to single spaces (render paths are single-line);
+ * - width is capped in terminal CELLS (never string.length) with an
+ *   ellipsis.
+ *
+ * Non-scalar input is DROPPED, never `String()`-coerced — `String({})`
+ * would put "[object Object]" on the render path. Scalars
+ * (string/number/boolean) coerce through String() first.
+ */
+import { stringWidth } from '../ink/stringWidth.js';
+/** Sanitize an already-string value for the render path. */
+export function cleanRenderText(value, maxCells) {
+    // Remove complete ANSI control sequences before stripping control bytes.
+    // Otherwise an SGR such as ESC[31m becomes the visible garbage "[31m".
+    const withoutAnsi = value
+        .replace(/\u001B\][^\u0007]*(?:\u0007|\u001B\\)/gu, '')
+        .replace(/\u001B\[[0-?]*[ -/]*[@-~]/gu, '');
+    // eslint-disable-next-line no-control-regex -- deliberate: sanitize untrusted render-path text
+    const flat = withoutAnsi.replace(/[\x00-\x1f\x7f-\x9f]/g, ' ').replace(/\s+/g, ' ').trim();
+    if (stringWidth(flat) <= maxCells)
+        return flat;
+    let out = '';
+    for (const ch of flat) {
+        if (stringWidth(out + ch) > maxCells - 1)
+            break;
+        out += ch;
+    }
+    return `${out}…`;
+}
+/**
+ * Sanitize an untrusted (possibly non-string) value. Non-scalars — objects,
+ * arrays, functions, symbols, null/undefined — yield '' so the caller takes
+ * its drop/refuse path; scalars coerce then sanitize.
+ */
+export function cleanScalarText(value, maxCells) {
+    if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean')
+        return '';
+    return cleanRenderText(String(value), maxCells);
+}
+/**
+ * Truncate to a cell budget WITHOUT ellipsis, whitespace folding, or any
+ * other mutation — the editing-path counterpart of {@link cleanRenderText}.
+ * An input panel caps what the user types/pastes; inserting '…' or
+ * collapsing their spaces would corrupt text they can still edit.
+ */
+export function capCells(value, maxCells) {
+    if (stringWidth(value) <= maxCells)
+        return value;
+    let out = '';
+    for (const ch of value) {
+        if (stringWidth(out + ch) > maxCells)
+            break;
+        out += ch;
+    }
+    return out;
+}
+/** C0/C1 control chars → space, nothing else touched. The single-line
+ *  input panel flattens pasted chunks with this (newlines become spaces —
+ *  the panel has no second row for them). */
+export function flattenInline(value) {
+    // eslint-disable-next-line no-control-regex -- deliberate: sanitize untrusted render-path text
+    return value.replace(/[\x00-\x1f\x7f-\x9f]/g, ' ');
+}
+/**
+ * Single-line field ingress for terminal/clipboard paste: strip COMPLETE
+ * ANSI/OSC sequences first (paste content is user-controlled bytes — a
+ * smuggled ESC[… would otherwise break out of the render path), then flatten
+ * every remaining C0/C1 control char to a space. Unlike {@link flattenInline},
+ * this never leaves `[31m`-style residue behind; the two regexes mirror
+ * {@link cleanRenderText}'s strip, and the final pass covers the rest.
+ */
+export function flattenPasteInline(value) {
+    const withoutAnsi = value
+        .replace(/\u001B\][^\u0007]*(?:\u0007|\u001B\\)/gu, '')
+        .replace(/\u001B\[[0-?]*[ -/]*[@-~]/gu, '');
+    return flattenInline(withoutAnsi);
+}
+/** Toast-bound plugin text (veto reasons, handled notices, rewind summaries)
+ *  and single-line transcript notices are render-path data too: same
+ *  sanitization, toast-width cap. */
+export const NOTICE_CELLS = 200;

package/lib/types/channel/selection-record.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Replay of the IDE-selection indicator from durable user-message content.
+ * The submit path (`dsh-adapter/channel/ide-selection.ts`) appends an
+ * `<attached-file path="…" selection count="N">` text block the channel itself
+ * builds; parsing it back is channel-format knowledge, not backend knowledge,
+ * so it lives beside the shared projector that needs it.
+ */
+import type { SelectionAttachment } from '../adapter/ports/channel-view.js';
+/**
+ * Derive the transcript indicator from the durable user-message content:
+ * the `<attached-file path="…" selection count="N">` block the submit path
+ * appended is part of the persisted event, so a replayed session can rebuild
+ * the "Selected N lines from <file>" line even though the in-memory
+ * message-id → attachment map starts empty. The indicator must not depend
+ * on process-local state.
+ */
+export declare function replaySelectionAttachment(content: readonly unknown[] | undefined): SelectionAttachment | undefined;
+//# sourceMappingURL=selection-record.d.ts.map

package/lib/types/channel/selection-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-record.d.ts","sourceRoot":"","sources":["../../../src/channel/selection-record.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AAE3E;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,GACtC,mBAAmB,GAAG,SAAS,CA8BjC"}

package/lib/types/channel/selection-record.js

@@ -0,0 +1,45 @@
+/**
+ * Derive the transcript indicator from the durable user-message content:
+ * the `<attached-file path="…" selection count="N">` block the submit path
+ * appended is part of the persisted event, so a replayed session can rebuild
+ * the "Selected N lines from <file>" line even though the in-memory
+ * message-id → attachment map starts empty. The indicator must not depend
+ * on process-local state.
+ */
+export function replaySelectionAttachment(content) {
+    if (content === undefined)
+        return undefined;
+    for (const block of content) {
+        if (block === null || typeof block !== 'object')
+            continue;
+        const text = block.text;
+        if (block.type !== 'text' || typeof text !== 'string')
+            continue;
+        const opened = /^<attached-file path="([^"]+)" selection(?: count="(\d+)")?>\n/.exec(text);
+        if (opened === null)
+            continue;
+        let closed = text.slice(opened[0].length);
+        if (closed.endsWith('</attached-file>'))
+            closed = closed.slice(0, -'</attached-file>'.length);
+        // The builder writes `body\n</attached-file>` — strip the newline the
+        // close tag rode on, or every body counts one phantom line.
+        if (closed.endsWith('\n'))
+            closed = closed.slice(0, -1);
+        const lines = closed.split('\n').length;
+        // `count` is authoritative when present (the builder always writes it).
+        // Blocks persisted before it existed fall back to the old tail heuristic,
+        // which misreads a body whose last line is literally the truncation marker.
+        const counted = opened[2] === undefined ? undefined : Number(opened[2]);
+        return {
+            lines: counted ?? (closed.endsWith('\n[… truncated]') ? lines - 1 : lines),
+            // Reverse escapeSnippetAttr so the replayed indicator shows the path
+            // exactly as the live one did (`&` first so entities are not re-baked).
+            path: opened[1]
+                .replace(/&lt;/g, '<')
+                .replace(/&gt;/g, '>')
+                .replace(/&quot;/g, '"')
+                .replace(/&amp;/g, '&'),
+        };
+    }
+    return undefined;
+}

package/lib/types/channel/side-prompts.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The backend-neutral prompt contracts of the TUI's side calls (`/btw`,
+ * `/recap`): what one tool-less, single-answer auxiliary call is asked, and
+ * how a recap answer is read back. Every backend's side call uses the same
+ * words: DSH sends them over its own derived history (`dsh-adapter/
+ * sideQuestion.ts`, `recap.ts`), Claude over a throwaway fork of the
+ * conversation (`backends/claude/side-query.ts`).
+ *
+ * Pure text: no I/O, no vendor types.
+ */
+/**
+ * Describe the auxiliary call's scope: one answer from existing context,
+ * with no tools, follow-up actions, or interruption of the main session.
+ * `running` names the main task's in-flight work, one line each (the
+ * caller formats them), when the context the call sees ends mid-step.
+ */
+export declare function sideQuestionPrompt(question: string, running?: readonly string[]): string;
+/**
+ * One earlier Q/A pair of a `/btw` side thread, as the thread store hands
+ * it to the next ask (answers already clipped to the per-answer budget).
+ */
+export interface SideThreadPriorTurn {
+    readonly question: string;
+    readonly answer: string;
+}
+/**
+ * Carry the recent turns of a side thread into the next single-turn ask:
+ * the pairs travel as explicit quoted context inside the question payload,
+ * so every backend's one-shot side call keeps its own contract unchanged
+ * (the wrapper still sees "one question, one answer, no tools"). The result
+ * is what the caller passes to `sideQuery.ask` as the question, not a
+ * second conversation: nothing here writes a session record anywhere.
+ *
+ * `omittedOlder` is the count of completed pairs the budget dropped from
+ * the front of the thread (turn-window or character budget); the note lets
+ * the model know earlier turns existed instead of silently forgetting.
+ */
+export declare function sideThreadQuestion(question: string, prior?: readonly SideThreadPriorTurn[], omittedOlder?: number): string;
+/**
+ * Wrap a recent-activity excerpt with the single-response, JSON-only recap
+ * contract (a call that does not see the conversation itself).
+ */
+export declare function wrapRecapPrompt(activity: string): string;
+/**
+ * The recap request for a call that runs over the conversation itself (a
+ * fork of it): the same contract, about the conversation so far, with an
+ * emphasis on its recent part.
+ */
+export declare function conversationRecapPrompt(): string;
+/**
+ * Parse the model's recap response: extract the JSON object (tolerating
+ * stray prose around it); on failure the whole text becomes the summary
+ * and no title is proposed.
+ */
+export declare function parseRecapResponse(raw: string): {
+    summary: string;
+    title?: string;
+};
+//# sourceMappingURL=side-prompts.d.ts.map

package/lib/types/channel/side-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"side-prompts.d.ts","sourceRoot":"","sources":["../../../src/channel/side-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,SAAS,MAAM,EAAO,GAAG,MAAM,CAc5F;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,KAAK,GAAE,SAAS,mBAAmB,EAAO,EAC1C,YAAY,SAAI,GACf,MAAM,CAsBR;AASD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMxD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAOhD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAyBnF"}