@google/adk 1.6.0 → 2.1.0

package/dist/types/a2a/agent_card.d.ts

@@ -4,15 +4,24 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { AgentCard, AgentInterface, AgentSkill } from '@a2a-js/sdk';
-import { BaseAgent } from '../agents/base_agent.js';
+import { RunnableRoot } from '../workflow/run_node_as_invocation.js';
 /**
  * Resolves the AgentCard from the provided source.
+ *
+ * A source is either an {@link AgentCard}, an `http(s)://` URL to fetch it
+ * from, a `file://` URL, or a filesystem path. Any other URL scheme throws: a
+ * source that looks like a URL is never read off the local filesystem.
+ *
+ * The card host must not be, or resolve to, a link-local address, and a
+ * redirect from the card endpoint is refused rather than followed. Loopback and
+ * private addresses stay allowed: they are where a locally served or
+ * VPC-internal peer agent lives.
  */
 export declare function resolveAgentCard(agentCard: AgentCard | string): Promise<AgentCard>;
 /**
  * Converts an ADK agent to an A2A AgentCard.
  */
-export declare function getA2AAgentCard(agent: BaseAgent, transports: AgentInterface[]): Promise<AgentCard>;
+export declare function getA2AAgentCard(agent: RunnableRoot, transports: AgentInterface[]): Promise<AgentCard>;
 /**
  * Builds a list of AgentSkills based on agent descriptions and types.
  * This information can be used in AgentCard to help clients understand agent capabilities.
@@ -20,4 +29,4 @@ export declare function getA2AAgentCard(agent: BaseAgent, transports: AgentInter
  * @param agent The agent to build skills for.
  * @returns A promise resolving to a list of AgentSkills.
  */
-export declare function buildAgentSkills(agent: BaseAgent): Promise<AgentSkill[]>;
+export declare function buildAgentSkills(agent: RunnableRoot): Promise<AgentSkill[]>;

package/dist/types/a2a/agent_executor.d.ts

