melchizedek-agents 1.0.3 → 1.2.0

package/dist/lib/runtime/native/delegate.js

@@ -13,12 +13,21 @@
  *
  * ONE CALL, AS ADK'S AgentTool RAN IT:
  *   1. The message: `{ role: 'user', parts: [{ text: args.request }] }`.
- *   2. The subagent's session: the one under the subagent's own name as the
- *      app name, with the caller's user id and session id. It is created on
- *      the first call, with the caller's state as it stands (the session's,
- *      then this call's writes; `temp:` keys dropped), and kept: a later
- *      call, in this turn or another, continues it. This is not a branch of
- *      the caller's session; ADK's AgentTool runs a Runner of its own.
+ *   2. The subagent's session: filed under the agent path (childAppName,
+ *      ADR 0111), with the caller's user id and session id: the caller's
+ *      app name, the caller's name and the subagent's at the top
+ *      (`<app>/<caller>/<subagent>`), the caller's app name and the
+ *      subagent's below it (`<app>/<caller>/<subagent>/<inner>`). It is
+ *      created on the first call, with the caller's state as it stands (the
+ *      session's, then this call's writes; `temp:` keys dropped), and kept:
+ *      a later call, in this turn or another, continues it. This is not a
+ *      branch of the caller's session; ADK's AgentTool runs a Runner of its
+ *      own. ADK filed it under the subagent's name alone, so two syndicates
+ *      with a same-named subagent on one conversation shared it. A session
+ *      stored under that old key is still read (legacyChild): when no
+ *      session exists under the path and the caller has called the
+ *      subagent before (or is resuming a pause found there), the old one is
+ *      continued, so a stored conversation resumes where it stopped.
  *   3. A turn already stopped answers an empty text, before or after the
  *      message is stored.
  *   4. The message is stored as a user event under a fresh invocation id
@@ -34,13 +43,34 @@
  *      schema it is parsed as JSON; text that does not parse fails the call
  *      with the parser's message, as on ADK.
  *
- * A PAUSE INSIDE A SUBAGENT (an ask_user call, an approval request) cannot
- * reach the caller, exactly as under ADK (ADR 0028): the child run ends
- * paused, its last event carries no text, the call answers '', and the gated
- * tool never runs. WS6-2a lifts this.
+ * A PAUSE INSIDE A SUBAGENT (an ask_user call, an approval request, or a
+ * pause inside its own delegated call) reaches the caller (ADR 0110, which
+ * lifts ADR 0028's refusal). The child run ends paused; the call resolves to
+ * a SubagentPause naming the ids it waits on, and the caller stores no
+ * response to it: the call stays open, and the caller's run ends paused too
+ * (agentLoop.ts). The turn finds the pause by walking down the open calls
+ * (interrupts.ts delegatedPauses) and reports it with the agent path. The
+ * answer comes back as the caller's next user message; the caller resumes
+ * the open call (resumeSubagent), which stores the same answer parts as
+ * the child's next message, under a fresh invocation id, and runs the
+ * child's loop on: it reads the answer from its own session as a top-level
+ * agent reads it (an approval runs or refuses its pinned call, a question's
+ * answer is the call's response), finishes, and its answer is the open
+ * call's response. A child that pauses again leaves the call open again.
+ * A skill script's approval is the same pause, and so is an OAuth consent
+ * request (ADR 0118): the child gets the caller's consent step, its flows
+ * bound to the caller's app (consentPinnedTo), and a grant's answer travels
+ * down the open call as a decision does.
  *
- * Calls to subagents in one step run one after another, in call order, as
- * ADK runs them; running them concurrently is WS6.
+ * CALLS TO SUBAGENTS IN ONE STEP RUN CONCURRENTLY (ADR 0116), under the
+ * caller's `max_concurrency` (the syndicate's root key, default
+ * DEFAULT_MAX_CONCURRENCY): agentLoop.ts runs each delegated call through
+ * the step's DelegationGate, which starts them in call order as slots free
+ * up, and runs two calls to the same subagent (one child session) one after
+ * the other. The step's responses are stored once every call has answered,
+ * in call order, whatever order the children finished in; a child that
+ * pauses leaves its call open while the others finish and are stored. ADK
+ * ran them one after another; `max_concurrency: 1` keeps that order.
  *
  * NESTED SYNDICATES: a `yaml_reference` subagent is the nested syndicate's
  * orchestrator, named as the entry, listing its own subagent tools. It runs
@@ -49,6 +79,13 @@
  *
  * A NESTED WORKFLOW (ADR 0098): a `yaml_reference` to a workflow syndicate
  * is a workflowSubagentTool, holding the whole graph as a WorkflowSubagent.
+ * A walk that ends paused (an ask_user node's question, an agent node's
+ * approval request) leaves the call open as a child loop's pause does
+ * (ADR 0111): the call resolves to a SubagentPause naming the walk's open
+ * interrupts, and resumeWorkflowSubagent walks the graph again on the
+ * answer, which the walk's own resume (lib/workflow/resume.ts) reads as it
+ * reads a top-level workflow's. An `ask_user` answer reaches the walk as
+ * ADK's explicit reply to its `adk_request_input` call.
  * A call runs as steps 1 to 6 say, with the walk in place of the loop: the
  * graph's walk (lib/workflow/turn.ts, runNativeWorkflow, which
  * lib/compileNative.ts hands over) stores the message itself and yields the
