@fungi.computer/parakeet 0.4.0 → 0.6.0

package/dist/core/awaiting-answer.js

@@ -0,0 +1,303 @@
+/**
+ * Order the items by arrival and pick the one the composer shows. A postponed
+ * item leaves the composer but stays counted: it is the footer row.
+ */
+export function awaitingQueue(items, later) {
+    const ordered = items
+        .map((item, index) => ({ item, index }))
+        .sort((left, right) => left.item.arrivedAt - right.item.arrivedAt || left.index - right.index)
+        .map(({ item }) => item);
+    const current = ordered.find((item) => !later.has(item.key));
+    return {
+        items: ordered,
+        current,
+        position: current === undefined ? 0 : ordered.indexOf(current) + 1,
+        total: ordered.length,
+    };
+}
+/**
+ * The item that owns the composer right now. An empty draft is taken over;
+ * a draft with text is never, unless the person asked for the decision.
+ */
+export function awaitingTakeover(awaiting, draft) {
+    return draft === "" || awaiting.forced ? awaiting.current : undefined;
+}
+/** The state a decision starts in. */
+export function initialDecisionState() {
+    return {
+        highlight: 0,
+        toggled: new Set(),
+        other: "",
+        phase: "choose",
+        details: false,
+    };
+}
+const unchanged = (state) => ({ state });
+function onRow(state, prompt, highlight) {
+    return {
+        ...state,
+        highlight,
+        phase: highlight === prompt.options.length ? "other" : "choose",
+        refusal: undefined,
+    };
+}
+/**
+ * The one set of rules both renderers follow. Number keys only move the
+ * highlight, Enter is the only way to answer, and Esc steps back one level
+ * until it reaches the option list, where it postpones the decision.
+ */
+export function reduceDecision(state, intent, prompt) {
+    const optionCount = prompt.options.length;
+    const other = prompt.other;
+    const rows = optionCount + (other === undefined ? 0 : 1);
+    if (intent.type === "refused")
+        return {
+            state: { ...state, phase: "refused", refusal: intent.message },
+        };
+    if (state.phase === "sending")
+        return unchanged(state);
+    if (state.details && intent.type !== "details" && intent.type !== "escape")
+        return unchanged(state);
+    switch (intent.type) {
+        case "move":
+            return {
+                state: onRow(state, prompt, (state.highlight + intent.delta + rows) % rows),
+            };
+        case "pick":
+            return intent.number >= 1 && intent.number <= rows
+                ? { state: onRow(state, prompt, intent.number - 1) }
+                : unchanged(state);
+        case "toggle": {
+            const option = prompt.options[state.highlight];
+            if (prompt.multiple !== true || option === undefined)
+                return unchanged(state);
+            const toggled = new Set(state.toggled);
+            if (!toggled.delete(option.value))
+                toggled.add(option.value);
+            return {
+                state: { ...state, toggled, phase: "choose", refusal: undefined },
+            };
+        }
+        case "type":
+        case "append":
+            if (other === undefined)
+                return unchanged(state);
+            return {
+                state: {
+                    ...state,
+                    other: (intent.type === "append"
+                        ? `${state.other}${intent.text}`
+                        : intent.text).slice(0, other.maxLength),
+                    highlight: optionCount,
+                    phase: "other",
+                    refusal: undefined,
+                },
+            };
+        case "details":
+            return { state: { ...state, details: !state.details } };
+        case "enter": {
+            const text = state.other.trim();
+            const answerText = text === "" ? {} : { text };
+            if (prompt.multiple === true) {
+                const selected = prompt.options
+                    .map((option) => option.value)
+                    .filter((value) => state.toggled.has(value));
+                if (selected.length === 0 && text === "")
+                    return {
+                        state: onRow(state, prompt, state.highlight),
+                    };
+                return {
+                    state: { ...state, phase: "sending", refusal: undefined },
+                    effect: { type: "answer", selected, ...answerText },
+                };
+            }
+            const option = prompt.options[state.highlight];
+            if (option !== undefined)
+                return {
+                    state: { ...state, phase: "sending", refusal: undefined },
+                    effect: { type: "answer", selected: [option.value] },
+                };
+            if (text === "") {
+                if (other?.blank === undefined)
+                    return { state: onRow(state, prompt, optionCount) };
+                return {
+                    state: { ...state, phase: "sending", refusal: undefined },
+                    effect: { type: "answer", selected: [other.blank] },
+                };
+            }
+            return {
+                state: { ...state, phase: "sending", refusal: undefined },
+                effect: { type: "answer", selected: [], text },
+            };
+        }
+        case "escape":
+            if (state.details)
+                return { state: { ...state, details: false } };
+            if (state.phase === "other" || state.phase === "confirm")
+                return {
+                    state: { ...state, highlight: 0, phase: "choose" },
+                    effect: { type: "back" },
+                };
+            if (prompt.escape !== undefined)
+                return {
+                    state: { ...state, phase: "sending", refusal: undefined },
+                    effect: { type: "answer", selected: [prompt.escape] },
+                };
+            return { state, effect: { type: "later" } };
+    }
+}
+const noun = { question: "question", approval: "approval" };
+/** Project a decision's state into the view every renderer draws. */
+export function decisionView(state, prompt, context) {
+    const multiple = prompt.multiple === true;
+    const optionCount = prompt.options.length;
+    const otherText = state.other.trim();
+    const rows = [
+        ...prompt.options.map((option, index) => {
+            const toggled = state.toggled.has(option.value);
+            const marker = multiple
+                ? toggled
+                    ? "[x]"
+                    : "[ ]"
+                : `${String(index + 1)}.`;
+            const caption = `${option.label}${index === 0 ? " (recommended)" : ""}`;
+            return {
+                index,
+                kind: "option",
+                marker,
+                label: option.label,
+                description: option.description,
+                recommended: index === 0,
+                highlighted: state.highlight === index,
+                toggled,
+                destructive: option.destructive === true,
+                caption,
+                text: `${marker} ${caption}`,
+            };
+        }),
+        ...(prompt.other === undefined
+            ? []
+            : [
+                ((other) => {
+                    const toggled = multiple && otherText !== "";
+                    const marker = multiple
+                        ? toggled
+                            ? "[x]"
+                            : "[ ]"
+                        : `${String(optionCount + 1)}.`;
+                    return {
+                        index: optionCount,
+                        kind: "other",
+                        marker,
+                        label: other.label,
+                        description: undefined,
+                        recommended: false,
+                        highlighted: state.highlight === optionCount,
+                        toggled,
+                        destructive: false,
+                        caption: other.label,
+                        text: `${marker} ${other.label}`,
+                    };
+                })(prompt.other),
+            ]),
+    ];
+    const typing = state.phase === "other";
+    const blankLabel = prompt.options
+        .find((option) => option.value === prompt.other?.blank)
+        ?.label.toLowerCase();
+    const escapeLabel = prompt.options
+        .find((option) => option.value === prompt.escape)
+        ?.label.toLowerCase();
+    const sending = state.phase === "sending";
+    const hasDetails = (prompt.details?.length ?? 0) > 0 || prompt.body !== undefined;
+    const hints = sending
+        ? []
+        : state.details
+            ? [
+                { keys: "d", label: "back", priority: 0 },
+                { keys: "Esc", label: "back", priority: 1 },
+            ]
+            : [
+                { keys: "↑↓", label: "move", priority: 1 },
+                ...(multiple && !typing
+                    ? [{ keys: "Space", label: "toggle", priority: 1 }]
+                    : []),
+                {
+                    keys: "Enter",
+                    label: typing && otherText === "" && blankLabel !== undefined
+                        ? blankLabel
+                        : multiple || typing
+                            ? "send"
+                            : state.highlight === optionCount
+                                ? "write"
+                                : "choose",
+                    priority: 0,
+                },
+                ...(hasDetails
+                    ? [{ keys: typing ? "Alt+D" : "d", label: "details", priority: 2 }]
+                    : []),
+                {
+                    keys: "Esc",
+                    label: typing ? "back" : (escapeLabel ?? "later"),
+                    priority: 2,
+                },
+            ];
+    return {
+        kind: context.kind,
+        label: `Agent ${noun[context.kind]} ${String(context.position)} of ${String(context.total)}`,
+        title: prompt.message,
+        counter: context.total > 1
+            ? `${String(context.position)} of ${String(context.total)}`
+            : undefined,
+        summary: prompt.summary,
+        facts: prompt.facts ?? [],
+        body: prompt.body,
+        bodyLabel: prompt.bodyLabel,
+        details: prompt.details ?? [],
+        detailsOpen: state.details,
+        rows,
+        other: prompt.other === undefined
+            ? undefined
+            : {
+                label: prompt.other.label,
+                placeholder: prompt.other.placeholder,
+                text: state.other,
+                focused: typing,
+                maxLength: prompt.other.maxLength,
+            },
+        multiple,
+        phase: state.phase,
+        canSend: !sending &&
+            !state.details &&
+            (multiple
+                ? state.toggled.size > 0 || otherText !== ""
+                : state.highlight < optionCount ||
+                    otherText !== "" ||
+                    prompt.other?.blank !== undefined),
+        status: sending
+            ? { tone: "info", text: "Sending…" }
+            : state.phase === "refused"
+                ? { tone: "error", text: state.refusal ?? "That answer was refused." }
+                : undefined,
+        hints,
+    };
+}
+/**
+ * The plain strings a renderer must show for a view, in reading order. The
+ * lockstep tests hold every surface to this list.
+ */
+export function decisionViewText(view) {
+    if (view.detailsOpen)
+        return [view.title];
+    return [
+        view.title,
+        ...(view.counter === undefined ? [] : [view.counter]),
+        ...(view.summary === undefined ? [] : [view.summary]),
+        ...view.facts.map((fact) => `${fact.label} ${fact.value}`),
+        ...view.rows.map((row) => row.text),
+        ...(view.other === undefined || view.other.text === ""
+            ? []
+            : [view.other.text]),
+        ...(view.status === undefined ? [] : [view.status.text]),
+    ];
+}

