@fungi.computer/shiitake 0.5.0 → 0.7.0

package/dist/internal/woodstock/work-senders.d.ts

@@ -0,0 +1,32 @@
+import { type AttentionRecipient } from "../../session-attention.js";
+import type { SqliteOwner } from "../contracts.js";
+/** One open item of a Session that waits on the Agent that sent its work. */
+export type WaitingOnYou = Readonly<{
+    itemId: string;
+    kind: string;
+    summary: string;
+}>;
+/**
+ * Woodstock records which Agent Session sent each accepted run, beside the
+ * run's admission. Attention that an extension raises during a run waits on
+ * this sender first; a run no Agent sent has no row.
+ */
+export declare function prepareWorkSenders(owner: SqliteOwner): void;
+/** Record the sender of one accepted run; a replay writes the same row. */
+export declare function recordWorkSender(owner: SqliteOwner, sessionId: string, workId: string, sender: AttentionRecipient): void;
+/** The Agent Session that sent this run, or undefined when none did. */
+export declare function readWorkSender(owner: SqliteOwner, sessionId: string, workId: string): AttentionRecipient | undefined;
+/**
+ * The Session's open attention that waits on the sender of this run, newest
+ * first as stored, bounded. Escalated items wait on someone else and are
+ * absent; a run no Agent sent names none.
+ */
+export declare function readWaitingOnSender(owner: SqliteOwner, sessionId: string, workId: string): readonly WaitingOnYou[];
+/**
+ * The Session's open attention that waits on any of these Agent Sessions,
+ * newest first as stored, bounded: what a reply or report to them names.
+ */
+export declare function readWaitingOn(owner: SqliteOwner, sessionId: string, recipients: readonly Readonly<{
+    agentId: string;
+    sessionId: string;
+}>[]): readonly WaitingOnYou[];

package/dist/internal/woodstock/work-senders.js

@@ -0,0 +1,70 @@
+import * as Schema from "effect/Schema";
+import { AttentionRecipientSchema, } from "../../session-attention.js";
+import { readSessionAttention } from "./session-attention.js";
+/** The most open items one settlement names as waiting on its sender. */
+const maximumWaitingOnYou = 8;
+const decodeRow = Schema.decodeUnknownSync(Schema.Struct({
+    agent_id: Schema.String,
+    sender_session_id: Schema.String,
+    name: Schema.String,
+}));
+const decodeRecipient = Schema.decodeUnknownSync(AttentionRecipientSchema);
+/**
+ * Woodstock records which Agent Session sent each accepted run, beside the
+ * run's admission. Attention that an extension raises during a run waits on
+ * this sender first; a run no Agent sent has no row.
+ */
+export function prepareWorkSenders(owner) {
+    owner.sql.exec(`CREATE TABLE IF NOT EXISTS session_work_senders (
+    session_id TEXT NOT NULL,
+    work_id TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    sender_session_id TEXT NOT NULL,
+    name TEXT NOT NULL,
+    PRIMARY KEY (session_id, work_id)
+  )`);
+}
+/** Record the sender of one accepted run; a replay writes the same row. */
+export function recordWorkSender(owner, sessionId, workId, sender) {
+    owner.sql.exec(`INSERT OR IGNORE INTO session_work_senders
+       (session_id, work_id, agent_id, sender_session_id, name)
+     VALUES (?, ?, ?, ?, ?)`, sessionId, workId, sender.agentId, sender.sessionId, sender.name);
+}
+/** The Agent Session that sent this run, or undefined when none did. */
+export function readWorkSender(owner, sessionId, workId) {
+    const raw = owner.sql
+        .exec("SELECT agent_id, sender_session_id, name FROM session_work_senders WHERE session_id = ? AND work_id = ?", sessionId, workId)
+        .toArray()[0];
+    if (raw === undefined)
+        return undefined;
+    const row = decodeRow(raw);
+    return decodeRecipient({
+        agentId: row.agent_id,
+        sessionId: row.sender_session_id,
+        name: row.name,
+    });
+}
+/**
+ * The Session's open attention that waits on the sender of this run, newest
+ * first as stored, bounded. Escalated items wait on someone else and are
+ * absent; a run no Agent sent names none.
+ */
+export function readWaitingOnSender(owner, sessionId, workId) {
+    const sender = readWorkSender(owner, sessionId, workId);
+    return sender === undefined ? [] : readWaitingOn(owner, sessionId, [sender]);
+}
+/**
+ * The Session's open attention that waits on any of these Agent Sessions,
+ * newest first as stored, bounded: what a reply or report to them names.
+ */
+export function readWaitingOn(owner, sessionId, recipients) {
+    return readSessionAttention(owner, sessionId)
+        .filter((item) => recipients.some((recipient) => item.waitingOn?.agentId === recipient.agentId &&
+        item.waitingOn.sessionId === recipient.sessionId))
+        .slice(0, maximumWaitingOnYou)
+        .map((item) => ({
+        itemId: item.id,
+        kind: item.kind,
+        summary: item.summary,
+    }));
+}

