@itookit/dsht 0.3.4 → 0.3.7

package/dist/session/transcript.js

@@ -59,6 +59,40 @@ export function contentText(content, tools, width = 100, reasoning = 'full') {
 }
 /** Event types that contribute a displayed message; other retained events only affect live state. */
 const DISPLAY_EVENTS = new Set(['user/message', 'assistant/message', 'tool/result']);
+/** One durable `user/message` event as a recallable prompt.
+ *
+ * Injected context and every other record type return undefined. This is the single place the rule
+ * lives, so a prompt parsed straight from a wire record (the cost scan's pages) is identical to one
+ * the transcript folded into its own window.
+ * @param seq - Durable sequence of the record.
+ * @param event - Decoded wire event, when the record carried one.
+ * @returns The prompt text, or undefined when the record is not a user prompt.
+ */
+export function eventPrompt(seq, event) {
+    if (!event || event.type !== 'user/message' || event.surfaceOp !== 'append')
+        return undefined;
+    const data = object(event.data);
+    if (data.source && object(data.source).kind !== 'user')
+        return undefined;
+    return { seq, text: contentText(data.content) };
+}
+/** User prompts in one raw history page, oldest first.
+ * @param records - One HTTP history page's records.
+ * @returns Prompts with their durable sequences, in page order.
+ */
+export function recordPrompts(records) {
+    const prompts = [];
+    for (const raw of array(records)) {
+        const event = object(object(raw).event);
+        const seq = event.seq;
+        if (typeof seq !== 'number' || !Number.isSafeInteger(seq))
+            continue;
+        const prompt = eventPrompt(seq, event);
+        if (prompt)
+            prompts.push(prompt);
+    }
+    return prompts;
+}
 /** Opening snapshots replace all state; durable events are deduplicated by sequence. */
 export class Transcript {
     sizes = new Map();
@@ -397,6 +431,45 @@ export class Transcript {
     }
     /** Latest loaded user prompt summary, sharing the durable thought index. */
     get latestPrompt() { void this.thoughts; return this.thoughtIndex.prompt; }
+    /** User prompts newer than `afterSeq`, oldest first, with the newest sequence scanned.
+     *
+     * Recall folds its tail this way instead of projecting messages, so a stream frame never rebuilds
+     * the row layout at a second width just to notice a new prompt. The watermark is returned even when
+     * the scanned records contributed no prompt, because an assistant-only turn must not make the next
+     * frame rescan it.
+     * @param afterSeq - Newest sequence already folded into the caller's index.
+     * @returns Prompts with an increasing sequence, and the watermark the caller should adopt.
+     */
+    promptsSince(afterSeq) {
+        const keys = this.sortedKeys();
+        let start = keys.length;
+        while (start > 0 && keys[start - 1] > afterSeq)
+            start--;
+        const prompts = [];
+        for (let index = start; index < keys.length; index++) {
+            const prompt = this.userPrompt(keys[index]);
+            if (prompt)
+                prompts.push(prompt);
+        }
+        return { prompts, through: Math.max(afterSeq, keys.at(-1) ?? afterSeq) };
+    }
+    /** User prompts strictly older than `beforeSeq`, oldest first, from the retained window.
+     * @param beforeSeq - Sequence the caller's index has already reached.
+     * @returns Loaded prompts that can refill an evicted prefix without a page request.
+     */
+    promptsBefore(beforeSeq) {
+        const prompts = [];
+        for (const seq of this.sortedKeys()) {
+            if (seq >= beforeSeq)
+                break;
+            const prompt = this.userPrompt(seq);
+            if (prompt)
+                prompts.push(prompt);
+        }
+        return prompts;
+    }
+    /** One `user/message` record as a prompt; injected context and other records return undefined. */
+    userPrompt(seq) { return eventPrompt(seq, this.events.get(seq)); }
     /** Number of semantic records and unfinished legacy chunks held by the client. */
     get retainedRecordCount() { return this.events.size; }
     /** Earliest loaded record, used with the opening cursor for backward paging. */

package/dist/state.d.ts

@@ -1,5 +1,5 @@
 /** Application state shared by the controller facade and every domain controller. */
-import { Transcript } from './session/transcript.ts';
+import { SessionInfo } from './session/info.ts';
 import type { HistorySearch, RemovalTarget } from './session/types.ts';
 import type { ObjectValue } from './transport/wire.ts';
 /** State shared by the picker and conversation view. */
@@ -21,7 +21,8 @@ export interface State {
     presetError?: string;
     presets?: ObjectValue[];
     defaultModel?: ObjectValue;
-    transcript: Transcript;
+    /** Record, prompt index, composer, view and interaction state of the selected session. */
+    session: SessionInfo;
 }
 /** The state contract every domain controller writes through. */
 export interface ControllerStore {

package/dist/state.js

@@ -1,9 +1,9 @@
 /** Application state shared by the controller facade and every domain controller. */
-import { Transcript } from "./session/transcript.js";
+import { SessionInfo } from "./session/info.js";
 /** Build the initial state before any connection exists.
  * @returns A fresh state whose transcript is empty and disconnected.
  */
 export function initialState() {
     return { version: 0, online: false, busy: false, screen: 'workspaces', status: 'Connecting…',
-        error: '', workspaces: [], sessions: [], showAllSessions: false, pending: [], transcript: new Transcript() };
+        error: '', workspaces: [], sessions: [], showAllSessions: false, pending: [], session: new SessionInfo() };
 }