@@ -16,7 +16,7 @@ export type RunnerOrRunnerConfig = Runner | RunnerConfig | (() => Runner | Runne
 /**
  * Callback called before execution starts.
  */
-export type BeforeExecuteCallback = (reqCtx: RequestContext) => Promise<void>;
+export type BeforeExecuteCallback = (reqCtx: RequestContext, a2aMetadata?: Record<string, unknown>) => Promise<void>;
 /**
  * Callback called after an ADK event is converted to an A2A event.
  */

package/dist/types/a2a/agent_to_a2a.d.ts

@@ -4,13 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { AgentCard } from '@a2a-js/sdk';
-import { UserBuilder } from '@a2a-js/sdk/server/express';
-import express from 'express';
-import { BaseAgent } from '../agents/base_agent.js';
+import type { UserBuilder } from '@a2a-js/sdk/server/express';
+import type express from 'express';
 import { BaseArtifactService } from '../artifacts/base_artifact_service.js';
 import { BaseMemoryService } from '../memory/base_memory_service.js';
 import { Runner } from '../runner/runner.js';
 import { BaseSessionService } from '../sessions/base_session_service.js';
+import { RunnableRoot } from '../workflow/run_node_as_invocation.js';
+import { AdkDefaultRequestHandler, getA2aRequestMetadata } from './request_metadata.js';
+export { AdkDefaultRequestHandler, getA2aRequestMetadata };
 /**
  * A request authenticator for the A2A surface.
  *
@@ -80,4 +82,4 @@ export interface ToA2aOptions {
  * @param options Configuration options
  * @returns An Express application
  */
-export declare function toA2a(agent: BaseAgent, options?: ToA2aOptions): Promise<express.Application>;
+export declare function toA2a(agent: RunnableRoot, options?: ToA2aOptions): Promise<express.Application>;

package/dist/types/a2a/auth.d.ts

@@ -15,7 +15,11 @@ import { A2aUserBuilder } from './agent_to_a2a.js';
  * text on every call.
  *
  * ```ts
- * toA2a(agent, {authentication: bearerTokenUserBuilder(process.env.MY_TOKEN)});
+ * const token = process.env.MY_TOKEN;
+ * if (!token) {
+ *   throw new Error('MY_TOKEN is not set');
+ * }
+ * toA2a(agent, {authentication: bearerTokenUserBuilder(token)});
  * ```
  *
  * A rejected request surfaces as whatever the `@a2a-js/sdk` handler produces

package/dist/types/a2a/event_processor_utils.d.ts

@@ -19,6 +19,21 @@ import { ExecutorContext } from './executor_context.js';
  */
 export declare function getFinalTaskStatusUpdate(adkEvents: AdkEvent[], context: ExecutorContext): TaskStatusUpdateEvent;
 /**
- * Returns input required task status update events if the provided user request does not contain responses for all function calls in the task status.
+ * Returns an input-required status update when the incoming message leaves a
+ * pending request unanswered.
+ *
+ * A pause belongs to the conversation, not to the task that happened to raise
+ * it: the ADK session is keyed by `contextId`, and a client picks its own task
+ * ids. Scoping this to `ctx.task` alone let a caller step around an open gate
+ * by starting a new task in the same context and going on talking to an agent
+ * that is supposed to be waiting on a human. Pending requests are therefore
+ * read from the session as well as from the task, and each one has to be
+ * answered before the agent runs again.
  */
-export declare function getTaskInputRequiredEvent(task: Task, genAIContent: GenAIContent): TaskStatusUpdateEvent | undefined;
+export declare function getUnansweredRequestEvent(options: {
+    taskId: string;
+    contextId: string;
+    task?: Task;
+    sessionEvents: AdkEvent[];
+    genAIContent: GenAIContent;
+}): TaskStatusUpdateEvent | undefined;

package/dist/types/a2a/executor_context.d.ts

@@ -18,16 +18,22 @@ export interface ExecutorContext {
     events: Event[];
     userContent: Content;
     requestContext: RequestContext;
+    /**
+     * Request-level metadata passed from an incoming A2A request.
+     */
+    a2aMetadata?: Record<string, unknown>;
 }
 /**
  * Creates an A2A Agent Executor context from the given parameters.
  * @param session The session.
  * @param userContent The content of the user.
  * @param requestContext The request context.
+ * @param a2aMetadata Optional request-level metadata.
  * @returns The A2A Agent Executor context.
  */
-export declare function createExecutorContext({ session, userContent, requestContext, }: {
+export declare function createExecutorContext({ session, userContent, requestContext, a2aMetadata, }: {
     session: Session;
     userContent: Content;
     requestContext: RequestContext;
+    a2aMetadata?: Record<string, unknown>;
 }): ExecutorContext;

package/dist/types/a2a/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * `@google/adk/a2a` subpath: the A2A surface only, without the full ADK barrel.
+ * Also re-exported from `@google/adk`.
+ */
+export { AGENT_CARD_PATH, RemoteA2AAgent } from './a2a_remote_agent.js';
+export type { A2AStreamEventData, AfterA2ARequestCallback, BeforeA2ARequestCallback, RemoteA2AAgentConfig, } from './a2a_remote_agent.js';
+export { getA2AAgentCard } from './agent_card.js';
+export { A2AAgentExecutor } from './agent_executor.js';
+export type { AfterEventCallback, AfterExecuteCallback, AgentExecutorConfig, BeforeExecuteCallback, RunnerOrRunnerConfig, } from './agent_executor.js';
+export { AdkDefaultRequestHandler, getA2aRequestMetadata, toA2a, } from './agent_to_a2a.js';
+export type { A2aUserBuilder, ToA2aOptions } from './agent_to_a2a.js';
+export { bearerTokenUserBuilder } from './auth.js';
+export type { ExecutorContext } from './executor_context.js';

package/dist/types/a2a/request_metadata.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Message, MessageSendParams, Task, TaskArtifactUpdateEvent, TaskStatusUpdateEvent } from '@a2a-js/sdk';
+import { DefaultRequestHandler, RequestContext, ServerCallContext } from '@a2a-js/sdk/server';
+/**
+ * Extracts request-level A2A metadata from a RequestContext.
+ *
+ * Supports @a2a-js/sdk >= 1.0.0 (`ctx.request.metadata`) and @a2a-js/sdk 0.3.x via
+ * `AdkDefaultRequestHandler`.
+ */
+export declare function getA2aRequestMetadata(ctx: RequestContext): Record<string, unknown> | undefined;
+/**
+ * A2A DefaultRequestHandler extension that preserves request-level metadata (`params.metadata`)
+ * across agent executions regardless of @a2a-js/sdk version.
+ */
+export declare class AdkDefaultRequestHandler extends DefaultRequestHandler {
+    sendMessage(params: MessageSendParams, context?: ServerCallContext): Promise<Message | Task>;
+    sendMessageStream(params: MessageSendParams, context?: ServerCallContext): AsyncGenerator<Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent, void, undefined>;
+}

package/dist/types/agents/base_agent.d.ts

@@ -5,6 +5,8 @@
  */
 import { Content } from '@google/genai';
 import { Event } from '../events/event.js';
+import { BaseNode, BaseNodeConfig } from '../workflow/base_node.js';
+import type { NodeContext } from '../workflow/node_context.js';
 import { Context } from './context.js';
 import { InvocationContext } from './invocation_context.js';
 /**
@@ -23,8 +25,13 @@ export type BeforeAgentCallback = SingleAgentCallback | SingleAgentCallback[];
 export type AfterAgentCallback = SingleAgentCallback | SingleAgentCallback[];
 /**
  * The config of a base agent.
+ *
+ * Extends {@link BaseNodeConfig}, so every agent also accepts the node-level
+ * options — `retryConfig`, `timeout`, `inputSchema`, `outputSchema`,
+ * `stateSchema`, `rerunOnResume`, `waitForOutput` — which apply when the agent
+ * runs inside a workflow.
  */
-export interface BaseAgentConfig {
+export interface BaseAgentConfig extends BaseNodeConfig {
     name: string;
     description?: string;
     parentAgent?: BaseAgent;
@@ -49,8 +56,13 @@ export declare function isBaseAgent(obj: unknown): obj is BaseAgent;
  * The class is generic over its config type so that {@link clone} can be typed
  * per subclass (e.g. `LlmAgent.clone({instruction})`). The default keeps bare
  * `BaseAgent` references valid as `BaseAgent<BaseAgentConfig>`.
+ *
+ * An agent **is** a {@link BaseNode}, so any agent can be dropped straight into
+ * a workflow graph without a wrapper — mirroring adk-python, where
+ * `BaseAgent(BaseNode)`. {@link runImpl} bridges the two contracts: the node
+ * runner calls it, and it delegates to the agent's own {@link runAsync}.
  */
-export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAgentConfig> {
+export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAgentConfig> extends BaseNode {
     /**
      * A unique symbol to identify ADK agent classes.
      */
@@ -70,13 +82,6 @@ export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAg
      * Agent name cannot be "user", since it's reserved for end-user's input.
      */
     readonly name: string;
-    /**
-     * Description about the agent's capability.
-     *
-     * The model uses this to determine whether to delegate control to the agent.
-     * One-line description is enough and preferred.
-     */
-    readonly description?: string;
     /**
      * Root agent of this agent.
      * Computed dynamically by traversing up the parent chain.
@@ -104,11 +109,15 @@ export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAg
      * When a list of callbacks is provided, the callbacks will be called in the
      * order they are listed until a callback does not return undefined.
      *
-     * @param callbackContext: MUST be named 'callbackContext' (enforced).
+     * Each callback takes a single {@link Context} argument. Returning `Content`
+     * skips this agent's own run — its `runAsyncImpl` body and its
+     * `afterAgentCallback` — and emits the returned content as this agent's
+     * response; return `undefined` to let the run proceed.
      *
-     * @return Content: The content to return to the user. When the content is
-     *     present, the agent run will be skipped and the provided content will be
-     *     returned to user.
+     * That skip is scoped to this agent. It sets `endInvocation` on the
+     * invocation context the agent created for itself, which is a copy of its
+     * parent's, so callers above are unaffected: a `SequentialAgent` still runs
+     * the remaining sub-agents.
      */
     readonly beforeAgentCallback: SingleAgentCallback[];
     /**
@@ -117,26 +126,25 @@ export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAg
      * When a list of callbacks is provided, the callbacks will be called in the
      * order they are listed until a callback does not return undefined.
      *
-     * @param callbackContext: MUST be named 'callbackContext' (enforced).
-     *
-     * @return Content: The content to return to the user. When the content is
-     *     present, the provided content will be used as agent response and
-     *     appended to event history as agent response.
+     * Each callback takes a single {@link Context} argument. Returning `Content`
+     * emits it as the agent's response, appended to the event history; return
+     * `undefined` to leave the response as the agent produced it.
      */
     readonly afterAgentCallback: SingleAgentCallback[];
     constructor(config: BaseAgentConfig);
     /**
      * Creates a copy of this agent with the given config fields overridden.
      *
-     * Mirrors adk-python's `BaseAgent.clone(update=...)`. The clone is a detached
-     * root: its `parentAgent` is always `undefined`. Sub-agents are recursively
-     * cloned (and re-parented to the clone) unless `subAgents` is overridden.
-     * Rebuilding via the concrete constructor re-derives all state, so a cloned
-     * `LlmAgent` gets a fresh `requestProcessors` array rather than sharing the
-     * original's. See google/adk-js#534.
+     * The clone is a detached root: its `parentAgent` is always `undefined`.
+     * Sub-agents are recursively cloned (and re-parented to the clone) unless
+     * `subAgents` is overridden. Rebuilding via the concrete constructor
+     * re-derives all state, so a cloned `LlmAgent` gets a fresh
+     * `requestProcessors` array rather than sharing the original's.
+     * See google/adk-js#534.
      *
      * @param overrides Config fields to override on the clone. Overriding
-     *     `parentAgent` is rejected, matching adk-python.
+     *     `parentAgent` is rejected: parentage is assigned only when a parent
+     *     agent is constructed with its sub-agents.
      * @returns A new detached agent instance of the same concrete class.
      */
     clone(overrides?: Partial<TConfig>): this;
@@ -148,6 +156,29 @@ export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAg
      * @returns An AsyncGenerator that yields the events generated by the agent.
      */
     runAsync(parentContext: InvocationContext): AsyncGenerator<Event, void, void>;
+    /**
+     * Runs this agent as a workflow node.
+     *
+     * The node runner calls this; it delegates to {@link runAsync}, so an agent
+     * behaves identically whether it is run directly or as a node. Mirrors
+     * adk-python `BaseAgent._run_impl`.
+     *
+     * The invocation context comes from {@link NodeContext.getInvocationContext}
+     * rather than the raw field, so the agent runs against whatever view of the
+     * session the workflow wants it to see.
+     *
+     * Unlike adk-python's `_run_impl`, nothing is stamped onto the events here.
+     * Python has to fix up the author and the node path because it authors
+     * in-workflow events as the workflow itself; the TypeScript node runner
+     * already owns both (`enrichEvent` keeps an author the node set, and always
+     * stamps the true node path), so repeating it would be dead code.
+     *
+     * `nodeInput` is intentionally unused: an agent's input is its conversation,
+     * which the workflow supplies through the session. A node that needs to read
+     * its input — an `LlmAgent` injecting it into the prompt, say — does so in
+     * its own wrapper.
+     */
+    protected runImpl(ctx: NodeContext, _nodeInput: unknown): AsyncGenerator<Event, void, void>;
     /**
      * Entry method to run an agent via video/audio-based conversation.
      *

package/dist/types/agents/context.d.ts

@@ -9,6 +9,7 @@ import { AuthConfig } from '../auth/auth_tool.js';
 import { EventActions } from '../events/event_actions.js';
 import { SearchMemoryResponse } from '../memory/base_memory_service.js';
 import { State } from '../sessions/state.js';
+import { ResumeInputs } from '../tools/resume_inputs.js';
 import { ToolConfirmation } from '../tools/tool_confirmation.js';
 import { InvocationContext } from './invocation_context.js';
 import { ReadonlyContext } from './readonly_context.js';
@@ -26,6 +27,7 @@ export declare class Context extends ReadonlyContext {
     readonly eventActions: EventActions;
     readonly functionCallId?: string;
     toolConfirmation?: ToolConfirmation;
+    readonly resumeInputs: ResumeInputs;
     readonly abortSignal?: AbortSignal;
     /**
      * @param options The configuration options for the Context.
@@ -38,12 +40,18 @@ export declare class Context extends ReadonlyContext {
      *     call.
      * @param options.toolConfirmation The tool confirmation of the current tool
      *     call.
+     * @param options.resumeInputs The inputs the current tool call is being
+     *     resumed with, if it paused to ask for them, keyed by interrupt id.
+     *     Defaults to empty rather than absent, matching adk-python's
+     *     `Context.resume_inputs`. Carries no approval; see
+     *     {@link ResumeInputs}.
      */
     constructor(options: {
         invocationContext: InvocationContext;
         eventActions?: EventActions;
         functionCallId?: string;
         toolConfirmation?: ToolConfirmation;
+        resumeInputs?: ResumeInputs;
     });
     /**
      * The delta-aware state of the current session.

package/dist/types/agents/framework_function_calls.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content } from '@google/genai';
+/**
+ * The function call the framework emits to ask a human to approve a pending
+ * tool call.
+ */
+export declare const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
+/** The function call the framework emits to ask a client for credentials. */
+export declare const REQUEST_CREDENTIAL_FUNCTION_CALL_NAME = "adk_request_credential";
+/** The function call the framework emits to ask a client for input. */
+export declare const REQUEST_INPUT_FUNCTION_CALL_NAME = "adk_request_input";
+/**
+ * The first reserved function call in `content`, if it carries one.
+ *
+ * Used to keep client input out of the framework's own control plane. Function
+ * responses are untouched: answering a pending request is exactly what a client
+ * is supposed to do.
+ *
+ * @param content The content to inspect.
+ * @return The reserved call's name, or undefined when there is none.
+ */
+export declare function reservedFunctionCallName(content: Content | undefined): string | undefined;

package/dist/types/agents/functions.d.ts

@@ -7,11 +7,11 @@ import { FunctionCall } from '@google/genai';
 import { InvocationContext } from '../agents/invocation_context.js';
 import { Event } from '../events/event.js';
 import { BaseTool } from '../tools/base_tool.js';
+import { ResumeInputs } from '../tools/resume_inputs.js';
 import { ToolConfirmation } from '../tools/tool_confirmation.js';
 import { SingleAfterToolCallback, SingleBeforeToolCallback } from './llm_agent.js';
 export { AF_FUNCTION_CALL_ID_PREFIX, generateClientFunctionCallId, populateClientFunctionCallId, } from '../events/event.js';
-export declare const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
-export declare const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
+export { REQUEST_CONFIRMATION_FUNCTION_CALL_NAME, REQUEST_CREDENTIAL_FUNCTION_CALL_NAME, REQUEST_INPUT_FUNCTION_CALL_NAME, reservedFunctionCallName, } from './framework_function_calls.js';
 export declare const functionsExportedForTestingOnly: {
     handleFunctionCallList: typeof handleFunctionCallList;
     generateAuthEvent: typeof generateAuthEvent;
@@ -40,6 +40,11 @@ export declare function generateRequestConfirmationEvent({ invocationContext, fu
  * Handles function calls.
  * Runtime behavior to pay attention to:
  * - Iterate through each function call in the `functionCallEvent`:
+ *   - Resolve the named tool. If the name is not callable, run the on-tool-
+ *     error callbacks and answer the call with their response, or with the
+ *     resolution error when none handles it, then move to the next call. That
+ *     answer skips the before/after tool callbacks below, so a plugin auditing
+ *     every response does not observe it — as in Python.
  *   - Execute before tool callbacks !!if a callback provides a response, short
  *     circuit the rest.
  *   - Execute the tool.
@@ -48,7 +53,7 @@ export declare function generateRequestConfirmationEvent({ invocationContext, fu
  *   - If the tool is long-running and the response is null, continue. !!state
  * - Merge all function response events into a single event.
  */
-export declare function handleFunctionCallsAsync({ invocationContext, functionCallEvent, toolsDict, beforeToolCallbacks, afterToolCallbacks, filters, toolConfirmationDict, }: {
+export declare function handleFunctionCallsAsync({ invocationContext, functionCallEvent, toolsDict, beforeToolCallbacks, afterToolCallbacks, filters, toolConfirmationDict, resumeInputsDict, }: {
     invocationContext: InvocationContext;
     functionCallEvent: Event;
     toolsDict: Record<string, BaseTool>;
@@ -56,13 +61,22 @@ export declare function handleFunctionCallsAsync({ invocationContext, functionCa
     afterToolCallbacks: SingleAfterToolCallback[];
     filters?: Set<string>;
     toolConfirmationDict?: Record<string, ToolConfirmation>;
+    resumeInputsDict?: Record<string, ResumeInputs>;
 }): Promise<Event | null>;
+/**
+ * Whether `tool` is the placeholder handed to the on-tool-error callbacks for a
+ * function call naming a tool this agent cannot call.
+ *
+ * Lets a plugin tell an unresolvable name from a registered tool that threw
+ * without matching on the error message.
+ */
+export declare function isToolNotFound(tool: unknown): boolean;
 /**
  * The underlying implementation of handleFunctionCalls, but takes a list of
  * function calls instead of an event.
  * This is also used by llm_agent execution flow in preprocessing.
  */
-export declare function handleFunctionCallList({ invocationContext, functionCalls, toolsDict, beforeToolCallbacks, afterToolCallbacks, filters, toolConfirmationDict, }: {
+export declare function handleFunctionCallList({ invocationContext, functionCalls, toolsDict, beforeToolCallbacks, afterToolCallbacks, filters, toolConfirmationDict, resumeInputsDict, }: {
     invocationContext: InvocationContext;
     functionCalls: FunctionCall[];
     toolsDict: Record<string, BaseTool>;
@@ -70,18 +84,69 @@ export declare function handleFunctionCallList({ invocationContext, functionCall
     afterToolCallbacks: SingleAfterToolCallback[];
     filters?: Set<string>;
     toolConfirmationDict?: Record<string, ToolConfirmation>;
+    /**
+     * Inputs to resume a paused tool call with, keyed by function call id. Each
+     * value is itself keyed by interrupt id. Kept apart from
+     * `toolConfirmationDict` so resume inputs can never be mistaken for a human
+     * approval; see {@link ResumeInputs}.
+     */
+    resumeInputsDict?: Record<string, ResumeInputs>;
 }): Promise<Event | null>;
 /**
  * Merges a list of function response events into a single event.
  */
 export declare function mergeParallelFunctionResponseEvents(functionResponseEvents: Event[]): Event;
 /**
- * Finds the function call event that matches the function call ID.
- * Mirrors Python ADK's `find_event_by_function_call_id`.
+ * Finds the most recent event before `endIndex` that contains a function call
+ * with the given ID.
  */
 export declare function findEventByFunctionCallId(events: Event[], functionCallId: string, endIndex?: number): Event | undefined;
 /**
- * Finds the function call event that matches the function response ID of the last event.
- * Mirrors Python ADK's `find_matching_function_call`.
+ * Returns the event containing the function call that the last event's
+ * function response(s) answer, by matching functionCall.id to
+ * functionResponse.id.
+ *
+ * Every function response in the last event is checked, not just the
+ * first one. A single event can carry responses answering calls from
+ * different agents at once -- for example two long-running operations
+ * from sibling sub-agents completing together and being resumed in one
+ * message. Resolving from only `functionResponses[0]` would silently
+ * attribute the rest to whichever agent's call happened to come first,
+ * which is the wrong agent for any response that isn't the first one:
+ * that response would then be processed under a resumed agent's context
+ * it was never meant for, and the agent it actually answers would never
+ * be correctly resumed at all.
+ *
+ * This is a pure lookup: responses with no id, or whose id matches no
+ * function call, are skipped rather than treated as an error, and when
+ * several responses resolve to calls from more than one distinct
+ * author, this does not throw -- it returns the last-resolved match by
+ * iteration order (whichever response is checked last wins). That is a
+ * change from the pre-existing behavior of resolving only
+ * `functionResponses[0]` (which effectively made the first response
+ * win): an external caller of {@link findEventByLastFunctionResponseId}
+ * can now get a different event, and a different id, than before this
+ * fix, even though {@link determineAgentForResumption} itself is
+ * unaffected, since it only reads `.author` and every distinct-author
+ * case is instead surfaced there as a thrown conflict (see
+ * `getConflictingFunctionResponseAuthors`) after that caller's own
+ * resumability gate, not from this function.
  */
 export declare function findMatchingFunctionCall(events: Event[]): Event | undefined;
+/**
+ * Returns the distinct pair of authors when the last event's function
+ * responses resolve to function calls from more than one agent, or
+ * `undefined` when they all resolve to a single agent (or there is
+ * nothing to resolve).
+ *
+ * This performs the same walk as {@link findMatchingFunctionCall} but
+ * reports a conflict instead of silently resolving to one match, so
+ * that a caller can decide when it is safe to raise it. {@link
+ * determineAgentForResumption} is the only current caller, and calls
+ * this only once resumability is confirmed enabled: this function
+ * existing separately from `findMatchingFunctionCall`, rather than
+ * that function throwing directly, is what keeps a session with such
+ * an event from aborting every run (not only resumption attempts) --
+ * see that caller's own comment for why the check has to live there.
+ */
+export declare function getConflictingFunctionResponseAuthors(events: Event[]): [string, string] | undefined;