@fungi.computer/shiitake 0.5.0 → 0.7.0

package/dist/client-visitor.js

@@ -0,0 +1,231 @@
+import { authorMeta, messageAuthor, FungiMessageMetaSchema, } from "@fungi.computer/agar/agents";
+/** Filter participant delivery only; the holder's stored Session is unchanged. */
+export function participantSnapshot(snapshot, owner) {
+    const active = snapshot.activity.queue.state !== "idle" &&
+        owner.turnIsCurrent(snapshot.sessionId, snapshot.activity.queue.commandId);
+    return {
+        ...snapshot,
+        messages: snapshot.messages.filter(({ id, commandId, value }) => value.role !== "assistant" ||
+            value.provider === "operator" ||
+            (commandId !== null &&
+                owner.deliverAgentReply(snapshot.sessionId, commandId, {
+                    kind: "message",
+                    messageId: id,
+                }))),
+        progress: active ? snapshot.progress : null,
+        activity: active
+            ? snapshot.activity
+            : {
+                ...snapshot.activity,
+                queue: { state: "idle" },
+                cancellationRequested: false,
+                activeTool: null,
+                retry: null,
+                lastModelChoiceSequence: null,
+                compaction: null,
+            },
+    };
+}
+function sourceRequestId(meta) {
+    const parsed = FungiMessageMetaSchema.parse(meta);
+    if (parsed.sourceRequestId === undefined)
+        throw new Error("Visitor entry is missing its original request identity");
+    return parsed.sourceRequestId;
+}
+/** Project one owner-selected prompt without exposing host identity or correlation metadata. */
+export function visitorPendingPrompt(prompt, visitorId) {
+    if (messageAuthor(prompt.meta)?.id !== visitorId)
+        throw new Error("Visitor pending lookup returned another author's prompt");
+    const projected = {
+        commandId: prompt.commandId,
+        requestId: sourceRequestId(prompt.meta),
+        text: prompt.text,
+        delivery: prompt.delivery,
+    };
+    if (prompt.images !== undefined)
+        return { ...projected, images: prompt.images };
+    return projected;
+}
+function userText(value) {
+    return Array.isArray(value.content)
+        ? value.content
+            .flatMap((part) => (part.type === "text" ? [part.text] : []))
+            .join("")
+        : value.content;
+}
+function visitorCommands(snapshot, visitorId) {
+    const commands = new Set();
+    for (const message of snapshot.messages)
+        if (message.value.role === "user" &&
+            messageAuthor(message.meta)?.id === visitorId &&
+            message.commandId !== null)
+            commands.add(message.commandId);
+    for (const prompt of snapshot.pending.prompts)
+        if (messageAuthor(prompt.meta)?.id === visitorId)
+            commands.add(prompt.commandId);
+    return commands;
+}
+function visibleMessages(snapshot, visitorId) {
+    const commands = visitorCommands(snapshot, visitorId);
+    return snapshot.messages.filter(({ commandId, value, meta }) => value.role === "user"
+        ? messageAuthor(meta)?.id === visitorId
+        : value.role === "assistant" &&
+            (value.provider === "operator" ||
+                (commandId !== null && commands.has(commandId))));
+}
+/** Visitor-scoped Session facts use the visitor's public address, never the internal Session ID. */
+export function visitorSnapshot(snapshot, visitorId) {
+    const commands = visitorCommands(snapshot, visitorId);
+    const messages = [];
+    for (const { id, sequence, commandId, value, meta } of visibleMessages(snapshot, visitorId)) {
+        if (value.role === "user") {
+            messages.push({
+                id,
+                sequence,
+                commandId,
+                requestId: sourceRequestId(meta),
+                value: {
+                    role: "user",
+                    content: userText(value),
+                    timestamp: value.timestamp,
+                },
+            });
+        }
+        else if (value.role === "assistant") {
+            const message = {
+                id,
+                sequence,
+                commandId,
+                value: {
+                    role: "assistant",
+                    content: value.content.filter((part) => part.type === "text"),
+                    api: "visitor",
+                    provider: "visitor",
+                    model: "visitor",
+                    usage: {
+                        input: 0,
+                        output: 0,
+                        cacheRead: 0,
+                        cacheWrite: 0,
+                        totalTokens: 0,
+                        cost: {
+                            input: 0,
+                            output: 0,
+                            cacheRead: 0,
+                            cacheWrite: 0,
+                            total: 0,
+                        },
+                    },
+                    stopReason: value.stopReason,
+                    timestamp: value.timestamp,
+                },
+            };
+            messages.push(value.provider === "operator"
+                ? {
+                    ...message,
+                    // A visitor never sees which member answered.
+                    meta: authorMeta({
+                        id: "channel-operator",
+                        name: "A person from the team",
+                    }),
+                }
+                : message);
+        }
+    }
+    const ownWork = snapshot.activity.queue.state !== "idle" &&
+        commands.has(snapshot.activity.queue.commandId);
+    const pendingPrompts = snapshot.pending.prompts
+        .filter(({ meta }) => messageAuthor(meta)?.id === visitorId)
+        .map((prompt) => visitorPendingPrompt(prompt, visitorId));
+    const projected = {
+        sessionId: visitorId,
+        cursor: snapshot.cursor,
+        hasMore: snapshot.hasMore,
+        messages,
+        terminals: snapshot.terminals
+            .filter(({ commandId }) => commands.has(commandId))
+            .map(({ commandId, outcome, sequence }) => ({
+            commandId,
+            outcome,
+            sequence,
+            diagnostic: null,
+        })),
+        pending: {
+            total: pendingPrompts.length,
+            hasMore: snapshot.pending.hasMore,
+            prompts: pendingPrompts,
+        },
+        activity: {
+            queue: !ownWork
+                ? { state: "idle" }
+                : snapshot.activity.queue.state === "queued"
+                    ? { ...snapshot.activity.queue, runningWork: null }
+                    : snapshot.activity.queue,
+            cancellationRequested: ownWork && snapshot.activity.cancellationRequested,
+            activeTool: null,
+            lastModelChoiceSequence: null,
+            compaction: null,
+            retry: !ownWork || snapshot.activity.retry === null
+                ? null
+                : { ...snapshot.activity.retry, errorMessage: "Chat is retrying" },
+        },
+        toolOutput: [],
+        progress: !ownWork || snapshot.progress === null
+            ? null
+            : {
+                ...snapshot.progress,
+                thinking: "",
+                thinkingOffset: 0,
+                thinkingTruncated: false,
+            },
+        extensions: {},
+        attention: [],
+    };
+    return snapshot.oldestCursor === undefined
+        ? projected
+        : { ...projected, oldestCursor: snapshot.oldestCursor };
+}
+/** Project only this visitor's host-attributed prompts, their replies, and explicit operator replies. */
+export function visitorView(snapshot, visitorId) {
+    if (snapshot === null)
+        return { status: "idle", lines: [], progress: null };
+    const lines = [];
+    for (const { id, value } of visibleMessages(snapshot, visitorId)) {
+        if (value.role === "user") {
+            lines.push({
+                id,
+                from: "visitor",
+                text: userText(value),
+            });
+        }
+        else if (value.role === "assistant") {
+            const text = value.content
+                .flatMap((part) => (part.type === "text" ? [part.text] : []))
+                .join("")
+                .trim();
+            if (text.length > 0)
+                lines.push({
+                    id,
+                    from: value.provider === "operator" ? "operator" : "agent",
+                    text,
+                });
+        }
+    }
+    for (const prompt of snapshot.pending.prompts)
+        if (messageAuthor(prompt.meta)?.id === visitorId)
+            lines.push({
+                id: `pending:${prompt.commandId}`,
+                from: "visitor",
+                text: prompt.text,
+            });
+    const commands = visitorCommands(snapshot, visitorId);
+    const working = (snapshot.activity.queue.state !== "idle" &&
+        commands.has(snapshot.activity.queue.commandId)) ||
+        snapshot.pending.prompts.some(({ meta }) => messageAuthor(meta)?.id === visitorId);
+    const progress = working ? (snapshot.progress?.text.trim() ?? "") : "";
+    return {
+        status: working ? "working" : "idle",
+        lines,
+        progress: progress.length > 0 ? progress : null,
+    };
+}

