melchizedek-agents 1.0.3 → 1.2.0

package/dist/lib/runtime/native/interrupts.d.ts

@@ -80,12 +80,72 @@
  *      builds its request. A later step finds the agent's own events last,
  *      so the call runs once.
  *
+ * PAUSES INSIDE DELEGATED SUBAGENTS (WS6-2a, ADR 0110). A subagent runs in
+ * its own child session (delegate.ts); an approval request or question it
+ * leaves open ends its run paused, and its caller leaves the delegated
+ * call open (no response stored) and ends paused too, up to the turn.
+ * delegatedPauses finds such a pause from any session by walking down:
+ * each call its agent left open (openCalls) leads to the child session
+ * under the call's name, whose own open request or question is the pause,
+ * or whose own open call leads one level further. The answer travels back
+ * down the same way: before each step, the loop resumes the open call
+ * whose pause the latest user message answers (agentLoop.ts), and the
+ * child reads the same answer from its own session, as it would at the top.
+ *
+ * NESTED SYNDICATES (WS6-2b, ADR 0111). The child session of a call is the
+ * one runSubagent files it under: the agent path (delegate.ts childAppName),
+ * else, for a conversation stored before ADR 0111, the subagent's name
+ * alone (legacyChild). A nested delegate syndicate is its orchestrator
+ * there, so the walk goes on through its open calls. A nested workflow
+ * syndicate holds a paused walk there instead: its own pause record (the
+ * workflow's event naming every interrupt it left open, authored by the
+ * workflow under the call's name) makes an approval request an agent node
+ * raised, or an ask_user node's question, the pause, with the node that
+ * asked at the end of the path. The walk stops there: a pause inside a
+ * workflow node's own delegation does not run (lib/workflow/agentNode.ts).
+ *
+ * NESTED WORKFLOWS AS A ROUTE OR A NODE (ADR 0119). A workflow node that is
+ * a nested workflow raises its walk's open requests again on its caller's
+ * walk, on one event of its own (lib/workflow/turn.ts), so the caller's
+ * walk pauses on the same ids; deepestPause follows such a request down,
+ * by id, through each child session filed under entryAppName (its kind in
+ * the key: `route:`, `node:`, ADR 0120; else an older key, legacyEntry) to
+ * the node that asked. A dispatch route that is one leaves its pause
+ * record as the conversation's last event (routePause). A delegated nested
+ * workflow's node that is one is followed the same way.
+ *
+ * NESTED DISPATCH SYNDICATES (ADR 0120). One runs as a turn of its own on
+ * its own conversation (the child session of a delegated call, a route or
+ * a node), its routes answering there as a turn's routes answer in the
+ * turn's conversation. conversationPause finds what it waits on as the
+ * turn finds it at the top: a route's pause record, a route's open
+ * request, question or consent request, else a pause inside a call a route
+ * left open (filed `<conversation>/<route>/<subagent>`). pauseBelow falls
+ * to it when the subagent's own checks find nothing; nestedWorkflowPause
+ * when the child session is not a walk. The answer goes down the open
+ * call, the route's pause record or the node's raised request, and the
+ * nested turn reads it as a message at the top.
+ *
+ * CONSENT AND SKILL SCRIPTS INSIDE DELEGATED SUBAGENTS (ADR 0118). A skill
+ * script run asks for approval through the same `adk_request_confirmation`
+ * call a gated tool stores, so the walk and the resume above carry it with
+ * nothing of its own. An OAuth consent request (`adk_request_credential`)
+ * the subagent left open in its child session is a pause too: the walk
+ * reports it with the path (pendingConsent), the turn runner stores the
+ * grant's answer once the callback has stored the grant, and the open
+ * call carries that answer down as it carries an approval decision; the
+ * child's own grantedCalls binds it and runs its paused call again.
+ *
  * ADK stays out of this file: an ADK tool an agent still lists is asked
  * whether it gates through its own checkRequireConfirmation, by shape.
  */
 import type { ToolConfirmation } from '../../tools/tool.ts';
-import type { TurnFunctionCall } from '../events.ts';
-import type { Session } from '../sessions.ts';
+import type { PendingInput } from '../../workflowConfig.ts';
+import type { PendingApproval } from '../approvals.ts';
+import type { PendingConsent } from '../credentials.ts';
+import type { TurnEvent, TurnFunctionCall, TurnPart } from '../events.ts';
+import type { Session, SessionService } from '../sessions.ts';
+import type { EntryKind } from './delegate.ts';
 import type { NativeAgent } from './request.ts';
 /** Why a confirmation does not bind to the call it pins: ADK's IntentMismatchError reasons. */
 export type IntentMismatchReason = 'untrusted_request' | 'malformed_request' | 'unknown_original_call' | 'unregistered_tool' | 'tool_name_mismatch' | 'arguments_mismatch' | 'confirmation_not_required';
@@ -106,6 +166,8 @@ interface Scope {
     session: Session;
     invocationId: string;
     branch?: string;
+    /** The session is a delegated subagent's, filed under its agent path (delegate.ts childAppName). */
+    delegated?: boolean;
 }
 /**
  * The pinned calls the latest user message approves or refuses, bound to
@@ -126,4 +188,124 @@ export interface GrantedCalls {
  * AuthPreprocessor, the exchange left to the callback route).
  */
 export declare function grantedCalls(agent: NativeAgent, scope: Scope): Promise<GrantedCalls | undefined>;
+/**
+ * An approval request or a question waiting inside a delegated call: the
+ * open call that leads to it from the session it was found from, and on
+ * down, to the agent that asked.
+ */
+export interface DelegatedPause {
+    /** The agents from the one that made the open call down to the one that asked: `[caller, subagent, …, asker]`. */
+    path: string[];
+    /** The open subagent calls on that path, by id, the outermost first. */
+    callIds: string[];
+    /** The approval request, when the asker waits on one; its `path` is set. */
+    approval?: PendingApproval;
+    /** The question, when the asker waits on one; its `path` is set. */
+    question?: PendingInput;
+    /** The OAuth consent request, when the asker waits for a grant (ADR 0118); its `path` is set. */
+    consent?: PendingConsent;
+}
+/** Where a session's delegated calls opened their child sessions: the store, and the caller's user and session ids. */
+export interface DelegationKey {
+    sessions: Pick<SessionService, 'get'>;
+    userId: string;
+    sessionId: string;
+    /**
+     * The app name of the session whose events are walked: its children are
+     * filed below it (delegate.ts childAppName, ADR 0111). Absent, only the
+     * children a conversation stored before ADR 0111 holds are found.
+     */
+    appName?: string;
+    /** The session walked is a delegated subagent's, already filed under its agent path. */
+    delegated?: boolean;
+}
+/**
+ * The calls an agent made that are still open: no later event answers it,
+ * and the person has not written since. Only an agent's calls count (a
+ * call in a user-authored event is never one), and the engine's own
+ * framework calls are left out. `author`, when given, keeps one agent's
+ * calls. Latest event first, calls in call order.
+ */
+export declare function openCalls(events: readonly TurnEvent[], author?: string): Array<{
+    author: string;
+    call: TurnFunctionCall;
+}>;
+/** A pause a nested workflow's walk holds: the path from the workflow down to the node that asked, and what it asks. */
+export interface NestedWorkflowPause {
+    /** From the workflow (the route, the node, the subagent) down to the node that asked: `[workflow, …, node]`. */
+    path: string[];
+    /** The approval request, its `agent` the node that asked and its `path` set. */
+    approval?: PendingApproval;
+    /** The question, its `node` the node that asked and its `path` set. */
+    question?: PendingInput;
+    /** The OAuth consent request, inside a nested dispatch syndicate's route (ADR 0120); its `path` set. */
+    consent?: PendingConsent;
+}
+/**
+ * The pause a nested workflow run as a dispatch route or a workflow node
+ * holds (ADR 0119): `name`'s child session below the session filed under
+ * `key.appName` (delegate.ts entryAppName), else the one filed under its
+ * name alone (legacyChild), and the paused walk there, followed down to the
+ * node that asked. With `id`, only that interrupt counts: a request a node
+ * raised again on its caller's walk names the one its own walk waits on.
+ */
+export declare function nestedWorkflowPause(key: DelegationKey & {
+    appName: string;
+}, name: string, kind: EntryKind, id?: string, depth?: number): Promise<NestedWorkflowPause | undefined>;
+/**
+ * A dispatch route that is a nested workflow, paused (ADR 0119): the
+ * conversation's last event is the route's pause record (authored by the
+ * route at its own path, no content, the walk's open interrupts in
+ * `longRunningToolIds`; lib/runtime/syndicateTurn.ts stores it), and the
+ * route's child session holds the paused walk under one of those ids.
+ * Anything stored after the record closes it. `routes`, when given, are the
+ * names a record may carry.
+ */
+export declare function routePause(key: DelegationKey & {
+    appName: string;
+}, events: readonly TurnEvent[], routes?: ReadonlySet<string>, depth?: number): Promise<(NestedWorkflowPause & {
+    route: string;
+}) | undefined>;
+/**
+ * An approval request or question found in a workflow's own session, raised
+ * by a node that is a nested workflow (lib/workflow/turn.ts raises its
+ * walk's requests again on the node's event, ADR 0119): the one its walk
+ * waits on, with the path from the node down to the one that asked. Any
+ * other request comes back as it is.
+ */
+export declare function deepestPause<T extends PendingApproval | PendingInput>(key: DelegationKey & {
+    appName: string;
+}, pending: T): Promise<T>;
+/**
+ * Every pause waiting inside a delegated call still open in `events` (one
+ * session's events), latest call first: each open call whose child session
+ * holds an open approval request or question, at any depth. `author`, when
+ * given, keeps one agent's calls. A call the person has written past is no
+ * longer open, and neither is anything waiting below it.
+ */
+export declare function delegatedPauses(key: DelegationKey, events: readonly TurnEvent[], author?: string, depth?: number, seen?: ReadonlySet<string>): Promise<DelegatedPause[]>;
+/** The interrupt a delegated pause waits on: the approval request's id, the question's, or the consent request's. */
+export declare function interruptIdOf(pause: DelegatedPause): string | undefined;
+/** The open delegated calls the latest user message resumes, and the ones still waiting after it. */
+export interface ResumedDelegations {
+    /** The open calls whose pause the message answers, as the agent made them. */
+    calls: TurnFunctionCall[];
+    /** By call id: the message's parts that answer what waits below it, to be the child's next message. */
+    answers: Map<string, TurnPart[]>;
+    /** The open calls whose pause the message does not answer, by id. */
+    waiting: string[];
+    /** The agent's tools by name, as the loop runs calls against them. */
+    tools: Map<string, unknown>;
+}
+/**
+ * The delegated calls `agent` left open that the latest user message
+ * answers (ADR 0110): the message's approval decisions and question
+ * answers (function responses to `adk_request_confirmation` or `ask_user`)
+ * and grants (to `adk_request_credential`, ADR 0118) matched, by interrupt
+ * id, to the pause below each open call. Undefined when the message answers
+ * none. The child binds the answer itself: an approval is checked against
+ * its pinned call there (approvedCalls), a grant against its request
+ * (grantedCalls), as at the top.
+ */
+export declare function resumedDelegations(agent: NativeAgent, scope: Scope, sessions: Pick<SessionService, 'get'>): Promise<ResumedDelegations | undefined>;
 export {};

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

@@ -80,14 +80,75 @@
  *      builds its request. A later step finds the agent's own events last,
  *      so the call runs once.
  *
+ * PAUSES INSIDE DELEGATED SUBAGENTS (WS6-2a, ADR 0110). A subagent runs in
+ * its own child session (delegate.ts); an approval request or question it
+ * leaves open ends its run paused, and its caller leaves the delegated
+ * call open (no response stored) and ends paused too, up to the turn.
+ * delegatedPauses finds such a pause from any session by walking down:
+ * each call its agent left open (openCalls) leads to the child session
+ * under the call's name, whose own open request or question is the pause,
+ * or whose own open call leads one level further. The answer travels back
+ * down the same way: before each step, the loop resumes the open call
+ * whose pause the latest user message answers (agentLoop.ts), and the
+ * child reads the same answer from its own session, as it would at the top.
+ *
+ * NESTED SYNDICATES (WS6-2b, ADR 0111). The child session of a call is the
+ * one runSubagent files it under: the agent path (delegate.ts childAppName),
+ * else, for a conversation stored before ADR 0111, the subagent's name
+ * alone (legacyChild). A nested delegate syndicate is its orchestrator
+ * there, so the walk goes on through its open calls. A nested workflow
+ * syndicate holds a paused walk there instead: its own pause record (the
+ * workflow's event naming every interrupt it left open, authored by the
+ * workflow under the call's name) makes an approval request an agent node
+ * raised, or an ask_user node's question, the pause, with the node that
+ * asked at the end of the path. The walk stops there: a pause inside a
+ * workflow node's own delegation does not run (lib/workflow/agentNode.ts).
+ *
+ * NESTED WORKFLOWS AS A ROUTE OR A NODE (ADR 0119). A workflow node that is
+ * a nested workflow raises its walk's open requests again on its caller's
+ * walk, on one event of its own (lib/workflow/turn.ts), so the caller's
+ * walk pauses on the same ids; deepestPause follows such a request down,
+ * by id, through each child session filed under entryAppName (its kind in
+ * the key: `route:`, `node:`, ADR 0120; else an older key, legacyEntry) to
+ * the node that asked. A dispatch route that is one leaves its pause
+ * record as the conversation's last event (routePause). A delegated nested
+ * workflow's node that is one is followed the same way.
+ *
+ * NESTED DISPATCH SYNDICATES (ADR 0120). One runs as a turn of its own on
+ * its own conversation (the child session of a delegated call, a route or
+ * a node), its routes answering there as a turn's routes answer in the
+ * turn's conversation. conversationPause finds what it waits on as the
+ * turn finds it at the top: a route's pause record, a route's open
+ * request, question or consent request, else a pause inside a call a route
+ * left open (filed `<conversation>/<route>/<subagent>`). pauseBelow falls
+ * to it when the subagent's own checks find nothing; nestedWorkflowPause
+ * when the child session is not a walk. The answer goes down the open
+ * call, the route's pause record or the node's raised request, and the
+ * nested turn reads it as a message at the top.
+ *
+ * CONSENT AND SKILL SCRIPTS INSIDE DELEGATED SUBAGENTS (ADR 0118). A skill
+ * script run asks for approval through the same `adk_request_confirmation`
+ * call a gated tool stores, so the walk and the resume above carry it with
+ * nothing of its own. An OAuth consent request (`adk_request_credential`)
+ * the subagent left open in its child session is a pause too: the walk
+ * reports it with the path (pendingConsent), the turn runner stores the
+ * grant's answer once the callback has stored the grant, and the open
+ * call carries that answer down as it carries an approval decision; the
+ * child's own grantedCalls binds it and runs its paused call again.
+ *
  * ADK stays out of this file: an ADK tool an agent still lists is asked
  * whether it gates through its own checkRequireConfirmation, by shape.
  */
 import { isDeepStrictEqual } from 'node:util';
 import { nativeToolOf } from '../../models/schemaNormalize.js';
 import { instructionToolOf, isTool, toolOf } from '../../tools/tool.js';
+import { inputRequestFrom } from '../../workflowConfig.js';
+import { approvalRequestOf, pendingApproval } from '../approvals.js';
+import { pendingConsent } from '../credentials.js';
 import { getFunctionCalls, getFunctionResponses } from '../events.js';
-import { REQUEST_CONFIRMATION_CALL, REQUEST_CREDENTIAL_CALL, isSegmentPrefix } from './history.js';
+import { ASK_USER, pendingQuestion } from '../questions.js';
+import { childAppName, entryAppName, legacyChild, legacyEntry } from './delegate.js';
+import { REQUEST_CONFIRMATION_CALL, REQUEST_CREDENTIAL_CALL, REQUEST_INPUT_CALL, isSegmentPrefix } from './history.js';
 import { isToolset } from './request.js';
 /** A confirmation that does not bind to its pinned call: ADK's IntentMismatchError, by name and text. */
 export class IntentMismatchError extends Error {
@@ -308,3 +369,332 @@ export async function grantedCalls(agent, scope) {
     }
     return undefined;
 }
+/** The deepest a chain of delegated pauses is followed: nested syndicates stop at 16 levels (lib/compile.ts). */
+const MAX_DELEGATION_DEPTH = 16;
+/** The engine's own long-running calls: never a delegation. */
+const FRAMEWORK_CALLS = new Set([REQUEST_CONFIRMATION_CALL, REQUEST_CREDENTIAL_CALL, ASK_USER]);
+const hasUserText = (e) => e.author === 'user' && (e.content?.parts ?? []).some((p) => typeof p.text === 'string' && p.text.trim() !== '' && !p.thought);
+/**
+ * The calls an agent made that are still open: no later event answers it,
+ * and the person has not written since. Only an agent's calls count (a
+ * call in a user-authored event is never one), and the engine's own
+ * framework calls are left out. `author`, when given, keeps one agent's
+ * calls. Latest event first, calls in call order.
+ */
+export function openCalls(events, author) {
+    const answered = new Set();
+    const open = [];
+    for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        if (hasUserText(event))
+            break;
+        for (const r of getFunctionResponses(event))
+            if (r.id)
+                answered.add(r.id);
+        if (!event.author || event.author === 'user' || (author !== undefined && event.author !== author))
+            continue;
+        for (const call of getFunctionCalls(event)) {
+            if (!call.id || !call.name || FRAMEWORK_CALLS.has(call.name) || answered.has(call.id))
+                continue;
+            open.push({ author: event.author, call });
+        }
+    }
+    return open;
+}
+/**
+ * What waits inside the delegated call `call` that `caller` left open: the
+ * child session under the call's name (where runSubagent runs it), and its
+ * own open approval request or question, else a pause inside a call it left
+ * open, one level down. Only the subagent's own requests count: a request
+ * or question authored by anyone else is none.
+ */
+async function pauseBelow(key, caller, call, depth, seen) {
+    const name = call.name;
+    const id = call.id;
+    if (depth >= MAX_DELEGATION_DEPTH || seen.has(name))
+        return undefined;
+    // Where runSubagent filed the call (ADR 0111), else where it filed it before.
+    const own = key.appName === undefined ? undefined : await key.sessions.get({ appName: childAppName({ appName: key.appName, delegated: key.delegated === true }, caller, name), userId: key.userId, sessionId: key.sessionId });
+    const child = own ?? (await legacyChild(key.sessions, key, name, true));
+    if (!child)
+        return undefined;
+    const here = [caller, name];
+    const walked = await workflowPauseIn(key, child, name);
+    if (walked) {
+        const path = [caller, ...walked.path];
+        return {
+            path,
+            callIds: [id],
+            ...(walked.approval ? { approval: { ...walked.approval, path } } : {}),
+            ...(walked.question ? { question: { ...walked.question, path } } : {}),
+        };
+    }
+    const approval = pendingApproval(child.events);
+    if (approval && approval.agent === name)
+        return { path: here, callIds: [id], approval: { ...approval, path: here } };
+    const question = pendingQuestion(child.events);
+    if (question && question.node === name)
+        return { path: here, callIds: [id], question: { ...question, path: here } };
+    // Only the subagent's own request counts (pendingConsent already skips a user-authored one).
+    const consent = pendingConsent(child.events);
+    if (consent && consent.agent === name)
+        return { path: here, callIds: [id], consent: { ...consent, path: here } };
+    const [first] = await delegatedPauses({ ...key, appName: child.appName, delegated: true }, child.events, name, depth + 1, new Set([...seen, name]));
+    if (first) {
+        const path = [caller, ...first.path];
+        return {
+            path,
+            callIds: [id, ...first.callIds],
+            ...(first.approval ? { approval: { ...first.approval, path } } : {}),
+            ...(first.question ? { question: { ...first.question, path } } : {}),
+            ...(first.consent ? { consent: { ...first.consent, path } } : {}),
+        };
+    }
+    // A nested dispatch syndicate delegated to (ADR 0120): its routes answer in the child session, as routes answer in a turn's.
+    const routed = await conversationPause(key, child, name, undefined, depth + 1, new Set([...seen, name]));
+    if (!routed)
+        return undefined;
+    const path = [caller, ...routed.path];
+    return {
+        path,
+        callIds: [id],
+        ...(routed.approval ? { approval: { ...routed.approval, path } } : {}),
+        ...(routed.question ? { question: { ...routed.question, path } } : {}),
+        ...(routed.consent ? { consent: { ...routed.consent, path } } : {}),
+    };
+}
+/** The id a pause found below waits on. */
+const idOf = (pause) => pause.approval?.id ?? pause.question?.id ?? pause.consent?.id;
+/**
+ * What a nested dispatch syndicate's conversation (`child`, filed for the
+ * entry `name`) waits on (ADR 0120): what its own turn would report at the
+ * top. Its routes answer there as a turn's routes answer in the turn's
+ * conversation, so it is found as the turn finds it: a route's pause record
+ * (a nested workflow or a nested dispatch syndicate run as a route, followed
+ * down), a route's open approval request, question or consent request, else
+ * a pause inside a call a route left open, its child filed under the
+ * route's name (`<child>/<route>/<subagent>`, as a turn's route files its
+ * own). The path runs from `name` down to the agent that asked. With `id`,
+ * only that request counts. Calls `name` made itself are not a route's.
+ */
+async function conversationPause(key, child, name, id, depth, seen = new Set()) {
+    if (depth >= MAX_DELEGATION_DEPTH)
+        return undefined;
+    const at = { ...key, appName: child.appName, delegated: false };
+    const wanted = (found) => !!found && (id === undefined || found === id);
+    const down = (path) => [name, ...path];
+    const routed = await routePause(at, child.events, undefined, depth + 1);
+    if (routed && wanted(idOf(routed))) {
+        const path = down(routed.path);
+        return {
+            path,
+            ...(routed.approval ? { approval: { ...routed.approval, path } } : {}),
+            ...(routed.question ? { question: { ...routed.question, path } } : {}),
+            ...(routed.consent ? { consent: { ...routed.consent, path } } : {}),
+        };
+    }
+    const approval = pendingApproval(child.events);
+    if (approval && approval.agent && approval.agent !== 'user' && approval.agent !== name && wanted(approval.id)) {
+        const path = down([approval.agent]);
+        return { path, approval: { ...approval, path } };
+    }
+    const question = pendingQuestion(child.events);
+    if (question && question.node && question.node !== 'user' && question.node !== name && wanted(question.id)) {
+        const path = down([question.node]);
+        return { path, question: { ...question, path } };
+    }
+    const consent = pendingConsent(child.events);
+    if (consent && consent.agent && consent.agent !== name && wanted(consent.id)) {
+        const path = down([consent.agent]);
+        return { path, consent: { ...consent, path } };
+    }
+    const below = await delegatedPauses(at, child.events, undefined, depth + 1, seen);
+    const first = below.find((p) => p.path[0] !== name && wanted(interruptIdOf(p)));
+    if (!first)
+        return undefined;
+    const path = down(first.path);
+    return {
+        path,
+        ...(first.approval ? { approval: { ...first.approval, path } } : {}),
+        ...(first.question ? { question: { ...first.question, path } } : {}),
+        ...(first.consent ? { consent: { ...first.consent, path } } : {}),
+    };
+}
+/** A walk's session: its node events carry a dotted node path (`<workflow>.<node>`). */
+const isWalk = (session) => session.events.some((e) => typeof e.nodeInfo?.path === 'string' && e.nodeInfo.path.includes('.'));
+/**
+ * The pause a nested workflow's walk holds in its child session (ADR 0111):
+ * the workflow's own pause record, the last event, authored by the
+ * workflow (`name`) at its own path with no content, names the open
+ * interrupts; the approval request or ask_user question among them is the
+ * pause, and the node that raised it the asker. With `id`, only that
+ * interrupt counts. Undefined when the session holds no paused walk of
+ * `name`'s. A node that is itself a nested workflow raised its walk's
+ * requests again on its own event (lib/workflow/turn.ts, ADR 0119), so it
+ * is the asker here, and workflowPauseIn goes on down.
+ */
+function workflowPause(events, name, id) {
+    const record = events[events.length - 1];
+    if (!record || record.author !== name || (record.content?.parts ?? []).length > 0 || record.nodeInfo?.path !== name)
+        return undefined;
+    const open = new Set((record.longRunningToolIds ?? []).filter((x) => id === undefined || x === id));
+    if (open.size === 0)
+        return undefined;
+    // The latest open request the record names, an approval first: the walk stores node inputs as user turns, so a later one may follow it.
+    for (const kind of [REQUEST_CONFIRMATION_CALL, REQUEST_INPUT_CALL]) {
+        for (let i = events.length - 2; i >= 0; i--) {
+            const event = events[i];
+            if (!event.author || event.author === 'user')
+                continue;
+            for (const call of getFunctionCalls(event)) {
+                if (call.name !== kind || !call.id || !open.has(call.id))
+                    continue;
+                if (kind === REQUEST_CONFIRMATION_CALL)
+                    return { asker: event.author, approval: approvalRequestOf(event, call) };
+                const question = inputRequestFrom(event.author, call);
+                if (question && question.id === call.id)
+                    return { asker: event.author, question };
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * The pause the walk of `name` holds in `child` (its child session), with
+ * `id` the only interrupt that counts when given: the node that asked, or,
+ * when that node is itself a nested workflow (ADR 0119), the pause its own
+ * child session holds under the same id, one level further down.
+ */
+async function workflowPauseIn(key, child, name, id, depth = 0) {
+    const walked = workflowPause(child.events, name, id);
+    if (!walked)
+        return undefined;
+    const found = (walked.approval?.id ?? walked.question?.id);
+    const deeper = await nestedWorkflowPause({ ...key, appName: child.appName }, walked.asker, 'node', found, depth + 1);
+    const path = deeper ? [name, ...deeper.path] : [name, walked.asker];
+    const approval = deeper ? deeper.approval : walked.approval;
+    const question = deeper ? deeper.question : walked.question;
+    return { path, ...(approval ? { approval: { ...approval, path } } : {}), ...(question ? { question: { ...question, path } } : {}) };
+}
+/**
+ * The pause a nested workflow run as a dispatch route or a workflow node
+ * holds (ADR 0119): `name`'s child session below the session filed under
+ * `key.appName` (delegate.ts entryAppName), else the one filed under its
+ * name alone (legacyChild), and the paused walk there, followed down to the
+ * node that asked. With `id`, only that interrupt counts: a request a node
+ * raised again on its caller's walk names the one its own walk waits on.
+ */
+export async function nestedWorkflowPause(key, name, kind, id, depth = 0) {
+    if (depth >= MAX_DELEGATION_DEPTH)
+        return undefined;
+    const own = await key.sessions.get({ appName: entryAppName(key.appName, name, kind), userId: key.userId, sessionId: key.sessionId });
+    const child = own ?? (await legacyEntry(key.sessions, key, name, true));
+    if (!child)
+        return undefined;
+    const walked = await workflowPauseIn(key, child, name, id, depth);
+    if (walked || isWalk(child))
+        return walked;
+    // A nested dispatch syndicate run as the route or the node (ADR 0120): its own conversation, as its turn reads it.
+    return conversationPause(key, child, name, id, depth + 1);
+}
+/**
+ * A dispatch route that is a nested workflow, paused (ADR 0119): the
+ * conversation's last event is the route's pause record (authored by the
+ * route at its own path, no content, the walk's open interrupts in
+ * `longRunningToolIds`; lib/runtime/syndicateTurn.ts stores it), and the
+ * route's child session holds the paused walk under one of those ids.
+ * Anything stored after the record closes it. `routes`, when given, are the
+ * names a record may carry.
+ */
+export async function routePause(key, events, routes, depth = 0) {
+    const record = events[events.length - 1];
+    const route = record?.author;
+    if (!record || !route || route === 'user' || (record.content?.parts ?? []).length > 0 || record.nodeInfo?.path !== route)
+        return undefined;
+    if (routes && !routes.has(route))
+        return undefined;
+    for (const id of record.longRunningToolIds ?? []) {
+        const pause = await nestedWorkflowPause(key, route, 'route', id, depth);
+        if (pause)
+            return { ...pause, route };
+    }
+    return undefined;
+}
+/**
+ * An approval request or question found in a workflow's own session, raised
+ * by a node that is a nested workflow (lib/workflow/turn.ts raises its
+ * walk's requests again on the node's event, ADR 0119): the one its walk
+ * waits on, with the path from the node down to the one that asked. Any
+ * other request comes back as it is.
+ */
+export async function deepestPause(key, pending) {
+    const raisedBy = 'agent' in pending ? pending.agent : pending.node;
+    if (!raisedBy || pending.path)
+        return pending;
+    const below = await nestedWorkflowPause(key, raisedBy, 'node', pending.id);
+    const found = 'agent' in pending ? below?.approval : below?.question;
+    return found ?? pending;
+}
+/**
+ * Every pause waiting inside a delegated call still open in `events` (one
+ * session's events), latest call first: each open call whose child session
+ * holds an open approval request or question, at any depth. `author`, when
+ * given, keeps one agent's calls. A call the person has written past is no
+ * longer open, and neither is anything waiting below it.
+ */
+export async function delegatedPauses(key, events, author, depth = 0, seen = new Set()) {
+    const out = [];
+    for (const { author: caller, call } of openCalls(events, author)) {
+        const pause = await pauseBelow(key, caller, call, depth, seen);
+        if (pause)
+            out.push(pause);
+    }
+    return out;
+}
+/** The interrupt a delegated pause waits on: the approval request's id, the question's, or the consent request's. */
+export function interruptIdOf(pause) {
+    return pause.approval?.id ?? pause.question?.id ?? pause.consent?.id;
+}
+/**
+ * The delegated calls `agent` left open that the latest user message
+ * answers (ADR 0110): the message's approval decisions and question
+ * answers (function responses to `adk_request_confirmation` or `ask_user`)
+ * and grants (to `adk_request_credential`, ADR 0118) matched, by interrupt
+ * id, to the pause below each open call. Undefined when the message answers
+ * none. The child binds the answer itself: an approval is checked against
+ * its pinned call there (approvedCalls), a grant against its request
+ * (grantedCalls), as at the top.
+ */
+export async function resumedDelegations(agent, scope, sessions) {
+    const events = scope.session.events;
+    let latest;
+    for (let i = events.length - 1; i >= 0 && !latest; i--)
+        if (events[i]?.author === 'user')
+            latest = events[i];
+    if (!latest)
+        return undefined;
+    const answerParts = (latest.content?.parts ?? []).filter((p) => {
+        const r = p.functionResponse;
+        return !!r?.id && (r.name === REQUEST_CONFIRMATION_CALL || r.name === ASK_USER || r.name === REQUEST_CREDENTIAL_CALL);
+    });
+    if (answerParts.length === 0)
+        return undefined;
+    const pauses = await delegatedPauses({ sessions, userId: scope.session.userId, sessionId: scope.session.id, appName: scope.session.appName, delegated: scope.delegated === true }, events, agent.name);
+    if (pauses.length === 0)
+        return undefined;
+    const open = new Map(openCalls(events, agent.name).map(({ call }) => [call.id, call]));
+    const answers = new Map();
+    const waiting = [];
+    for (const pause of pauses) {
+        const callId = pause.callIds[0];
+        const parts = answerParts.filter((p) => p.functionResponse?.id === interruptIdOf(pause));
+        if (parts.length)
+            answers.set(callId, [...(answers.get(callId) ?? []), ...parts]);
+        else
+            waiting.push(callId);
+    }
+    if (answers.size === 0)
+        return undefined;
+    const calls = [...answers.keys()].map((id) => open.get(id)).filter((c) => !!c);
+    return { calls, answers, waiting: waiting.filter((id) => !answers.has(id)), tools: await toolsOf(agent, scope) };
+}

package/dist/lib/runtime/native/request.d.ts

@@ -13,8 +13,12 @@
  *
  * THE REQUEST, in the order ADK built it:
  *   1. The agent's generateContentConfig, and its output schema when it has
- *      no tools (or the model takes a schema beside tools: Gemini 2 and
- *      later on Vertex AI).
+ *      no tools, or when every model the step may call (its own and its
+ *      fallback_model) takes a schema beside tools in one request: Claude
+ *      from Opus 4.8, Sonnet 5 and Haiku 5.5 on, OpenAI, Gemini 2 and later
+ *      on Vertex AI (outputSchemaBesideTools, lib/models/capabilities.ts,
+ *      ADR 0109). That is how an orchestrator that delegates answers in a
+ *      schema without a set_model_response call.
  *   2. The system prompt, each piece joined to the last by a blank line:
  *      - the identity lines ("You are an agent. Your internal name is …"),
  *        unless the agent may transfer to no one (an output schema rules
@@ -112,6 +116,8 @@ export interface NativeAgent {
     fallbackModel?: string;
     /** `context:` (ADR 0033): compact the history into a summary past a token threshold. The loop runs it before each step (compaction.ts). */
     context?: ContextConfig;
+    /** The syndicate's `max_concurrency` (ADR 0116): delegated calls one step runs at once. Default DEFAULT_MAX_CONCURRENCY (delegate.ts). */
+    maxConcurrency?: number;
 }
 /** What an instruction function reads. */
 export interface InstructionContext {
@@ -166,7 +172,11 @@ export interface BuiltRequest {
 export declare const SET_MODEL_RESPONSE = "set_model_response";
 /** set_model_response as an own Tool: its answer is the arguments, as JSON text, and it ends the step. */
 export declare function setModelResponseTool(outputSchema: Record<string, unknown>): Tool;
-/** Whether the model takes an output schema beside tools in one request (ADK: Vertex AI, Gemini 2 and later). */
+/**
+ * ADK's rule for whether the model takes an output schema beside tools in one
+ * request (Vertex AI, Gemini 2 and later). `mode: task` keeps it as it is,
+ * for the instruction line ADK's processor writes there.
+ */
 export declare function outputSchemaWithTools(model: string): boolean;
 /**
  * What ADK's runLlmAgentAsNode puts in a node agent's invocation context