package/dist/core/build-timeline.js

@@ -53,11 +53,14 @@ function progressItem(progress) {
         id: progress.messageId,
         kind: "assistant_message",
         pending: true,
-        text: progress.text,
+        text: `${progress.textTruncated ? "…" : ""}${progress.text}`,
     };
     return progress.thinking === ""
         ? base
-        : { ...base, thinking: progress.thinking };
+        : {
+            ...base,
+            thinking: `${progress.thinkingTruncated ? "…" : ""}${progress.thinking}`,
+        };
 }
 function collectAssistantBlocks(value) {
     const text = [];
@@ -97,11 +100,54 @@ function assistantMessageItem(id, value, blocks) {
         },
     };
     const withProviderError = value.stopReason === "error" && value.providerError !== undefined
-        ? { ...item, providerError: value.providerError }
+        ? {
+            ...item,
+            text: value.errorMessage ?? "This run couldn’t finish.",
+            providerError: value.providerError,
+        }
         : item;
+    const withDetail = value.stopReason === "error" &&
+        value.providerError !== undefined &&
+        blocks.text.length > 0
+        ? {
+            ...withProviderError,
+            errorDetail: blocks.text.join("").slice(0, 160),
+        }
+        : withProviderError;
     return blocks.thinking.length === 0
-        ? withProviderError
-        : { ...withProviderError, thinking: blocks.thinking.join("\n") };
+        ? withDetail
+        : { ...withDetail, thinking: blocks.thinking.join("\n") };
+}
+/** Presentation-only folding; durable messages and their raw evidence remain intact. */
+function collapseProviderErrors(rows, breakBefore) {
+    const items = [];
+    const aliases = new Map();
+    for (const row of rows) {
+        const prior = items.at(-1);
+        if (!breakBefore.has(row.id) &&
+            row.kind === "assistant_message" &&
+            row.isError &&
+            prior?.kind === "assistant_message" &&
+            prior.isError &&
+            row.providerError !== undefined &&
+            prior.providerError !== undefined &&
+            row.text === prior.text &&
+            row.errorDetail === prior.errorDetail &&
+            row.thinking === prior.thinking &&
+            row.author?.id === prior.author?.id &&
+            row.author?.name === prior.author?.name) {
+            items[items.length - 1] = {
+                ...prior,
+                repeatCount: (prior.repeatCount ?? 1) + 1,
+                // Details show the latest response, including its request id.
+                providerError: row.providerError,
+            };
+            aliases.set(row.id, prior.id);
+        }
+        else
+            items.push(row);
+    }
+    return { items, aliases };
 }
 function projectAssistant(id, value, author) {
     const blocks = collectAssistantBlocks(value);
@@ -281,11 +327,17 @@ export function buildDurableTimeline(messages, compactions = [], activity, autho
         }
         positionAnchors.set(position, anchor);
     }
