@fungi.computer/parakeet 0.0.0-stage → 0.0.1

package/dist/core/client-contributions.js

@@ -0,0 +1,115 @@
+import { clientContributionSchemaV1, parseClientEntryV1, } from "@fungi.computer/shiitake/client-entry";
+import { parseCatalog } from "@fungi.computer/whistle/catalog";
+import * as Schema from "effect/Schema";
+const decodeContribution = Schema.decodeUnknownSync(clientContributionSchemaV1, {
+    onExcessProperty: "error",
+});
+function actions(value) {
+    return [
+        ...value.panel.flatMap((row) => row.actions ?? []),
+        ...value.timeline.cells.flatMap((cell) => cell.rows.flatMap((row) => row.actions ?? [])),
+        ...(value.waiting === null ? [] : [value.waiting.cancel]),
+    ];
+}
+function admitActions(value, slot) {
+    const declaredActions = actions(value);
+    const inspections = value.panel.flatMap((row) => row.inspection === undefined ? [] : [row.inspection]);
+    if (declaredActions.length === 0 && inspections.length === 0)
+        return;
+    if (slot?.status !== "running" || slot.catalog === undefined)
+        throw new Error("Client row actions require a running advertised catalog");
+    const catalog = parseCatalog(slot.catalog);
+    const ids = new Set(catalog.commands.map((command) => command.id));
+    for (const inspection of inspections)
+        if (!ids.has(inspection.commandId))
+            throw new Error(`Client inspection ${inspection.commandId} is not advertised by its entry`);
+    for (const action of declaredActions)
+        if (!ids.has(action.id))
+            throw new Error(`Client row action ${action.id} is not advertised by its entry`);
+}
+function admitContribution(contribute, slot) {
+    try {
+        const value = decodeContribution(contribute(slot));
+        admitActions(value, slot);
+        return { status: "admitted", value };
+    }
+    catch (cause) {
+        return {
+            status: "failed",
+            error: cause instanceof Error
+                ? cause
+                : new Error("Client contribution failed", { cause }),
+        };
+    }
+}
+/**
+ * The selected-Session evaluation owner. Feed existing observed slots here;
+ * renderers subscribe to admitted data and never evaluate an entry in render.
+ */
+export function createClientContributions(installed, onError) {
+    const entries = installed.map((entry) => parseClientEntryV1(entry));
+    if (new Set(entries.map((entry) => entry.id)).size !== entries.length)
+        throw new Error("Duplicate client contribution entry");
+    const previous = new Map();
+    const admitted = new Map();
+    const failures = new Map();
+    const listeners = new Set();
+    let state = [];
+    let disposed = false;
+    return {
+        snapshot: () => state,
+        subscribe: (listener) => {
+            if (disposed)
+                return () => undefined;
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        update: (slots) => {
+            if (disposed)
+                return;
+            let changed = false;
+            for (const entry of entries) {
+                if (entry.contribute === undefined)
+                    continue;
+                const slot = slots[entry.id];
+                if (previous.has(entry.id) && previous.get(entry.id) === slot)
+                    continue;
+                previous.set(entry.id, slot);
+                admitted.delete(entry.id);
+                changed = true;
+                const result = admitContribution(entry.contribute, slot);
+                if (result.status === "admitted") {
+                    admitted.set(entry.id, { entryId: entry.id, value: result.value });
+                    failures.delete(entry.id);
+                }
+                else {
+                    const { error } = result;
+                    const signature = `${error.name}: ${error.message}`;
+                    if (failures.get(entry.id) !== signature)
+                        onError(entry.id, error);
+                    failures.set(entry.id, signature);
+                }
+            }
+            if (!changed)
+                return;
+            state = entries.flatMap((entry) => {
+                const contribution = admitted.get(entry.id);
+                return contribution === undefined ? [] : [contribution];
+            });
+            for (const listener of listeners)
+                listener();
+        },
+        dispose: () => {
+            disposed = true;
+            previous.clear();
+            failures.clear();
+            admitted.clear();
+            state = [];
+            for (const listener of listeners)
+                listener();
+            listeners.clear();
+        },
+    };
+}

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

@@ -0,0 +1,33 @@
+import type { ClientTimelineCellV1 } from "@fungi.computer/shiitake/client-entry";
+import type { ClientContribution } from "./client-contributions.js";
+/** A committed cell retains its producer namespace in every renderer. */
+export type PlacedClientCell = Readonly<{
+    /** Namespace of the entry that produced this committed event. */
+    entryId: string;
+    /** Producer event, unchanged by host placement. */
+    cell: ClientTimelineCellV1;
+}>;
+/** Page visibility follows real durable command anchors, never event time. */
+export declare function placeClientTimeline(entries: readonly ClientContribution[], anchors: ReadonlyMap<string, string>): {
+    /** Loaded durable row IDs mapped to their following committed events. */
+    after: Map<string, Readonly<{
+        /** Namespace of the entry that produced this committed event. */
+        entryId: string;
+        /** Producer event, unchanged by host placement. */
+        cell: ClientTimelineCellV1;
+    }>[]>;
+    /** Null-anchor events for the separate Extension changes section. */
+    unanchored: Readonly<{
+        /** Namespace of the entry that produced this committed event. */
+        entryId: string;
+        /** Producer event, unchanged by host placement. */
+        cell: ClientTimelineCellV1;
+    }>[];
+    /** Factual producer retention counts, independent of loaded message pages. */
+    omitted: {
+        /** Producer namespace for the retention notice. */
+        entryId: string;
+        /** Number of committed events omitted by this producer. */
+        count: number;
+    }[];
+};

package/dist/core/client-timeline.js

@@ -0,0 +1,72 @@
+/** Merge producer heads: clock rollback never reverses a producer's sequence. */
+function mergeCells(cells) {
+    const streams = new Map();
+    for (const cell of cells) {
+        const stream = streams.get(cell.entryId);
+        if (stream === undefined)
+            streams.set(cell.entryId, [cell]);
+        else
+            stream.push(cell);
+    }
+    for (const stream of streams.values())
+        stream.sort((left, right) => left.cell.sequence - right.cell.sequence);
+    const merged = [];
+    while (streams.size > 0) {
+        const heads = [...streams.values()].flatMap((stream) => stream[0] === undefined ? [] : [stream[0]]);
+        heads.sort((left, right) => left.cell.at - right.cell.at ||
+            (left.entryId < right.entryId
+                ? -1
+                : left.entryId > right.entryId
+                    ? 1
+                    : 0) ||
+            left.cell.sequence - right.cell.sequence);
+        const next = heads[0];
+        if (next === undefined)
+            break;
+        merged.push(next);
+        const stream = streams.get(next.entryId);
+        stream?.shift();
+        if (stream?.length === 0)
+            streams.delete(next.entryId);
+    }
+    return merged;
+}
+/** Page visibility follows real durable command anchors, never event time. */
+export function placeClientTimeline(entries, anchors) {
+    const anchored = new Map();
+    const unanchored = [];
+    for (const { entryId, value } of entries) {
+        for (const cell of value.timeline.cells) {
+            const placed = { entryId, cell };
+            if (cell.commandId === null) {
+                unanchored.push(placed);
+                continue;
+            }
+            const itemId = anchors.get(cell.commandId);
+            if (itemId === undefined)
+                continue;
+            const existing = anchored.get(itemId);
+            if (existing === undefined)
+                anchored.set(itemId, [placed]);
+            else
+                existing.push(placed);
+        }
+    }
+    return {
+        /** Loaded durable row IDs mapped to their following committed events. */
+        after: new Map([...anchored].map(([id, cells]) => [id, mergeCells(cells)])),
+        /** Null-anchor events for the separate Extension changes section. */
+        unanchored: mergeCells(unanchored),
+        /** Factual producer retention counts, independent of loaded message pages. */
+        omitted: entries.flatMap(({ entryId, value }) => value.timeline.omitted === 0
+            ? []
+            : [
+                {
+                    /** Producer namespace for the retention notice. */
+                    entryId,
+                    /** Number of committed events omitted by this producer. */
+                    count: value.timeline.omitted,
+                },
+            ]),
+    };
+}

package/dist/core/format-context.d.ts

@@ -0,0 +1,11 @@
+import type { SessionContext } from "@fungi.computer/shiitake/client";
+/**
+ * One token count, compacted for a narrow readout, e.g. `182000` to `182K`.
+ * Shared by the context footer and the compaction divider and notices.
+ */
+export declare function formatTokenCount(tokens: number): string;
+/**
+ * Context used over the model's window, e.g. `12K/200K`, shared by the
+ * browser and terminal footers. An unknown window shows the tokens alone.
+ */
+export declare function formatContextUsage(context: SessionContext): string;

package/dist/core/format-context.js

@@ -0,0 +1,20 @@
+/**
+ * One token count, compacted for a narrow readout, e.g. `182000` to `182K`.
+ * Shared by the context footer and the compaction divider and notices.
+ */
+export function formatTokenCount(tokens) {
+    if (tokens < 1_000)
+        return String(tokens);
+    if (tokens < 1_000_000)
+        return `${String(Math.round(tokens / 1_000))}K`;
+    return `${String(Math.round(tokens / 100_000) / 10)}M`;
+}
+/**
+ * Context used over the model's window, e.g. `12K/200K`, shared by the
+ * browser and terminal footers. An unknown window shows the tokens alone.
+ */
+export function formatContextUsage(context) {
+    return context.window === null
+        ? formatTokenCount(context.tokens)
+        : `${formatTokenCount(context.tokens)}/${formatTokenCount(context.window)}`;
+}

package/dist/core/format-tokens.d.ts

@@ -0,0 +1,2 @@
+/** Keep small usage counts exact; abbreviate thousands in the footer. */
+export declare function formatTokens(tokens: number): string;

package/dist/core/format-tokens.js

@@ -0,0 +1,6 @@
+/** Keep small usage counts exact; abbreviate thousands in the footer. */
+export function formatTokens(tokens) {
+    return tokens < 1000
+        ? `${String(tokens)} tok`
+        : `${(tokens / 1000).toFixed(1)}K`;
+}

package/dist/core/model-identity.d.ts

@@ -0,0 +1,3 @@
+import type { ParakeetModel } from "../conversation.js";
+/** The durable assistant's provider/model ids, shared by browser and terminal. */
+export declare function formatModelIdentity(model: ParakeetModel): string;

package/dist/core/model-identity.js

@@ -0,0 +1,7 @@
+/** The durable assistant's provider/model ids, shared by browser and terminal. */
+export function formatModelIdentity(model) {
+    const prefix = `${model.provider}/`;
+    return model.model.startsWith(prefix)
+        ? model.model
+        : `${prefix}${model.model}`;
+}

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

@@ -0,0 +1,11 @@
+import type { SessionCompactionMarker, SessionCompactionNotice, SessionFrame, SessionMessage, SessionSnapshot, SessionTerminal } from "@fungi.computer/shiitake/client";
+/** Derive completed durable message identity once per immutable history revision. */
+export declare function completedMessageIds(messages: readonly SessionMessage[]): ReadonlySet<string>;
+export declare function mergeMessages(current: readonly SessionMessage[], incoming: readonly SessionMessage[]): readonly SessionMessage[];
+/** Preserve the first terminal for each command, in observed order. */
+export declare function mergeTerminals(current: readonly SessionTerminal[], incoming: readonly SessionTerminal[]): readonly SessionTerminal[];
+/** Accumulate compaction markers by identity; a frame never removes one. */
+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[];
+export declare function applySessionFrame(current: SessionSnapshot, frame: SessionFrame): SessionSnapshot;

package/dist/core/session-projection.js

@@ -0,0 +1,191 @@
+import { sameRunningWork } from "./session-view-state.js";
+const durableMessageIds = new WeakMap();
+/** Derive completed durable message identity once per immutable history revision. */
+export function completedMessageIds(messages) {
+    const known = durableMessageIds.get(messages);
+    if (known !== undefined)
+        return known;
+    const ids = new Set(messages.map(({ id }) => id));
+    durableMessageIds.set(messages, ids);
+    return ids;
+}
+function mergeOrderedUnique(current, incoming) {
+    if (incoming.length === 0)
+        return current;
+    const known = new Set(current.map(({ id }) => id));
+    const added = incoming.filter(({ id }) => !known.has(id));
+    if (added.length === 0)
+        return current;
+    return [...current, ...added].sort((left, right) => left.sequence - right.sequence);
+}
+export function mergeMessages(current, incoming) {
+    return mergeOrderedUnique(current, incoming);
+}
+function retainsProgress(progress, messages) {
+    if (progress === null)
+        return null;
+    return completedMessageIds(messages).has(progress.messageId)
+        ? null
+        : progress;
+}
+/** Preserve the first terminal for each command, in observed order. */
+export function mergeTerminals(current, incoming) {
+    const merged = [];
+    const positions = new Map();
+    for (const terminal of [...current, ...incoming]) {
+        const position = positions.get(terminal.commandId);
+        if (position === undefined) {
+            positions.set(terminal.commandId, merged.length);
+            merged.push(terminal);
+        }
+    }
+    if (merged.length === current.length &&
+        merged.every((terminal, index) => terminal === current[index]))
+        return current;
+    return merged;
+}
+/** Accumulate compaction markers by identity; a frame never removes one. */
+export function mergeCompactions(current, incoming) {
+    return mergeOrderedUnique(current, incoming);
+}
+/** Accumulate compaction notices by identity; a frame never removes one. */
+export function mergeCompactionNotices(current, incoming) {
+    return mergeOrderedUnique(current, incoming);
+}
+function sameAttention(left, right) {
+    return (left.length === right.length &&
+        left.every((item, index) => {
+            const other = right[index];
+            return (item.extensionId === other?.extensionId &&
+                item.id === other.id &&
+                item.kind === other.kind &&
+                item.summary === other.summary &&
+                item.since === other.since &&
+                item.expiresAt === other.expiresAt);
+        }));
+}
+function samePending(left, right) {
+    return (left.total === right.total &&
+        left.hasMore === right.hasMore &&
+        left.prompts.length === right.prompts.length &&
+        left.prompts.every((prompt, index) => {
+            const rightPrompt = right.prompts[index];
+            if (rightPrompt === undefined)
+                return false;
+            return (prompt.commandId === rightPrompt.commandId &&
+                prompt.delivery === rightPrompt.delivery &&
+                prompt.text === rightPrompt.text);
+        }));
+}
+/** Activity facts are a few scalars; compare them by content. */
+function sameActivity(left, right) {
+    return (left === right ||
+        (left.queue.state === right.queue.state &&
+            (left.queue.state === "idle" ||
+                right.queue.state === "idle" ||
+                (left.queue.commandId === right.queue.commandId &&
+                    (left.queue.state !== "queued" ||
+                        right.queue.state !== "queued" ||
+                        sameRunningWork(left.queue.runningWork, right.queue.runningWork)))) &&
+            left.cancellationRequested === right.cancellationRequested &&
+            left.activeTool === right.activeTool &&
+            left.lastModelChoiceSequence === right.lastModelChoiceSequence &&
+            (left.retry === right.retry ||
+                (left.retry !== null &&
+                    right.retry !== null &&
+                    left.retry.attempt === right.retry.attempt &&
+                    left.retry.maxAttempts === right.retry.maxAttempts &&
+                    left.retry.delayMs === right.retry.delayMs &&
+                    left.retry.errorMessage === right.retry.errorMessage &&
+                    left.retry.scheduledAt === right.retry.scheduledAt)) &&
+            (left.compaction === right.compaction ||
+                (left.compaction !== null &&
+                    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);
+}
+export function applySessionFrame(current, frame) {
+    if (frame.kind === "reset")
+        return {
+            ...frame.baseline,
+            terminals: mergeTerminals([], frame.baseline.terminals),
+            compactions: mergeCompactions([], frame.baseline.compactions ?? []),
+            compactionNotices: mergeCompactionNotices([], frame.baseline.compactionNotices ?? []),
+        };
+    if (frame.kind === "progress") {
+        const completed = completedMessageIds(current.messages).has(frame.progress.messageId);
+        const currentProgress = current.progress;
+        const sameMessage = currentProgress !== null &&
+            currentProgress.messageId === frame.progress.messageId;
+        const older = sameMessage && currentProgress.revision > frame.progress.revision;
+        if (completed || older)
+            return current;
+        const activity = sameActivity(current.activity, frame.activity)
+            ? current.activity
+            : frame.activity;
+        // A progress observation can carry new owner facts even when its text
+        // revision did not change, such as the end of a retry backoff.
+        if (sameMessage && currentProgress.revision === frame.progress.revision)
+            return activity === current.activity ? current : { ...current, activity };
+        return {
+            ...current,
+            progress: frame.progress,
+            activity,
+        };
+    }
+    const pending = samePending(current.pending, frame.pending)
+        ? current.pending
+        : frame.pending;
+    const messages = mergeMessages(current.messages, frame.messages);
+    const terminals = mergeTerminals(current.terminals, frame.terminals);
+    const currentCompactions = current.compactions ?? [];
+    const compactions = mergeCompactions(currentCompactions, frame.compactions ?? []);
+    const currentCompactionNotices = current.compactionNotices ?? [];
+    const compactionNotices = mergeCompactionNotices(currentCompactionNotices, frame.compactionNotices ?? []);
+    const progress = frame.activity.queue.state === "idle"
+        ? null
+        : retainsProgress(current.progress, messages);
+    // An update without a context figure leaves the last one in place.
+    const context = frame.context === undefined ||
+        (current.context?.tokens === frame.context.tokens &&
+            current.context.window === frame.context.window)
+        ? current.context
+        : frame.context;
+    if (messages === current.messages &&
+        terminals === current.terminals &&
+        compactions === currentCompactions &&
+        compactionNotices === currentCompactionNotices &&
+        progress === current.progress &&
+        pending === current.pending &&
+        sameExtensionSlots(frame.extensions, current.extensions) &&
+        sameAttention(frame.attention, current.attention) &&
+        frame.cursor === current.cursor &&
+        sameActivity(frame.activity, current.activity) &&
+        context === current.context)
+        return current;
+    const next = {
+        ...current,
+        cursor: frame.cursor,
+        messages,
+        terminals,
+        compactions,
+        compactionNotices,
+        progress,
+        activity: sameActivity(current.activity, frame.activity)
+            ? current.activity
+            : frame.activity,
+        pending,
+        attention: sameAttention(frame.attention, current.attention)
+            ? current.attention
+            : frame.attention,
+        extensions: sameExtensionSlots(frame.extensions, current.extensions)
+            ? current.extensions
+            : frame.extensions,
+    };
+    // Undefined only while neither the snapshot nor the frame reported one.
+    return context === undefined ? next : { ...next, context };
+}

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

@@ -0,0 +1,118 @@
+import type { SessionSnapshot } from "@fungi.computer/shiitake/client";
+import { type QueryClient } from "@tanstack/react-query";
+import type { ParakeetSession } from "../session.js";
+/** One shared TanStack observation keyed by Shiitake's logical Session address. */
+export declare function sessionQueryOptions(session: ParakeetSession): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Readonly<{
+    /** Whether the current watch has supplied a fresh owner baseline. */
+    observation: "connecting" | "live";
+    /** Last coherent durable Session state, absent before the first snapshot. */
+    snapshot: SessionSnapshot | undefined;
+    /** One retryable user prompt survives live-page refreshes. */
+    latestPrompt: readonly [commandId: string, text: string] | undefined;
+}>, Error, Readonly<{
+    /** Whether the current watch has supplied a fresh owner baseline. */
+    observation: "connecting" | "live";
+    /** Last coherent durable Session state, absent before the first snapshot. */
+    snapshot: SessionSnapshot | undefined;
+    /** One retryable user prompt survives live-page refreshes. */
+    latestPrompt: readonly [commandId: string, text: string] | undefined;
+}>, readonly ["shiitake-session", string]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Readonly<{
+        /** Whether the current watch has supplied a fresh owner baseline. */
+        observation: "connecting" | "live";
+        /** Last coherent durable Session state, absent before the first snapshot. */
+        snapshot: SessionSnapshot | undefined;
+        /** One retryable user prompt survives live-page refreshes. */
+        latestPrompt: readonly [commandId: string, text: string] | undefined;
+    }>, readonly ["shiitake-session", string], never>;
+} & import("@tanstack/react-query").QueryKeyWithDataTag<readonly ["shiitake-session", string], Readonly<{
+    /** Whether the current watch has supplied a fresh owner baseline. */
+    observation: "connecting" | "live";
+    /** Last coherent durable Session state, absent before the first snapshot. */
+    snapshot: SessionSnapshot | undefined;
+    /** One retryable user prompt survives live-page refreshes. */
+    latestPrompt: readonly [commandId: string, text: string] | undefined;
+}>, Error>;
+/** Seed the shared observation with a bounded read before its watch mounts. */
+export declare function seedSessionQuery(queryClient: QueryClient, session: ParakeetSession, snapshot: SessionSnapshot): void;
+/** Borrow activity from the existing cache without starting another watch. */
+export declare function subscribeSessionActivity(queryClient: QueryClient, session: ParakeetSession, listener: (activity: "idle" | "working" | "unknown") => void): () => void;
+/** Shared, demand-loaded history; the live watch remains a separate small tail. */
+export declare function sessionHistoryQueryOptions(session: ParakeetSession, before?: string | null): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseInfiniteQueryOptions<Readonly<{
+    sessionId: string;
+    cursor: string | null;
+    hasMore: boolean;
+    oldestCursor?: string | null;
+    messages: readonly import("@fungi.computer/shiitake/client").SessionMessage[];
+    terminals: readonly import("@fungi.computer/shiitake/client").SessionTerminal[];
+    compactions?: readonly import("@fungi.computer/shiitake/client").SessionCompactionMarker[];
+    compactionNotices?: readonly import("@fungi.computer/shiitake/client").SessionCompactionNotice[];
+    sandboxFailures?: readonly import("@fungi.computer/mycelium").SandboxFailureEvent[];
+    pending: import("@fungi.computer/shiitake/client").SessionPendingPrompts;
+    activity: import("@fungi.computer/shiitake/client").SessionActivity;
+    progress: import("@fungi.computer/shiitake/client").SessionProgress | null;
+    extensions: import("@fungi.computer/shiitake/client").SessionExtensionSlots;
+    attention: readonly import("@fungi.computer/shiitake/client").SessionAttention[];
+    context?: import("@fungi.computer/shiitake/client").SessionContext;
+}>, Error, {
+    pages: Readonly<{
+        sessionId: string;
+        cursor: string | null;
+        hasMore: boolean;
+        oldestCursor?: string | null;
+        messages: readonly import("@fungi.computer/shiitake/client").SessionMessage[];
+        terminals: readonly import("@fungi.computer/shiitake/client").SessionTerminal[];
+        compactions?: readonly import("@fungi.computer/shiitake/client").SessionCompactionMarker[];
+        compactionNotices?: readonly import("@fungi.computer/shiitake/client").SessionCompactionNotice[];
+        sandboxFailures?: readonly import("@fungi.computer/mycelium").SandboxFailureEvent[];
+        pending: import("@fungi.computer/shiitake/client").SessionPendingPrompts;
+        activity: import("@fungi.computer/shiitake/client").SessionActivity;
+        progress: import("@fungi.computer/shiitake/client").SessionProgress | null;
+        extensions: import("@fungi.computer/shiitake/client").SessionExtensionSlots;
+        attention: readonly import("@fungi.computer/shiitake/client").SessionAttention[];
+        context?: import("@fungi.computer/shiitake/client").SessionContext;
+    }>[];
+    newerOverflow: boolean;
+}, string[], Readonly<{
+    before: string | null;
+    newerBefore: readonly string[];
+    newerOverflow: boolean;
+}>>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Readonly<{
+        sessionId: string;
+        cursor: string | null;
+        hasMore: boolean;
+        oldestCursor?: string | null;
+        messages: readonly import("@fungi.computer/shiitake/client").SessionMessage[];
+        terminals: readonly import("@fungi.computer/shiitake/client").SessionTerminal[];
+        compactions?: readonly import("@fungi.computer/shiitake/client").SessionCompactionMarker[];
+        compactionNotices?: readonly import("@fungi.computer/shiitake/client").SessionCompactionNotice[];
+        sandboxFailures?: readonly import("@fungi.computer/mycelium").SandboxFailureEvent[];
+        pending: import("@fungi.computer/shiitake/client").SessionPendingPrompts;
+        activity: import("@fungi.computer/shiitake/client").SessionActivity;
+        progress: import("@fungi.computer/shiitake/client").SessionProgress | null;
+        extensions: import("@fungi.computer/shiitake/client").SessionExtensionSlots;
+        attention: readonly import("@fungi.computer/shiitake/client").SessionAttention[];
+        context?: import("@fungi.computer/shiitake/client").SessionContext;
+    }>, string[], Readonly<{
+        before: string | null;
+        newerBefore: readonly string[];
+        newerOverflow: boolean;
+    }>>;
+} & import("@tanstack/react-query").QueryKeyWithDataTag<string[], import("@tanstack/react-query").InfiniteData<Readonly<{
+    sessionId: string;
+    cursor: string | null;
+    hasMore: boolean;
+    oldestCursor?: string | null;
+    messages: readonly import("@fungi.computer/shiitake/client").SessionMessage[];
+    terminals: readonly import("@fungi.computer/shiitake/client").SessionTerminal[];
+    compactions?: readonly import("@fungi.computer/shiitake/client").SessionCompactionMarker[];
+    compactionNotices?: readonly import("@fungi.computer/shiitake/client").SessionCompactionNotice[];
+    sandboxFailures?: readonly import("@fungi.computer/mycelium").SandboxFailureEvent[];
+    pending: import("@fungi.computer/shiitake/client").SessionPendingPrompts;
+    activity: import("@fungi.computer/shiitake/client").SessionActivity;
+    progress: import("@fungi.computer/shiitake/client").SessionProgress | null;
+    extensions: import("@fungi.computer/shiitake/client").SessionExtensionSlots;
+    attention: readonly import("@fungi.computer/shiitake/client").SessionAttention[];
+    context?: import("@fungi.computer/shiitake/client").SessionContext;
+}>, unknown>, Error>;