@@ -69,7 +106,9 @@ import { randomUUID } from 'node:crypto';
 import { resolveAdapter } from '../../models/registry.js';
 import { createTurnEvent } from '../events.js';
 import { TEMP_STATE_PREFIX } from '../sessions.js';
+import { REQUEST_INPUT_CALL } from './history.js';
 import { SelfCorrection } from './selfCorrection.js';
+import { currentTurnControl } from '../turnControl.js';
 // ── The subagent tool ────────────────────────────────────────────────────────
 /** Where a subagent tool keeps the agent it runs. A global symbol, so a second copy of this module still finds it. */
 export const SUBAGENT = Symbol.for('melchizedek.subagent');
@@ -128,13 +167,91 @@ export function subagentOf(tool) {
         return agent;
     return undefined;
 }
-const queues = new WeakMap();
-/** Runs `run` after every earlier call queued under `key`, whether it succeeded or not. */
-function inTurn(key, run) {
-    const before = queues.get(key) ?? Promise.resolve();
-    const mine = before.then(run, run);
-    queues.set(key, mine.then(() => undefined, () => undefined));
-    return mine;
+// ── Running one call ─────────────────────────────────────────────────────────
+/**
+ * A delegated call whose child run ended paused (ADR 0110): the ids the
+ * child waits on. The caller stores no response to the call and ends its
+ * own run paused.
+ */
+export class SubagentPause {
+    pending;
+    constructor(pending) {
+        this.pending = pending;
+    }
+}
+/** Delegated calls one step runs at once when the syndicate sets no `max_concurrency` (ADR 0116). */
+export const DEFAULT_MAX_CONCURRENCY = 4;
+/**
+ * The delegated calls of one step (ADR 0116): at most `limit` run at once,
+ * started in the order they entered (agentLoop.ts enters them in call
+ * order, synchronously, before any of them runs), and calls sharing a key
+ * (the subagent's name, so one child session) run one after another in
+ * that order. A slot is held from the call's start to its release, which
+ * comes as soon as the child's run ends: what the step does after (self-
+ * correction's bookkeeping, which waits on earlier calls) holds no slot. A
+ * call waiting on an earlier same-key call holds its slot meanwhile: the
+ * earlier call already holds one, so the wait always ends.
+ */
+export class DelegationGate {
+    limit;
+    active = 0;
+    waiting = [];
+    lanes = new Map();
+    constructor(limit = DEFAULT_MAX_CONCURRENCY) {
+        this.limit = Number.isInteger(limit) && limit > 0 ? limit : DEFAULT_MAX_CONCURRENCY;
+    }
+    /** Enters one call under `key`, behind every call entered before it. */
+    enter(key) {
+        let granted = false;
+        let released = false;
+        let freeLane;
+        const laneDone = new Promise((resolve) => (freeLane = resolve));
+        const slot = new Promise((resolve) => {
+            this.waiting.push(() => {
+                granted = true;
+                resolve();
+            });
+            this.pump();
+        });
+        const before = this.lanes.get(key);
+        this.lanes.set(key, laneDone);
+        const ready = Promise.all([slot, before]).then(() => undefined);
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            freeLane();
+            if (granted) {
+                this.active -= 1;
+                this.pump();
+            }
+            else {
+                // Never started (a step that failed before reaching the child): the slot it would have taken is not held, and it never will be.
+                void slot.then(() => {
+                    this.active -= 1;
+                    this.pump();
+                });
+            }
+        };
+        return { ready, release };
+    }
+    /** Runs `run` under a ticket for `key`: once ready, the ticket released when it settles. */
+    async run(key, run) {
+        const ticket = this.enter(key);
+        try {
+            await ticket.ready;
+            return await run();
+        }
+        finally {
+            ticket.release();
+        }
+    }
+    pump() {
+        while (this.active < this.limit && this.waiting.length > 0) {
+            this.active += 1;
+            this.waiting.shift()();
+        }
+    }
 }
 /** ADK's AgentTool answer: the last event's non-thought text, joined by a newline; parsed under an output schema. */
 function answerOf(agent, last) {
@@ -148,11 +265,107 @@ function answerOf(agent, last) {
         .join('\n');
     return agent.outputSchema ? JSON.parse(text) : text;
 }
-/** The child's session, as ADK's AgentTool gets or creates it: under the subagent's name, from the caller's state the first time. */
-async function childSession(name, context, scope) {
+/**
+ * The app name a delegated call's child session is filed under (ADR 0111):
+ * the agent path. Below a top-level agent, its app name, its name and the
+ * subagent's (`<app>/<caller>/<subagent>`); below a delegated subagent,
+ * whose own session is already filed under its path, that app name and the
+ * subagent's. Agent names are identifiers (lib/syndicateSchema.ts), so
+ * never hold a `/`.
+ */
+export function childAppName(parent, caller, name) {
+    return parent.delegated ? `${parent.appName}/${name}` : `${parent.appName}/${caller}/${name}`;
+}
+/**
+ * The app name a nested syndicate run as a dispatch route or a workflow
+ * node is filed under (ADR 0119, ADR 0120): the session that runs it, and
+ * the entry's name behind its kind (`<app>/route:<route>`,
+ * `<walk's app>/node:<node>`). Agent names are identifiers, so a `:` never
+ * occurs in one, and a delegated call's key (childAppName: names only)
+ * never equals a route's or a node's: a delegate orchestrator `X` calling
+ * `Y` files `<app>/X/Y`, a route `X` with a nested node `Y` files
+ * `<app>/route:X/node:Y`. F3 (ADR 0119) filed it under `<app>/<entry>`
+ * (entryAppNameF3) and ADR 0106 under the entry's name alone; entrySession
+ * and the pause walk still read both.
+ */
+export function entryAppName(parentAppName, name, kind) {
+    return `${parentAppName}/${kind}:${name}`;
+}
+/** Where ADR 0119 filed a route's or a node's session before the kind segment (ADR 0120): `<app>/<entry>`. */
+export function entryAppNameF3(parentAppName, name) {
+    return `${parentAppName}/${name}`;
+}
+/**
+ * The session a delegated call ran in before ADR 0111, filed under the
+ * subagent's name alone, when it is the one to continue (`continues`): the
+ * caller of a stored conversation called the subagent there before, or a
+ * pause was found waiting in it. Read only when no session exists under the
+ * agent path.
+ */
+export async function legacyChild(sessions, key, name, continues) {
+    if (!continues)
+        return undefined;
+    return sessions.get({ appName: name, userId: key.userId, sessionId: key.sessionId });
+}
+/**
+ * The session a route's or a node's entry ran in before the kind segment
+ * (ADR 0120), when it is the one to continue (`continues`): the one F3
+ * filed under `<app>/<entry>`, else the one ADR 0106 filed under the
+ * entry's name alone. Read only when none exists under entryAppName.
+ */
+export async function legacyEntry(sessions, key, name, continues) {
+    if (!continues)
+        return undefined;
+    return (await sessions.get({ appName: entryAppNameF3(key.appName, name), userId: key.userId, sessionId: key.sessionId })) ?? (await legacyChild(sessions, key, name, true));
+}
+/**
+ * The child session a nested syndicate run as a dispatch route or a
+ * workflow node runs on (ADR 0119, ADR 0120): the one filed under
+ * entryAppName, else, when the entry ran in `parent` before (an event it
+ * authored there) or a pause was found waiting below it (`resuming`), the
+ * one filed under an older key (legacyEntry), else a new one from `state`.
+ */
+export async function entrySession(sessions, parent, name, kind, state, resuming = false) {
+    const key = { appName: entryAppName(parent.appName, name, kind), userId: parent.userId, sessionId: parent.sessionId };
+    const own = await sessions.get(key);
+    if (own)
+        return own;
+    const legacy = await legacyEntry(sessions, parent, name, resuming || parent.events.some((e) => e.author === name));
+    return legacy ?? (await sessions.create({ ...key, state }));
+}
+/** Whether `caller` called `name` in `events` in a call other than `callId`: the subagent ran for it before. */
+function calledBefore(events, caller, name, callId) {
+    return events.some((e) => e.author === caller && (e.content?.parts ?? []).some((p) => p.functionCall?.name === name && p.functionCall.id !== callId));
+}
+/**
+ * The child's session, as ADK's AgentTool gets or creates it: filed under
+ * the agent path (childAppName), from the caller's state the first time. A
+ * session under the old key is continued when the caller called the
+ * subagent before, or when `resuming` a pause found there (legacyChild):
+ * a syndicate that never called it, another syndicate's caller included,
+ * starts its own.
+ */
+async function childSession(name, context, scope, resuming) {
     const { sessions, session: parent } = scope.ctx;
-    const key = { appName: name, userId: parent.userId, sessionId: parent.id };
-    return (await sessions.get(key)) ?? (await sessions.create({ ...key, state: { ...scope.stateBase, ...context.stateDelta } }));
+    const key = { appName: childAppName({ appName: parent.appName, delegated: scope.ctx.delegated === true }, scope.caller, name), userId: parent.userId, sessionId: parent.id };
+    const own = await sessions.get(key);
+    if (own)
+        return own;
+    const legacy = await legacyChild(sessions, key, name, resuming || calledBefore(parent.events, scope.caller, name, context.functionCallId));
+    return legacy ?? (await sessions.create({ ...key, state: { ...scope.stateBase, ...context.stateDelta } }));
+}
+/**
+ * The consent step as a child run reaches it (ADR 0118): a flow it begins
+ * is bound to `appName`, the caller's app, so the callback stores the grant
+ * under the app the run's pinned credentials read (the root's), never under
+ * the child session's agent path. A grandchild pins its caller's pinned
+ * step again; the first pin is applied last, so the root's app wins.
+ */
+export function consentPinnedTo(consent, appName) {
+    return {
+        has: (provider) => consent.has(provider),
+        begin: (binding) => consent.begin({ ...binding, appName }),
+    };
 }
 /** Step 5: an event's state writes, `temp:` keys aside, into the call's state delta. */
 function recordState(event, context) {
@@ -168,13 +381,22 @@ function recordState(event, context) {
  * throws, and for an output-schema answer that does not parse.
  */
 export function runSubagent(agent, args, context, scope) {
-    return inTurn(scope.queue, () => runChild(agent, args, context, scope));
+    return runChild(agent, { role: 'user', parts: [{ text: args.request }] }, context, scope, false);
 }
-async function runChild(agent, args, context, scope) {
+/**
+ * Resumes a delegated call the child left paused (ADR 0110): `answer` (the
+ * caller's user message parts that answer what waits below the call) is
+ * stored as the child's next message and the child's loop runs on, as
+ * runSubagent runs it. Resolves as runSubagent does, a SubagentPause again
+ * when the child pauses again.
+ */
+export function resumeSubagent(agent, answer, context, scope) {
+    return runChild(agent, { role: 'user', parts: answer }, context, scope, true);
+}
+async function runChild(agent, content, context, scope, resuming) {
     const { ctx, signal } = scope;
     const { sessions } = ctx;
-    const content = { role: 'user', parts: [{ text: args.request }] };
-    const session = await childSession(agent.name, context, scope);
+    const session = await childSession(agent.name, context, scope, resuming);
     if (signal?.aborted)
         return '';
     const invocationId = `e-${randomUUID()}`;
@@ -187,24 +409,36 @@ async function runChild(agent, args, context, scope) {
         invocationId,
         userContent: content,
         stream: false,
+        // Its own delegations are filed below its path (childAppName, ADR 0111).
+        delegated: true,
         // ADK's AgentTool builds its sub-runner without the reflect-and-retry
         // plugins, so a subagent's own errors are not retried (ADR 0075).
         selfCorrection: new SelfCorrection({ model_errors: 0, tool_errors: 0 }),
         ...(ctx.memory ? { memory: ctx.memory } : {}),
-        // The parent's grants, pinned to the root's app (ADR 0072). Not its consent step: a subagent's
-        // pause would end inside the call, as ADK's AgentTool swallows it (ADR 0085).
+        // The parent's grants, pinned to the root's app (ADR 0072), and its consent step: a call that
+        // needs a grant pauses the child, and the pause reaches the turn through the open call (ADR 0118).
         ...(ctx.credentials ? { credentials: ctx.credentials } : {}),
+        ...(ctx.consent ? { consent: consentPinnedTo(ctx.consent, ctx.session.appName) } : {}),
         ...(ctx.signal ? { signal: ctx.signal } : {}),
         ...(ctx.adapterFor ? { adapterFor: ctx.adapterFor } : {}),
         ...(ctx.log ? { log: ctx.log } : {}),
     });
     let last;
-    for await (const event of loop) {
+    for (;;) {
+        const next = await loop.next();
+        if (next.done) {
+            // A child that ended waiting on a person leaves the call open (ADR 0110).
+            if (next.value.reason === 'paused' && !signal?.aborted)
+                return new SubagentPause(next.value.pending ?? []);
+            break;
+        }
         // ADK's Runner stops yielding once the turn stopped: the answer is the last event it yielded.
-        if (signal?.aborted)
+        if (signal?.aborted) {
+            await loop.return(undefined);
             break;
-        recordState(event, context);
-        last = event;
+        }
+        recordState(next.value, context);
+        last = next.value;
     }
     return answerOf(agent, last);
 }
@@ -215,11 +449,26 @@ async function runChild(agent, args, context, scope) {
  * yielded event's text, '' for none. Throws what the walk throws.
  */
 export function runWorkflowSubagent(workflow, args, context, scope) {
-    return inTurn(scope.queue, () => walkChild(workflow, args, context, scope));
+    return walkChild(workflow, [{ text: args.request }], context, scope, false);
+}
+/** The engine's ask_user tool name (lib/runtime/questions.ts ASK_USER). */
+const ASK_USER_CALL = 'ask_user';
+/**
+ * Resumes a delegated call whose nested workflow ended paused (ADR 0111):
+ * the graph is walked again on `answer` (the caller's user message parts
+ * that answer the walk's open interrupt), which the walk's resume reads as
+ * it reads a top-level workflow's. An approval decision goes as it came; an
+ * `ask_user` answer goes as ADK's explicit reply to the `adk_request_input`
+ * call it answers, under that call's name. Resolves as runWorkflowSubagent
+ * does, a SubagentPause again when the walk pauses again.
+ */
+export function resumeWorkflowSubagent(workflow, answer, context, scope) {
+    const parts = answer.map((p) => (p.functionResponse?.name === ASK_USER_CALL ? { functionResponse: { ...p.functionResponse, name: REQUEST_INPUT_CALL } } : p));
+    return walkChild(workflow, parts, context, scope, true);
 }
-async function walkChild(workflow, args, context, scope) {
+async function walkChild(workflow, userParts, context, scope, resuming) {
     const { ctx, signal } = scope;
-    const session = await childSession(workflow.name, context, scope);
+    const session = await childSession(workflow.name, context, scope, resuming);
     if (signal?.aborted)
         return '';
     const walk = workflow.walk({
@@ -227,7 +476,7 @@ async function walkChild(workflow, args, context, scope) {
         appName: session.appName,
         userId: session.userId,
         sessionId: session.id,
-        userParts: [{ text: args.request }],
+        userParts,
         adapterFor: ctx.adapterFor ?? resolveAdapter,
         // As runChild: ADK's AgentTool runs its sub-runner without the reflect-and-retry plugins (ADR 0075).
         selfCorrection: new SelfCorrection({ model_errors: 0, tool_errors: 0 }),
@@ -237,9 +486,20 @@ async function walkChild(workflow, args, context, scope) {
         ...(ctx.credentials ? { credentials: ctx.credentials } : {}),
     });
     let last;
-    for await (const event of walk) {
-        if (signal?.aborted)
+    for (;;) {
+        const next = await walk.next();
+        if (next.done) {
+            // A walk that ended waiting on a person leaves the call open (ADR 0111).
+            const paused = next.value?.run?.interruptIds ?? [];
+            if (paused.length > 0 && !signal?.aborted)
+                return new SubagentPause(paused);
+            break;
+        }
+        if (signal?.aborted) {
+            await walk.return(undefined);
             break;
+        }
+        const event = next.value;
         if (event.partial)
             continue;
         recordState(event, context);
@@ -247,3 +507,94 @@ async function walkChild(workflow, args, context, scope) {
     }
     return answerOf({}, last);
 }
+/** The engine's approval request call (lib/runtime/approvals.ts APPROVAL_REQUEST). */
+const APPROVAL_REQUEST_CALL = 'adk_request_confirmation';
+/**
+ * The message a nested dispatch syndicate's turn reads (ADR 0120): the
+ * parts as they came, except an answer to a question, which comes down as
+ * an `ask_user` reply (a delegated call's resume) or an `adk_request_input`
+ * reply (a workflow node's), and goes in as the plain text it was, as a
+ * person's answer reaches a turn at the top.
+ */
+function dispatchParts(parts) {
+    return parts.map((p) => {
+        const r = p.functionResponse;
+        if (!r || (r.name !== ASK_USER_CALL && r.name !== REQUEST_INPUT_CALL))
+            return p;
+        const result = r.response?.result;
+        return { text: typeof result === 'string' ? result : JSON.stringify(result ?? '') };
+    });
+}
+/**
+ * The request call a paused nested dispatch syndicate's turn waits on, as a
+ * workflow node raises it again on its caller's walk: an approval request
+ * pinned to the gated call, or an input request carrying the question.
+ * Undefined for a consent request, which a walk cannot raise (ADR 0119).
+ */
+function requestCallOf(end) {
+    const id = end.interruptId;
+    if (!id)
+        return undefined;
+    const approval = end.approval;
+    if (approval) {
+        return {
+            id,
+            name: APPROVAL_REQUEST_CALL,
+            args: { originalFunctionCall: { name: approval.tool ?? '', args: approval.args ?? {}, ...(approval.callId ? { id: approval.callId } : {}) }, toolConfirmation: { confirmed: false } },
+        };
+    }
+    const input = end.input;
+    if (input) {
+        return {
+            id,
+            name: REQUEST_INPUT_CALL,
+            args: {
+                interruptId: id,
+                message: input.message ?? '',
+                ...(input.payload !== undefined ? { payload: input.payload } : {}),
+                ...(input.schema !== undefined ? { response_schema: input.schema } : {}),
+            },
+        };
+    }
+    return undefined;
+}
+/**
+ * Runs a nested dispatch syndicate as a walk (ADR 0120): its own turn, on
+ * the conversation its caller opened (`run`), through the turn runner the
+ * current turn carries (TurnControl.nestedDispatch), under the turn's
+ * controls. Completed, it yields one event, never stored, that carries the
+ * route's final text and the conversation's state writes: the caller reads
+ * the answer and records the writes from it, as from a walk's last event.
+ * Paused, it ends with the request's id, and the request call itself for a
+ * workflow node to raise again. Failed, it throws the turn's error. A
+ * delegated call, a dispatch route and a workflow node all run it.
+ */
+export async function* nestedDispatchWalk(entry, run) {
+    const runner = currentTurnControl()?.nestedDispatch;
+    if (!runner)
+        throw new Error(`'${entry.name}' is a nested dispatch syndicate, which runs only inside a syndicate turn (runSyndicateTurn).`);
+    const end = await runner({
+        config: entry.config,
+        compile: entry.compile,
+        name: entry.name,
+        sessions: run.sessions,
+        appName: run.appName,
+        userId: run.userId,
+        sessionId: run.sessionId,
+        parts: dispatchParts(run.userParts),
+    });
+    if (end.status === 'canceled' || run.signal?.aborted || currentTurnControl()?.stopReason)
+        return { stopped: true };
+    if (end.status === 'failed')
+        throw new Error(end.error?.message ?? `${entry.name} failed.`);
+    if (end.status === 'input-required' && end.interruptId) {
+        const request = requestCallOf(end);
+        return { run: { interruptIds: [end.interruptId] }, ...(request ? { requests: [request] } : {}) };
+    }
+    yield createTurnEvent({
+        author: entry.name,
+        content: { role: 'model', parts: [{ text: end.text }] },
+        ...(Object.keys(end.stateDelta).length ? { actions: { stateDelta: end.stateDelta } } : {}),
+    });
+    return { run: { interruptIds: [] } };
+}