+    const collapsed = collapseProviderErrors(grouped, breakBefore);
+    for (const [command, anchor] of commandAnchors)
+        commandAnchors.set(command, collapsed.aliases.get(anchor) ?? anchor);
+    for (const [position, anchor] of positionAnchors)
+        if (anchor !== null)
+            positionAnchors.set(position, collapsed.aliases.get(anchor) ?? anchor);
     const base = {
         commandAnchors,
         positionAnchors,
         completedMessageIds: completedMessageIds(messages),
-        items: grouped,
+        items: collapsed.items,
         commandIds,
         requestIds: new Set(messages.flatMap((message) => message.requestId === undefined ? [] : [message.requestId])),
     };
@@ -337,7 +389,9 @@ export function buildTimelineTail(durable, progress, queued, admissions = [], au
                 ? "failed"
                 : admission.status === "accepted"
                     ? "accepted"
-                    : "pending",
+                    : admission.status === "queued-local"
+                        ? "queued"
+                        : "pending",
             delivery: admission.delivery,
             text: admission.content,
         };

package/dist/core/client-actions.d.ts

@@ -22,6 +22,7 @@ export declare function createClientActions(options: Readonly<{
         readonly input?: {
             readonly [x: string]: import("effect/Schema").Json;
         } | undefined;
+        readonly awaiting?: "question";
     }, Readonly<{
         /** The same advertised intent is already in flight. */
         pending: boolean;

package/dist/core/client-actions.js

@@ -64,6 +64,11 @@ export function createClientActions(options) {
                 !advertisedActions(entry).includes(action) ||
                 (waiting && entry.value.waiting?.cancel !== action))
                 return;
+            // A decision answers in the composer; the row only asks for it.
+            if (action.awaiting !== undefined) {
+                options.interactions.awaiting.focus();
+                return;
+            }
             const intent = key(entryId, action);
             if (intents.get(intent)?.pending)
                 return;
@@ -76,7 +81,8 @@ export function createClientActions(options) {
                 };
                 if (action.input !== undefined)
                     input = { ...input, arguments: action.input };
-                outcome = await options.commands.execute(`${entryId}:${action.id}`, input);
+                // A client row belongs to the extension whose namespace is its entry.
+                outcome = await options.commands.execute({ namespace: entryId, id: action.id }, input);
             }
             catch (cause) {
                 reportFailure("client row command", cause);

package/dist/core/composer-model-name.d.ts

@@ -0,0 +1,3 @@
+import type { ParakeetModel } from "../conversation.js";
+/** A maintained catalog label, or the real identity rather than a guessed name. */
+export declare function composerModelName(model: ParakeetModel): string;

package/dist/core/composer-model-name.js

@@ -0,0 +1,21 @@
+import { ANTHROPIC_MODELS } from "@earendil-works/pi-ai/providers/anthropic.models";
+import { CLOUDFLARE_WORKERS_AI_MODELS } from "@earendil-works/pi-ai/providers/cloudflare-workers-ai.models";
+import { OPENAI_MODELS } from "@earendil-works/pi-ai/providers/openai.models";
+import { OPENAI_CODEX_MODELS } from "@earendil-works/pi-ai/providers/openai-codex.models";
+import { formatModelIdentity } from "./model-identity.js";
+// Read the same maintained metadata as the providers, without loading their
+// execution/auth adapters or maintaining another table of display names.
+const names = new Map([
+    ...Object.values(ANTHROPIC_MODELS),
+    ...Object.values(CLOUDFLARE_WORKERS_AI_MODELS),
+    ...Object.values(OPENAI_MODELS),
+    ...Object.values(OPENAI_CODEX_MODELS),
+].map((model) => [
+    formatModelIdentity({ provider: model.provider, model: model.id }),
+    model.name,
+]));
+/** A maintained catalog label, or the real identity rather than a guessed name. */
+export function composerModelName(model) {
+    const identity = formatModelIdentity(model);
+    return names.get(identity) ?? identity;
+}

package/dist/core/display-text.d.ts

@@ -0,0 +1,2 @@
+/** Display text keeps shaping characters, never terminal programs or bidi overrides. */
+export declare function sanitizeDisplayText(value: string): string;

package/dist/core/display-text.js

@@ -0,0 +1,7 @@
+import stripAnsi from "strip-ansi";
+/** Display text keeps shaping characters, never terminal programs or bidi overrides. */
+export function sanitizeDisplayText(value) {
+    return stripAnsi(value)
+        .replace(/\r\n?/gu, "\n")
+        .replace(/[\p{Cc}\u200b\u200e\u200f\u061c\u202a-\u202e\u2066-\u2069\u2060\ufeff]/gu, (character) => character === "\n" || character === "\t" ? character : "");
+}

package/dist/core/draft-storage.d.ts

@@ -12,6 +12,8 @@ export type ParakeetDraftStorage = Readonly<{
     getItem: (key: string) => string | null;
     /** Atomically replace the journal; throw if it cannot be committed. */
     setItem: (key: string, value: string) => void;
+    /** Remove a journal, doing nothing when the key is absent. */
+    removeItem: (key: string) => void;
 }>;
 declare const journal: z.ZodObject<{
     draft: z.ZodString;
@@ -39,6 +41,10 @@ declare const journal: z.ZodObject<{
         }>;
     }, z.core.$strip>>;
     pending: z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<{
+            "queued-local": "queued-local";
+            admitting: "admitting";
+        }>;
         requestId: z.ZodString;
         content: z.ZodString;
         submittedDraft: z.ZodString;

package/dist/core/draft-storage.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { reportFailure } from "../lib/failure.js";
 const images = z
     .array(z.object({
     type: z.literal("image"),
@@ -15,6 +16,7 @@ const recalledPrompt = z.object({
     delivery,
 });
 const pendingDraft = z.object({
+    status: z.enum(["queued-local", "admitting"]),
     requestId: z.string().min(1),
     content: z.string(),
     submittedDraft: z.string(),
@@ -31,15 +33,33 @@ const journal = z.object({
 });
 /** One owner-scoped journal commits pending text and composer text together. */
 export function draftJournal(scope, storage) {
-    const key = `fungi.parakeet.drafts.v1:${scope}`;
+    const key = `fungi.parakeet.drafts.v2:${scope}`;
+    let discardObsolete = true;
     return {
         read() {
             if (storage === undefined)
                 return { draft: "", pending: [] };
-            const saved = storage.getItem(key);
-            return saved === null
-                ? { draft: "", pending: [] }
-                : journal.parse(JSON.parse(saved));
+            if (discardObsolete) {
+                discardObsolete = false;
+                try {
+                    // Delete preview data without interpreting its superseded grammar.
+                    storage.removeItem(`fungi.parakeet.drafts.v1:${scope}`);
+                }
+                catch (cause) {
+                    reportFailure("discard obsolete draft journal", cause);
+                }
+            }
+            try {
+                const saved = storage.getItem(key);
+                return saved === null
+                    ? { draft: "", pending: [] }
+                    : journal.parse(JSON.parse(saved));
+            }
+            catch (cause) {
+                // Preview journals are disposable; a broken load must not break chat.
+                reportFailure("read saved draft", cause);
+                return { draft: "", pending: [] };
+            }
         },
         write(value) {
             if (storage === undefined)

package/dist/core/session-projection.d.ts

@@ -8,4 +8,5 @@ export declare function mergeTerminals(current: readonly SessionTerminal[], inco
 export declare function mergeCompactions(current: readonly SessionCompactionMarker[], incoming: readonly SessionCompactionMarker[]): readonly SessionCompactionMarker[];
 /** Accumulate compaction notices by identity; a frame never removes one. */
 export declare function mergeCompactionNotices(current: readonly SessionCompactionNotice[], incoming: readonly SessionCompactionNotice[]): readonly SessionCompactionNotice[];
+/** Apply one already-decoded Shiitake frame to its authoritative projection. */
 export declare function applySessionFrame(current: SessionSnapshot, frame: SessionFrame): SessionSnapshot;

package/dist/core/session-projection.js

@@ -1,3 +1,4 @@
+import { appendSessionProgress } from "@fungi.computer/shiitake/client";
 import { sameRunningWork } from "./session-view-state.js";
 const durableMessageIds = new WeakMap();
 /** Derive completed durable message identity once per immutable history revision. */
@@ -103,11 +104,11 @@ function sameActivity(left, right) {
                     right.compaction !== null &&
                     left.compaction.trigger === right.compaction.trigger))));
 }
-/** Apply one already-decoded Shiitake frame to its authoritative projection. */
 /** Extension slots are small JSON values; compare them by content. */
 function sameExtensionSlots(next, current) {
     return next === current || JSON.stringify(next) === JSON.stringify(current);
 }
+/** Apply one already-decoded Shiitake frame to its authoritative projection. */
 export function applySessionFrame(current, frame) {
     if (frame.kind === "reset")
         return {
@@ -149,7 +150,7 @@ export function applySessionFrame(current, frame) {
             return activity === current.activity ? current : { ...current, activity };
         return {
             ...current,
-            progress: frame.progress,
+            progress: appendSessionProgress(current.progress, frame.progress),
             activity,
         };
     }

package/dist/core/session-query.d.ts

@@ -7,6 +7,8 @@ export declare function sessionQueryOptions(session: ParakeetSession): import("@
     observation: "connecting" | "live";
     /** Last coherent durable Session state, absent before the first snapshot. */
     snapshot: SessionSnapshot | undefined;
+    /** Last successful watch connect or delivered frame, not a cached seed. */
+    lastReplyAt: number | undefined;
     /** One retryable user prompt, including image cargo, survives page refreshes. */
     latestPrompt: Readonly<{
         /** Owner-issued identity of the original prompt command. */
@@ -21,6 +23,8 @@ export declare function sessionQueryOptions(session: ParakeetSession): import("@
     observation: "connecting" | "live";
     /** Last coherent durable Session state, absent before the first snapshot. */
     snapshot: SessionSnapshot | undefined;
+    /** Last successful watch connect or delivered frame, not a cached seed. */
+    lastReplyAt: number | undefined;
     /** One retryable user prompt, including image cargo, survives page refreshes. */
     latestPrompt: Readonly<{
         /** Owner-issued identity of the original prompt command. */
@@ -36,6 +40,8 @@ export declare function sessionQueryOptions(session: ParakeetSession): import("@
         observation: "connecting" | "live";
         /** Last coherent durable Session state, absent before the first snapshot. */
         snapshot: SessionSnapshot | undefined;
+        /** Last successful watch connect or delivered frame, not a cached seed. */
+        lastReplyAt: number | undefined;
         /** One retryable user prompt, including image cargo, survives page refreshes. */
         latestPrompt: Readonly<{
             /** Owner-issued identity of the original prompt command. */
@@ -51,6 +57,8 @@ export declare function sessionQueryOptions(session: ParakeetSession): import("@
     observation: "connecting" | "live";
     /** Last coherent durable Session state, absent before the first snapshot. */
     snapshot: SessionSnapshot | undefined;
+    /** Last successful watch connect or delivered frame, not a cached seed. */
+    lastReplyAt: number | undefined;
     /** One retryable user prompt, including image cargo, survives page refreshes. */
     latestPrompt: Readonly<{
         /** Owner-issued identity of the original prompt command. */