package/dist/node.js

@@ -50,8 +50,13 @@ export function nodeRuntimeHost(observeFailure) {
         wakeTimer = setTimeout(() => {
             wakeTimer = undefined;
             wakeAt = undefined;
+            // A capped wait may finish before the actual deadline.
+            if (at > Date.now()) {
+                scheduleWake(at);
+                return;
+            }
             void bound?.requestWake().catch(reportFailure);
-        }, Math.max(0, at - Date.now()));
+        }, Math.min(2_147_483_647, Math.max(0, at - Date.now())));
     };
     const runtime = Object.freeze({
         bind: ({ reconcile, pendingWork }) => {
@@ -133,7 +138,11 @@ export function nodeRuntimeHost(observeFailure) {
     return Object.freeze({
         runtime,
         scheduleWake,
-        close: () => bound?.close() ?? Promise.resolve(),
+        close: () => {
+            scheduleWake(null);
+            closed = true;
+            return bound?.close() ?? Promise.resolve();
+        },
     });
 }
 /**

package/dist/remote-client.js

@@ -72,7 +72,12 @@ function remoteEvents(url, clientClosed, sources, eventSource) {
                 closed: false,
             };
             const emit = (kind, event) => {
-                Queue.offerUnsafe(queue, { kind, event });
+                if (!Queue.offerUnsafe(queue, { kind, event })) {
+                    // A dropped frame breaks this watch's ordering. Fail instead
+                    // of delivering an incomplete history to the client.
+                    Queue.failCauseUnsafe(queue, Cause.fail(unavailable("Session stream client fell behind")));
+                    Effect.runSync(closeRemoteSource(active, sources));
+                }
             };
             active.source.addEventListener("snapshot", (event) => {
                 emit("snapshot", event);
@@ -91,7 +96,7 @@ function remoteEvents(url, clientClosed, sources, eventSource) {
             return active;
         },
         catch: () => unavailable("Session stream could not open"),
-    }), (active) => closeRemoteSource(active, sources))).pipe(Stream.mapEffect(decodeRemoteEvent), Stream.interruptWhen(clientClosed.await));
+    }), (active) => closeRemoteSource(active, sources)), { bufferSize: 256, strategy: "dropping" }).pipe(Stream.mapEffect(decodeRemoteEvent), Stream.interruptWhen(clientClosed.await));
 }
 function sessionUrl(baseUrl, sessionId) {
     return `${baseUrl}/sessions/${encodeURIComponent(sessionId)}`;

package/dist/server-visitor-stream.d.ts

@@ -0,0 +1,13 @@
+import type { SessionSnapshot, SessionWatch } from "./client.js";
+export type VisitorStreamError = "channel_visitor_stream_expiry_failed" | "channel_visitor_stream_close_failed" | "channel_visitor_stream_heartbeat_failed" | "channel_visitor_stream_failed";
+export declare function visitorStream(options: Readonly<{
+    watch: SessionWatch;
+    visitorId: string;
+    filter: (snapshot: SessionSnapshot) => SessionSnapshot;
+    expiresAt: number;
+    now: () => number;
+    release: () => void;
+    canRead: () => Promise<boolean>;
+    read: () => Promise<SessionSnapshot>;
+    onError: (event: VisitorStreamError, cause: unknown) => void;
+}>): ReadableStream<Uint8Array>;

package/dist/server-visitor-stream.js

@@ -0,0 +1,124 @@
+import { SSEStreamingApi } from "hono/streaming";
+import { visitorSnapshot } from "./client-visitor.js";
+export function visitorStream(options) {
+    const { readable, writable } = new TransformStream();
+    const stream = new SSEStreamingApi(writable, readable);
+    let closing;
+    let ending = false;
+    let heartbeat;
+    const expiry = setTimeout(() => {
+        void close().catch((cause) => {
+            options.onError("channel_visitor_stream_expiry_failed", cause);
+        });
+    }, Math.max(0, options.expiresAt - options.now()));
+    const close = () => {
+        if (closing !== undefined)
+            return closing;
+        ending = true;
+        clearTimeout(expiry);
+        clearTimeout(heartbeat);
+        options.release();
+        closing = Promise.resolve().then(async () => {
+            stream.abort();
+            try {
+                await options.watch.close();
+            }
+            finally {
+                await stream.close();
+            }
+        });
+        return closing;
+    };
+    stream.onAbort(() => {
+        void close().catch((cause) => {
+            options.onError("channel_visitor_stream_close_failed", cause);
+        });
+    });
+    const admitted = async () => !ending &&
+        options.now() < options.expiresAt &&
+        (await options.canRead()) &&
+        !ending;
+    const beat = async () => {
+        if (!(await admitted())) {
+            await close();
+            return;
+        }
+        await stream.write(": heartbeat\n\n");
+        if (!ending)
+            heartbeat = setTimeout(() => {
+                void beat().catch((cause) => {
+                    options.onError("channel_visitor_stream_heartbeat_failed", cause);
+                    void close().catch((closeCause) => {
+                        options.onError("channel_visitor_stream_close_failed", closeCause);
+                    });
+                });
+            }, 30_000);
+    };
+    const publish = async (snapshot) => {
+        if (!(await admitted()))
+            return false;
+        const baseline = visitorSnapshot(options.filter(snapshot), options.visitorId);
+        await stream.writeSSE({ event: "session", data: JSON.stringify(baseline) });
+        return !ending;
+    };
+    const pump = async () => {
+        try {
+            let snapshot = options.watch.snapshot;
+            if (!(await publish(snapshot)))
+                return;
+            heartbeat = setTimeout(() => {
+                void beat().catch((cause) => {
+                    options.onError("channel_visitor_stream_heartbeat_failed", cause);
+                    void close().catch((closeCause) => {
+                        options.onError("channel_visitor_stream_close_failed", closeCause);
+                    });
+                });
+            }, 30_000);
+            for await (const frame of options.watch.changes) {
+                if (ending)
+                    break;
+                if (frame.kind === "tool_output")
+                    continue;
+                if (frame.kind === "progress" || frame.kind === "activity") {
+                    if (!(await admitted()))
+                        break;
+                    snapshot = { ...snapshot, activity: frame.activity };
+                    const baseline = visitorSnapshot(options.filter(snapshot), options.visitorId);
+                    if (baseline.activity.queue.state === "idle") {
+                        if (frame.kind === "activity")
+                            await stream.writeSSE({
+                                event: "session",
+                                data: JSON.stringify(baseline),
+                            });
+                        continue;
+                    }
+                    await stream.writeSSE({
+                        event: "frame",
+                        data: JSON.stringify(frame.kind === "activity"
+                            ? { kind: "activity", activity: baseline.activity }
+                            : {
+                                ...frame,
+                                progress: {
+                                    ...frame.progress,
+                                    thinking: { offset: 0, append: "" },
+                                },
+                                activity: baseline.activity,
+                            }),
+                    });
+                    continue;
+                }
+                snapshot =
+                    frame.kind === "reset" ? frame.baseline : await options.read();
+                if (!(await publish(snapshot)))
+                    break;
+            }
+        }
+        finally {
+            await close();
+        }
+    };
+    void pump().catch((cause) => {
+        options.onError("channel_visitor_stream_failed", cause);
+    });
+    return stream.responseReadable.pipeThrough(new TransformStream());
+}

package/dist/session-attention.d.ts

@@ -1,7 +1,21 @@
 import * as Schema from "effect/Schema";
+/**
+ * The Agent Session that sent the work an item belongs to. The host derives it
+ * from the accepted mail; it is the only party the item waits on until it is
+ * escalated.
+ */
+export declare const AttentionRecipientSchema: Schema.Struct<{
+    readonly agentId: Schema.NonEmptyString;
+    readonly sessionId: Schema.NonEmptyString;
+    readonly name: Schema.NonEmptyString;
+}>;
+/** Decoded Agent Session an attention item waits on. */
+export type AttentionRecipient = typeof AttentionRecipientSchema.Type;
 /**
  * An extension-owned request for human attention; expiry is owned by its timer.
  * Items marked `inbox: false` remain visible without changing the inbox state.
+ * An item with `waitingOn` waits on that Agent first and is never a person's
+ * inbox item until it is escalated past every Agent.
  */
 export declare const AttentionItemSchema: Schema.Struct<{
     readonly id: Schema.NonEmptyString;
@@ -11,6 +25,12 @@ export declare const AttentionItemSchema: Schema.Struct<{
     readonly expiresAt: Schema.optional<Schema.Int>;
     /** This item does not change the Session's inbox state; omission does. */
     readonly inbox: Schema.optional<Schema.Literal<false>>;
+    /** The Agent this item waits on; absent means a person. */
+    readonly waitingOn: Schema.optional<Schema.Struct<{
+        readonly agentId: Schema.NonEmptyString;
+        readonly sessionId: Schema.NonEmptyString;
+        readonly name: Schema.NonEmptyString;
+    }>>;
 }>;
 /** Input to the granted attention door, scoped to the calling extension. */
 export type AttentionItem = typeof AttentionItemSchema.Type;
@@ -23,6 +43,11 @@ export declare const SessionAttentionSchema: 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;
+    }>>;
 }>;
 /** One open attention item in a Session observation. */
 export type SessionAttention = typeof SessionAttentionSchema.Type;
@@ -39,4 +64,9 @@ export declare const SessionAttentionListSchema: Schema.$Array<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;
+    }>>;
 }>>;