package/dist/client-wire.d.ts

@@ -149,6 +149,8 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
         revision: number;
         text: string;
         thinking: string;
+        textOffset: number;
+        thinkingOffset: number;
         textTruncated: boolean;
         thinkingTruncated: boolean;
     }>, Readonly<{
@@ -156,6 +158,8 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
         revision: number;
         text: string;
         thinking: string;
+        textOffset: number;
+        thinkingOffset: number;
         textTruncated: boolean;
         thinkingTruncated: boolean;
     }>, never, never>>;
@@ -175,6 +179,11 @@ export declare const SessionSnapshotSchema: Schema.Struct<{
         readonly since: Schema.Int;
         readonly expiresAt: Schema.optional<Schema.Int>;
         readonly inbox: Schema.optional<Schema.Literal<false>>;
+        readonly waitingOn: Schema.optional<Schema.Struct<{
+            readonly agentId: Schema.NonEmptyString;
+            readonly sessionId: Schema.NonEmptyString;
+            readonly name: Schema.NonEmptyString;
+        }>>;
     }>>;
     readonly context: Schema.optionalKey<Schema.Struct<{
         readonly tokens: Schema.Int;

package/dist/client-wire.js

@@ -33,6 +33,7 @@ const SessionActivitySchema = Schema.Struct({
                     kind: Schema.Literal("session"),
                     sessionId: Schema.NonEmptyString,
                     commandId: Schema.NonEmptyString,
+                    title: Schema.String,
                 }),
                 Schema.Struct({
                     kind: Schema.Literal("host"),
@@ -110,11 +111,14 @@ const SessionCompactionNoticeSchema = Schema.Struct({
     ]),
     diagnostic: Schema.NullOr(Schema.String),
 });
+const ProgressTailSchema = Schema.String.check(Schema.makeFilter((value) => new TextEncoder().encode(value).byteLength <= 65_536));
 const SessionProgressSchema = Schema.Struct({
     messageId: Schema.String,
     revision: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-    text: Schema.String,
-    thinking: Schema.String,
+    text: ProgressTailSchema,
+    thinking: ProgressTailSchema,
+    textOffset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    thinkingOffset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
     textTruncated: Schema.Boolean,
     thinkingTruncated: Schema.Boolean,
 });
@@ -190,7 +194,18 @@ export const SessionFrameSchema = Schema.Union([
     }),
     Schema.Struct({
         kind: Schema.Literal("progress"),
-        progress: SessionProgressSchema,
+        progress: Schema.Struct({
+            messageId: Schema.String,
+            revision: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+            text: Schema.Struct({
+                offset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+                append: ProgressTailSchema,
+            }),
+            thinking: Schema.Struct({
+                offset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+                append: ProgressTailSchema,
+            }),
+        }),
         activity: SessionActivitySchema,
     }),
     Schema.Struct({
@@ -282,10 +297,16 @@ export function parseForkedSession(value) {
 /** Exact command facts shared by Session clients and host fleet transports. */
 export const commandSettlementSchema = Schema.Struct({
     acceptedSender: Schema.NullOr(Schema.String),
+    delegator: Schema.NullOr(Schema.String),
     terminal: SessionTerminalSchema,
     content: Schema.String,
     usage: Schema.Array(Schema.Struct({ provider: Schema.String, model: Schema.String, usage })),
     toolCalls: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    waitingOnYou: Schema.Array(Schema.Struct({
+        itemId: Schema.String,
+        kind: Schema.String,
+        summary: Schema.String,
+    })).check(Schema.isMaxLength(8)),
 });
 /** A timeout is null on the JSON wire and undefined at the client boundary. */
 export function parseCommandSettlement(value) {

package/dist/client.d.ts

@@ -5,12 +5,13 @@ export { type SessionAttention } from "./session-attention.js";
 import type { SandboxFailureEvent } from "@fungi.computer/mycelium";
 import type { ModelPreference } from "./internal/model-preference.js";
 import type { Message } from "@fungi.computer/mule/effect";
-import type { ExtensionSlotV0, ExtensionStatusV0, Json } from "./extensions.js";
+import type { ExtensionCommandCallerV0, ExtensionSlotV0, ExtensionStatusV0, Json } from "./extensions.js";
 import type { AbortCommand, BranchCommand, CompactCommand, OperatorCommand, TitleCommand, CancelCommand, ForkCommand, PromptCommand, PromptDelivery, SessionCommand } from "./internal/client-boundary.js";
 export { createShiitakeClient, type ShiitakeClientOptions, } from "./remote-client.js";
 export { bindAgentExtension, bindSessionExtension, type BoundAgentExtensionV0, type BoundCallV0, type BoundSessionExtensionV0, type ExtensionViewV0, type ScopedCommandsV0, } from "./extension-client.js";
 export { AcceptedSchema, DelegationReceiptSchema, HeldSchema, parseAccepted, parseDelegationReceipt, parseCancelResult, parseLatestPendingPrompt, parseWithdrawResult, parseForkedSession, parseSessionFrame, parseSessionSnapshot, parseSessionSummaryPage, parseShiitakeError, } from "./client-wire.js";
 export type { AbortCommand, BranchCommand, CompactCommand, CancelCommand, ForkCommand, OperatorCommand, PromptCommand, PromptDelivery, SessionCommand, TitleCommand, } from "./internal/client-boundary.js";
+export { participantSnapshot, visitorPendingPrompt, visitorSnapshot, visitorView, type ParticipantPolicy, type VisitorLine, type VisitorPendingPrompt, type VisitorView, } from "./client-visitor.js";
 /** Semantic acknowledgement returned after one durable acceptance commit. */
 export type Accepted = Readonly<{
     /** Indicates that the owner transaction committed. */
@@ -131,11 +132,13 @@ export type SessionTerminal = Readonly<{
      */
     meta?: Json;
 }>;
-/** Work occupying the executor partition that this queued command requires, without message or provider data. */
+/** Blocking executor identity and Session display metadata, never messages or provider data. */
 export type AgentRunningWork = Readonly<{
     kind: "session";
     sessionId: string;
     commandId: string;
+    /** Owner-issued display title; empty when no title is known. */
+    title: string;
 }> | Readonly<{
     kind: "host";
     lane: string;
@@ -185,8 +188,8 @@ export type SessionActivity = Readonly<{
 export type SessionExtensionSlots = Readonly<Record<string, ExtensionSlotV0>>;
 /** Generic Session-scope extension commands. */
 export type SessionExtensionControls = Readonly<{
-    /** Call one Session-scope command with its encoded input; resolves the encoded output. */
-    call: (command: string, input: Json) => Promise<Json>;
+    /** Call one Session-scope command with its encoded input and optional host caller. */
+    call: (command: string, input: Json, caller?: ExtensionCommandCallerV0) => Promise<Json>;
 }>;
 /** Generic Agent-scope extension controls. */
 export type AgentExtensionControls = Readonly<{
@@ -212,9 +215,27 @@ export type SessionProgress = Readonly<{
     revision: number;
     text: string;
     thinking: string;
+    /** UTF-16 offsets of the retained tails, not byte offsets. */
+    textOffset: number;
+    thinkingOffset: number;
     textTruncated: boolean;
     thinkingTruncated: boolean;
 }>;
+/** Append-only progress on the wire. Offsets count JavaScript string units. */
+export type SessionProgressDelta = Readonly<{
+    messageId: string;
+    revision: number;
+    text: Readonly<{
+        offset: number;
+        append: string;
+    }>;
+    thinking: Readonly<{
+        offset: number;
+        append: string;
+    }>;
+}>;
+/** Fold a decoded append once; a missing prefix waits for an owner reset. */
+export declare function appendSessionProgress(current: SessionProgress | null, delta: SessionProgressDelta): SessionProgress | null;
 /** Accepted prompt waiting to enter the conversation, not a scheduling command. */
 export type SessionPendingPrompt = Readonly<{
     /** Caller identity, available even before the command response reaches its client. */
@@ -369,9 +390,9 @@ export type SessionFrame = Readonly<{
      */
     context?: SessionContext;
 }> | Readonly<{
-    /** Bounded process-local assistant progress. */
+    /** Only new text/thinking; snapshots, not frames, carry retained tails. */
     kind: "progress";
-    progress: SessionProgress;
+    progress: SessionProgressDelta;
     /** Raw facts about the Session's activity read with this progress. */
     activity: SessionActivity;
 }> | Readonly<{

package/dist/client.js

@@ -2,3 +2,26 @@ export {} from "./session-attention.js";
 export { createShiitakeClient, } from "./remote-client.js";
 export { bindAgentExtension, bindSessionExtension, } from "./extension-client.js";
 export { AcceptedSchema, DelegationReceiptSchema, HeldSchema, parseAccepted, parseDelegationReceipt, parseCancelResult, parseLatestPendingPrompt, parseWithdrawResult, parseForkedSession, parseSessionFrame, parseSessionSnapshot, parseSessionSummaryPage, parseShiitakeError, } from "./client-wire.js";
+export { participantSnapshot, visitorPendingPrompt, visitorSnapshot, visitorView, } from "./client-visitor.js";
+/** Fold a decoded append once; a missing prefix waits for an owner reset. */
+export function appendSessionProgress(current, delta) {
+    const previous = current?.messageId === delta.messageId ? current : null;
+    if (previous !== null && previous.revision >= delta.revision)
+        return current;
+    const textEnd = previous === null ? 0 : previous.textOffset + previous.text.length;
+    const thinkingEnd = previous === null ? 0 : previous.thinkingOffset + previous.thinking.length;
+    if (delta.text.offset > textEnd || delta.thinking.offset > thinkingEnd)
+        return current;
+    return {
+        messageId: delta.messageId,
+        revision: delta.revision,
+        text: (previous?.text ?? "") +
+            delta.text.append.slice(Math.max(0, textEnd - delta.text.offset)),
+        thinking: (previous?.thinking ?? "") +
+            delta.thinking.append.slice(Math.max(0, thinkingEnd - delta.thinking.offset)),
+        textOffset: previous?.textOffset ?? 0,
+        thinkingOffset: previous?.thinkingOffset ?? 0,
+        textTruncated: previous?.textTruncated ?? false,
+        thinkingTruncated: previous?.thinkingTruncated ?? false,
+    };
+}

package/dist/cloudflare.d.ts

@@ -102,6 +102,11 @@ export type CloudflareShiitakeOptions = Readonly<{
      * refuses for storage pressure. The budget and thresholds are the host's.
      */
     storagePressure?: StoragePressureCheck;
+    /** Host-owned synchronous check at the single new-work admission door. */
+    admission?: Readonly<{
+        /** Check the host's current flag synchronously inside admission's transaction. */
+        assertOpen: () => void;
+    }>;
     /** Compaction budgets; absent uses Pi's defaults for every model. */
     compaction?: CompactionOptions;
     /** The host's explicit extension roster and grants; there is no default. */
@@ -127,6 +132,21 @@ export type CloudflareShiitakeOptions = Readonly<{
 }>;
 /** Cloudflare host lifecycle; alarm forwarding stays outside the neutral client. */
 export type CloudflareShiitake = ShiitakeOwnerAgent & Readonly<{
+    /** Read durable queued/running Session or unresolved delegated work in the
+     * host's SQLite transaction, immediately before changing archived state.
+     * A confirmed remote settlement must be recorded locally first; unavailable
+     * remote settlement remains busy, not idle. Never use an in-memory counter.
+     */
+    busySync: () => Readonly<{
+        kind: "session";
+        sessionId: string;
+        commandId: string;
+    }> | Readonly<{
+        kind: "delegation";
+        agentId: string;
+        sessionId: string;
+        commandId: string;
+    }> | undefined;
     /** Exact settled command facts, outside the neutral Session transport. */
     readSettlement: (sessionId: string, commandId: string) => Promise<CommandSettlement | undefined>;
     /**

package/dist/cloudflare.js

@@ -277,6 +277,8 @@ function effectOptions(state, options, runtime) {
         Object.assign(base, { meta: options.meta });
     if (options.storagePressure !== undefined)
         Object.assign(base, { storagePressure: options.storagePressure });
+    if (options.admission !== undefined)
+        Object.assign(base, { admission: options.admission });
     if (options.compaction !== undefined)
         Object.assign(base, { compaction: options.compaction });
     return tools === undefined ? base : { ...base, tools };
@@ -319,7 +321,7 @@ export function makeCloudflareShiitake(unnamed, options) {
     const coreOptions = effectOptions(state, options, host.runtime);
     return import("./internal/runtime-core.js")
         .then(({ openRuntimeCore }) => runShiitakePromise(openRuntimeCore(coreOptions, options.mailRoom)))
-        .then(async ({ agent, activeSessions, acceptMail, readSettlement }) => {
+        .then(async ({ agent, activeSessions, busySync, acceptMail, readSettlement, }) => {
         const handle = toPromiseOwner(agent);
         try {
             await options.initialize?.(handle);
@@ -340,6 +342,7 @@ export function makeCloudflareShiitake(unnamed, options) {
             },
             alarm: host.alarm,
             activeSessions: () => runShiitakePromise(activeSessions),
+            busySync,
             abortActive: async () => {
                 for (const sessionId of await runShiitakePromise(activeSessions))
                     await runShiitakePromise(agent.session(sessionId).abort);