package/dist/session-attention.js

@@ -1,9 +1,21 @@
 import * as Schema from "effect/Schema";
 const identity = Schema.NonEmptyString.check(Schema.isMaxLength(256));
 const instant = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+/**
+ * The Agent Session that sent the work an item belongs to. The host derives it
+ * from the accepted mail; it is the only party the item waits on until it is
+ * escalated.
+ */
+export const AttentionRecipientSchema = Schema.Struct({
+    agentId: identity,
+    sessionId: identity,
+    name: identity,
+});
 /**
  * An extension-owned request for human attention; expiry is owned by its timer.
  * Items marked `inbox: false` remain visible without changing the inbox state.
+ * An item with `waitingOn` waits on that Agent first and is never a person's
+ * inbox item until it is escalated past every Agent.
  */
 export const AttentionItemSchema = Schema.Struct({
     id: identity,
@@ -13,6 +25,8 @@ export const AttentionItemSchema = Schema.Struct({
     expiresAt: Schema.optional(instant),
     /** This item does not change the Session's inbox state; omission does. */
     inbox: Schema.optional(Schema.Literal(false)),
+    /** The Agent this item waits on; absent means a person. */
+    waitingOn: Schema.optional(AttentionRecipientSchema),
 });
 /** Public identity includes the owner so two extensions can use the same id. */
 export const SessionAttentionSchema = AttentionItemSchema.mapFields((fields) => ({

package/docs/api/agent-control.md

@@ -31,7 +31,7 @@ new AgentArchiveRefused(reason, message): AgentArchiveRefused;
 
 | Parameter | Type                                                                                           |
 | --------- | ---------------------------------------------------------------------------------------------- |
-| `reason`  | \| `"running"` \| `"pending"` \| `"archived"` \| `"not_creator"` \| `"self"` \| `"unreadable"` |
+| `reason`  | \| `"archived"` \| `"running"` \| `"pending"` \| `"not_creator"` \| `"self"` \| `"unreadable"` |
 | `message` | `string`                                                                                       |
 
 ###### Returns
@@ -62,9 +62,9 @@ Error.name;
 
 ```ts
 readonly reason:
+  | "archived"
   | "running"
   | "pending"
-  | "archived"
   | "not_creator"
   | "self"
   | "unreadable";
@@ -75,8 +75,9 @@ readonly reason:
 ### AgentCreateRefused
 
 A host's refusal of an Agent creating an Agent: the creator asked to give the
-created Agent more than it holds, or the host cannot tell which Agent is
-creating. It reaches the caller as an `agents.create` failure.
+created Agent more than it holds, the host cannot tell which Agent is creating,
+or the request id belongs to another creating Agent or Session. It reaches the
+caller as an `agents.create` failure.
 
 #### Extends
 
@@ -92,10 +93,10 @@ new AgentCreateRefused(reason, message): AgentCreateRefused;
 
 ###### Parameters
 
-| Parameter | Type                                  |
-| --------- | ------------------------------------- |
-| `reason`  | `"exceeds_creator"` \| `"no_creator"` |
-| `message` | `string`                              |
+| Parameter | Type                                                          |
+| --------- | ------------------------------------------------------------- |
+| `reason`  | `"exceeds_creator"` \| `"no_creator"` \| `"request_conflict"` |
+| `message` | `string`                                                      |
 
 ###### Returns
 
@@ -124,11 +125,62 @@ Error.name;
 ##### reason
 
 ```ts
-readonly reason: "exceeds_creator" | "no_creator";
+readonly reason: "exceeds_creator" | "no_creator" | "request_conflict";
 ```
 
 ## Type Aliases
 
+### AgentControlAnswerInput
+
+```ts
+type AgentControlAnswerInput = Readonly<{
+  agentId: string;
+  sessionId: string;
+  askId: string;
+  requestId: string;
+  answers: MyceliumJsonValue;
+}>;
+```
+
+Sender-authenticated submission for one child Session's routed Ask.
+
+---
+
+### AgentControlEscalateInput
+
+```ts
+type AgentControlEscalateInput = Readonly<{
+  agentId: string;
+  sessionId: string;
+  itemId: string;
+  note?: string;
+}>;
+```
+
+Sender-authenticated escalation of one item a child Session left waiting.
+
+---
+
+### AgentControlAnswerOutput
+
+```ts
+type AgentControlAnswerOutput = z.infer<typeof answerOutput>;
+```
+
+Typed outcome of a sender's answer to a child Ask.
+
+---
+
+### AgentControlEscalateOutput
+
+```ts
+type AgentControlEscalateOutput = z.infer<typeof escalateOutput>;
+```
+
+Typed outcome of a sender's escalation of a child's item.
+
+---
+
 ### ArchiveRefusalReason
 
 ```ts
@@ -173,10 +225,17 @@ One host-offered model usable as an Agent's create or setModel choice.
 ```ts
 type AgentDelegationInput = Readonly<{
   agentId: string;
-  sessionId: string;
   text: string;
   requestId: string;
-  delivery: "steer" | "followUp";
+}> &
+  | Readonly<{
+  sessionId: string;
+  delivery: "steer";
+}>
+  | Readonly<{
+  sessionId?: string;
+  delivery: "followUp";
+  goal?: string | false;
 }>;
 ```
 
@@ -226,6 +285,16 @@ type AgentControlDirectory = Readonly<{
     invocation?,
   ) => Promise<Accepted | Held>;
   recall?: (input, sourceSessionId, signal) => Promise<CancelResult>;
+  answer?: (
+    input,
+    senderSessionId,
+    signal,
+  ) => Promise<AgentControlAnswerOutput>;
+  escalate?: (
+    input,
+    senderSessionId,
+    signal,
+  ) => Promise<AgentControlEscalateOutput>;
   create?: (input, signal) => Promise<AgentControlAgent>;
   setModel?: (input, signal) => Promise<void>;
   archive?: (input, signal) => Promise<void>;
@@ -248,6 +317,126 @@ Host-owned discovery and per-operation access to ordinary Agents.
 
 ## Variables
 
+### answerOutput
+
+```ts
+const answerOutput: ZodDiscriminatedUnion<
+  [
+    ZodObject<
+      {
+        status: ZodLiteral<"answered">;
+        via: ZodEnum<{
+          in_turn: "in_turn";
+          follow_up: "follow_up";
+        }>;
+        commandId: ZodExactOptional<ZodString>;
+      },
+      $strict
+    >,
+    ZodObject<
+      {
+        status: ZodLiteral<"not_found">;
+      },
+      $strict
+    >,
+    ZodObject<
+      {
+        status: ZodLiteral<"closed">;
+        reason: ZodEnum<{
+          cancelled: "cancelled";
+          undeliverable: "undeliverable";
+          answered: "answered";
+          declined: "declined";
+          withdrawn: "withdrawn";
+          expired: "expired";
+        }>;
+      },
+      $strict
+    >,
+    ZodObject<
+      {
+        status: ZodLiteral<"refused">;
+        reason: ZodEnum<{
+          not_sender: "not_sender";
+          no_provenance: "no_provenance";
+        }>;
+      },
+      $strict
+    >,
+    ZodObject<
+      {
+        status: ZodLiteral<"unavailable">;
+        reason: ZodLiteral<"unsupported">;
+      },
+      $strict
+    >,
+  ],
+  "status"
+>;
+```
+
+Typed outcome of a sender's answer to a child Ask.
+
+---
+
+### escalateOutput
+
+```ts
+const escalateOutput: ZodDiscriminatedUnion<
+  [
+    ZodObject<
+      {
+        status: ZodLiteral<"escalated">;
+        to: ZodLiteral<"person">;
+      },
+      $strict
+    >,
+    ZodObject<
+      {
+        status: ZodLiteral<"not_found">;
+      },
+      $strict
+    >,
+    ZodObject<
+      {
+        status: ZodLiteral<"closed">;
+        reason: ZodEnum<{
+          cancelled: "cancelled";
+          undeliverable: "undeliverable";
+          answered: "answered";
+          declined: "declined";
+          withdrawn: "withdrawn";
+          expired: "expired";
+        }>;
+      },
+      $strict
+    >,
+    ZodObject<
+      {
+        status: ZodLiteral<"refused">;
+        reason: ZodEnum<{
+          not_sender: "not_sender";
+          no_provenance: "no_provenance";
+        }>;
+      },
+      $strict
+    >,
+    ZodObject<
+      {
+        status: ZodLiteral<"unavailable">;
+        reason: ZodLiteral<"unsupported">;
+      },
+      $strict
+    >,
+  ],
+  "status"
+>;
+```
+
+Typed outcome of a sender's escalation of a child's item.
+
+---
+
 ### archiveRefusalReasons
 
 ```ts
@@ -279,10 +468,16 @@ function waitForAgentSettlement(
 ): Promise<
   Readonly<{
     acceptedSender: string | null;
+    delegator: string | null;
     terminal: SessionTerminal;
     content: string;
     usage: readonly Pick<AssistantMessage, "model" | "provider" | "usage">[];
     toolCalls: number;
+    waitingOnYou: readonly Readonly<{
+      itemId: string;
+      kind: string;
+      summary: string;
+    }>[];
   }>
 >;
 ```
@@ -301,10 +496,12 @@ Await one exact durable terminal without opening a transcript observation.
 
 #### Returns
 
-`Promise`\<`Readonly`\<\{ `acceptedSender`: `string` \| `null`; `terminal`:
-[`SessionTerminal`](client.md#sessionterminal); `content`: `string`; `usage`:
-readonly `Pick`\<`AssistantMessage`, `"model"` \| `"provider"` \| `"usage"`\>[];
-`toolCalls`: `number`; \}\>\>
+`Promise`\<`Readonly`\<\{ `acceptedSender`: `string` \| `null`; `delegator`:
+`string` \| `null`; `terminal`: [`SessionTerminal`](client.md#sessionterminal);
+`content`: `string`; `usage`: readonly `Pick`\<`AssistantMessage`, `"model"` \|
+`"provider"` \| `"usage"`\>[]; `toolCalls`: `number`; `waitingOnYou`: readonly
+`Readonly`\<\{ `itemId`: `string`; `kind`: `string`; `summary`: `string`;
+\}\>[]; \}\>\>
 
 ---