@google/adk 1.5.0 → 2.0.0

package/dist/types/index.d.ts

@@ -3,15 +3,9 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export { AGENT_CARD_PATH, RemoteA2AAgent } from './a2a/a2a_remote_agent.js';
-export type { A2AStreamEventData, AfterA2ARequestCallback, BeforeA2ARequestCallback, RemoteA2AAgentConfig, } from './a2a/a2a_remote_agent.js';
-export { getA2AAgentCard } from './a2a/agent_card.js';
-export { A2AAgentExecutor } from './a2a/agent_executor.js';
-export type { AfterEventCallback, AfterExecuteCallback, AgentExecutorConfig, BeforeExecuteCallback, RunnerOrRunnerConfig, } from './a2a/agent_executor.js';
-export { toA2a } from './a2a/agent_to_a2a.js';
-export type { A2aUserBuilder, ToA2aOptions } from './a2a/agent_to_a2a.js';
-export type { ExecutorContext } from './a2a/executor_context.js';
+export * from './a2a/index.js';
 export { InvocationContext } from './agents/invocation_context.js';
+export type { WorkflowInstructionScope } from './agents/invocation_context.js';
 export { FileArtifactService } from './artifacts/file_artifact_service.js';
 export { GcsArtifactService } from './artifacts/gcs_artifact_service.js';
 export { getArtifactServiceFromUri } from './artifacts/registry.js';
@@ -19,17 +13,16 @@ export { AgentEngineSandboxCodeExecutor, type AgentEngineSandboxCodeExecutorOpti
 export { CodeExecutionLanguage } from './code_executors/code_execution_utils.js';
 export { UnsafeLocalCodeExecutor, type UnsafeLocalCodeExecutorOptions, } from './code_executors/unsafe_local_code_executor.js';
 export * from './common.js';
+export { LocalEnvironment } from './environment/local_environment.js';
+export type { LocalEnvironmentOptions } from './environment/local_environment.js';
 export { DatabaseSessionService } from './sessions/database_session_service.js';
 export { getSessionServiceFromUri } from './sessions/registry.js';
 export { VertexAiSessionService } from './sessions/vertex_ai_session_service.js';
-export type { VertexAiSessionServiceOptions } from './sessions/vertex_ai_session_service.js';
+export type { VertexAiCreateSessionRequest, VertexAiSessionServiceOptions, } from './sessions/vertex_ai_session_service.js';
 export { loadAllSkillsInDir, loadSkillFromDir, validateSkillDir, } from './skills/loader.js';
 export { RunSkillInlineScriptErrorCode, RunSkillInlineScriptTool, } from './tools/skill/run_skill_inline_script_tool.js';
 export { RunSkillScriptTool } from './tools/skill/run_skill_script_tool.js';
 export * from './integrations/agent_registry/agent_registry.js';
 export * from './telemetry/google_cloud.js';
 export * from './telemetry/setup.js';
-export * from './tools/mcp/load_mcp_resource_tool.js';
-export * from './tools/mcp/mcp_session_manager.js';
-export * from './tools/mcp/mcp_tool.js';
-export * from './tools/mcp/mcp_toolset.js';
+export * from './tools/mcp/index.js';

package/dist/types/memory/in_memory_memory_service.d.ts

@@ -12,6 +12,17 @@ import { BaseMemoryService, SearchMemoryRequest, SearchMemoryResponse } from './
  */
 export declare class InMemoryMemoryService implements BaseMemoryService {
     private readonly memories;
+    /**
+     * A map from user key to a map from session ID to events.
+     *
+     * The inner map is keyed by `session.id`, which arrives off the request path
+     * and contains no `/`, so it can be exactly `__proto__`. On a plain object
+     * literal that key would reach the inherited `__proto__` setter and
+     * re-parent the map instead of creating an own property, silently dropping
+     * the session from the `Object.values` scan in `searchMemory`. The outer key
+     * always contains a `/` (see `getUserKey`) and cannot collide, but is
+     * created the same way for consistency.
+     */
     private readonly sessionEvents;
     addSessionToMemory(session: Session): Promise<void>;
     searchMemory(req: SearchMemoryRequest): Promise<SearchMemoryResponse>;

package/dist/types/models/apigee_llm.d.ts

@@ -33,10 +33,10 @@ export interface ApigeeLlmParams extends GeminiParams {
      */
     proxyUrl?: string;
     /**
-     * API key to use. If not provided, it will look for
-     * the GOOGLE_GENAI_API_KEY or GEMINI_API_KEY environment variable. If gemini
-     * provider is selected and no key is provided, the fake key "-" will be
-     * used for the "x-goog-api-key" header.
+     * API key to use. If not provided, it will look for the GOOGLE_GENAI_API_KEY,
+     * GOOGLE_API_KEY or GEMINI_API_KEY environment variable, in that order. If
+     * gemini provider is selected and no key is provided, the fake key "-" will
+     * be used for the "x-goog-api-key" header.
      */
     apiKey?: string;
 }

package/dist/types/models/google_llm.d.ts

@@ -19,7 +19,8 @@ export interface GeminiParams {
     model?: string;
     /**
      * The API key to use for the Gemini API. If not provided, it will look for
-     * the GOOGLE_GENAI_API_KEY or GEMINI_API_KEY environment variable.
+     * the GOOGLE_GENAI_API_KEY, GOOGLE_API_KEY or GEMINI_API_KEY environment
+     * variable, in that order.
      */
     apiKey?: string;
     /**

package/dist/types/plugins/base_plugin.d.ts

@@ -11,6 +11,8 @@ import { Event } from '../events/event.js';
 import { LlmRequest } from '../models/llm_request.js';
 import { LlmResponse } from '../models/llm_response.js';
 import { BaseTool } from '../tools/base_tool.js';
+import type { BaseNode } from '../workflow/base_node.js';
+import type { NodeContext } from '../workflow/node_context.js';
 /**
  * Trigger for context compaction.
  */
@@ -151,8 +153,10 @@ export declare abstract class BasePlugin {
      * @param params.invocationContext The context for the entire invocation.
      * @param params.event The event raised by the runner.
      * @returns An optional value. A non-`undefined` return may be used by the
-     *     framework to modify or replace the response. Returning `undefined`
-     *     allows the original response to be used.
+     *     framework to modify or replace the response. Copy `params.event` when
+     *     constructing a replacement to preserve fields that are not being
+     *     modified, such as event actions. Returning `undefined` allows the
+     *     original response to be used.
      */
     onEventCallback(params: {
         invocationContext: InvocationContext;
@@ -202,6 +206,39 @@ export declare abstract class BasePlugin {
         agent: BaseAgent;
         callbackContext: Context;
     }): Promise<Content | undefined>;
+    /**
+     * Callback executed before a workflow node runs.
+     *
+     * @param params.node The node that is about to run.
+     * @param params.nodeContext The node's execution context.
+     * @param params.input The input the node is about to receive.
+     * @returns An optional value. If anything other than `undefined` is returned,
+     *     the node's body is skipped and the returned value becomes its output,
+     *     which is how a plugin implements a node-level cache or a stub.
+     *     Returning `undefined` lets the node run normally.
+     */
+    beforeNodeCallback(params: {
+        node: BaseNode;
+        nodeContext: NodeContext;
+        input: unknown;
+    }): Promise<unknown>;
+    /**
+     * Callback executed after a workflow node has run.
+     *
+     * Not called for a node whose body was skipped by `beforeNodeCallback`, and
+     * not called when the node throws.
+     *
+     * @param params.node The node that has just run.
+     * @param params.nodeContext The node's execution context.
+     * @param params.output The output the node produced.
+     * @returns An optional value replacing the node's output. Returning
+     *     `undefined` keeps the original.
+     */
+    afterNodeCallback(params: {
+        node: BaseNode;
+        nodeContext: NodeContext;
+        output: unknown;
+    }): Promise<unknown>;
     /**
      * Callback executed before a request is sent to the model.
      *

package/dist/types/plugins/plugin_manager.d.ts

@@ -11,6 +11,8 @@ import { Event } from '../events/event.js';
 import { LlmRequest } from '../models/llm_request.js';
 import { LlmResponse } from '../models/llm_response.js';
 import { BaseTool } from '../tools/base_tool.js';
+import type { BaseNode } from '../workflow/base_node.js';
+import type { NodeContext } from '../workflow/node_context.js';
 import { BasePlugin, ContextCompactionTrigger } from './base_plugin.js';
 /**
  * Manages the registration and execution of plugins.
@@ -28,6 +30,8 @@ import { BasePlugin, ContextCompactionTrigger } from './base_plugin.js';
  */
 export declare class PluginManager {
     private readonly plugins;
+    /** Whether any plugin is registered. */
+    get hasPlugins(): boolean;
     /**
      * Initializes the plugin service.
      *
@@ -103,6 +107,22 @@ export declare class PluginManager {
         agent: BaseAgent;
         callbackContext: Context;
     }): Promise<Content | undefined>;
+    /**
+     * Runs the `beforeNodeCallback` for all plugins.
+     */
+    runBeforeNodeCallback({ node, nodeContext, input, }: {
+        node: BaseNode;
+        nodeContext: NodeContext;
+        input: unknown;
+    }): Promise<unknown>;
+    /**
+     * Runs the `afterNodeCallback` for all plugins.
+     */
+    runAfterNodeCallback({ node, nodeContext, output, }: {
+        node: BaseNode;
+        nodeContext: NodeContext;
+        output: unknown;
+    }): Promise<unknown>;
     /**
      * Runs the `beforeToolSelection` for all plugins.
      */

package/dist/types/plugins/security_plugin.d.ts

@@ -5,10 +5,11 @@
  */
 import { FunctionCall } from '@google/genai';
 import { Context } from '../agents/context.js';
+import { REQUEST_CONFIRMATION_FUNCTION_CALL_NAME } from '../agents/functions.js';
 import { Event } from '../events/event.js';
 import { BasePlugin } from '../plugins/base_plugin.js';
 import { BaseTool } from '../tools/base_tool.js';
-export declare const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
+export { REQUEST_CONFIRMATION_FUNCTION_CALL_NAME };
 /**
  * The outcome of a policy check.
  */
@@ -46,9 +47,10 @@ export declare class InMemoryPolicyEngine implements BasePolicyEngine {
     /**
      * Always returns {@link PolicyOutcome.ALLOW} for every tool call.
      *
+     * @param _context - The tool and its arguments; ignored.
      * @returns A promise resolving to an ALLOW result.
      */
-    evaluate(): Promise<PolicyCheckResult>;
+    evaluate(_context: ToolCallPolicyContext): Promise<PolicyCheckResult>;
 }
 /**
  *  Security Plugin for running Orcas agents.

package/dist/types/runner/in_memory_runner.d.ts

@@ -3,10 +3,10 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { BaseAgent } from '../agents/base_agent.js';
 import { App } from '../apps/app.js';
 import { ResumabilityConfig } from '../apps/resumability_config.js';
 import { BasePlugin } from '../plugins/base_plugin.js';
+import { RunnableRoot } from '../workflow/run_node_as_invocation.js';
 import { Runner } from './runner.js';
 /**
  * A {@link Runner} pre-configured with in-memory services.
@@ -40,7 +40,7 @@ export declare class InMemoryRunner extends Runner {
      */
     constructor(params: {
         app?: App;
-        agent?: BaseAgent;
+        agent?: RunnableRoot;
         appName?: string;
         plugins?: BasePlugin[];
         resumabilityConfig?: ResumabilityConfig;

package/dist/types/runner/runner.d.ts

@@ -5,6 +5,7 @@
  */
 import { Content } from '@google/genai';
 import { BaseAgent } from '../agents/base_agent.js';
+import { LiveRequestQueue } from '../agents/live_request_queue.js';
 import { RunConfig } from '../agents/run_config.js';
 import { App } from '../apps/app.js';
 import { ResumabilityConfig } from '../apps/resumability_config.js';
@@ -16,6 +17,8 @@ import { BasePlugin } from '../plugins/base_plugin.js';
 import { PluginManager } from '../plugins/plugin_manager.js';
 import { BaseSessionService } from '../sessions/base_session_service.js';
 import { Session } from '../sessions/session.js';
+import type { RunnableNode } from '../workflow/graph.js';
+import { RunnableRoot } from '../workflow/run_node_as_invocation.js';
 /**
  * The configuration parameters for the Runner.
  */
@@ -29,9 +32,15 @@ export interface RunnerConfig {
      */
     appName?: string;
     /**
-     * The agent to run. Required if `app` is not provided.
+     * The agent or workflow to run. Required if `app` is not provided.
+     *
+     * A bare node — a `Workflow`, most usefully — is accepted as the root and
+     * driven directly, so a graph does not have to be wrapped by hand to be run.
+     * The accepted set is the one an edge takes: any other node-like value
+     * becomes the single node of a one-node workflow. Mirrors adk-python, whose
+     * `Runner.agent` is typed `BaseNode`.
      */
-    agent?: BaseAgent;
+    agent?: RunnableNode;
     /**
      * An optional list of plugins to apply globally across all agents.
      */
@@ -96,7 +105,11 @@ export declare function isRunner(obj: unknown): obj is Runner;
 export declare class Runner {
     readonly [RUNNER_SIGNATURE_SYMBOL] = true;
     readonly appName: string;
-    readonly agent: BaseAgent;
+    /**
+     * The root being run: an agent, or a bare node (a `Workflow`) that the
+     * runner drives directly.
+     */
+    readonly agent: RunnableRoot;
     readonly pluginManager: PluginManager;
     readonly artifactService?: BaseArtifactService;
     readonly sessionService: BaseSessionService;
@@ -145,6 +158,19 @@ export declare class Runner {
         abortSignal?: AbortSignal;
         customMetadata?: Record<string, unknown>;
     }): AsyncGenerator<Event, void, undefined>;
+    /**
+     * Runs whatever this runner was given as its root.
+     *
+     * An agent is run through `runAsync`, as always. A bare node — a `Workflow`
+     * handed to the runner directly — is driven by {@link runNodeAsInvocation}.
+     *
+     * Only the execution differs. Everything around it (the run callbacks, event
+     * persistence, cancellation) is shared, so the node path cannot drift from
+     * the agent path on the things that are not about execution. adk-python has
+     * two separate loops here and a TODO noting its node one lacks tracing and
+     * plugins; there is nothing to lack if there is only one loop.
+     */
+    private runRoot;
     /**
      * Saves artifacts from the message parts and replaces the inline data with
      * a file name placeholder and optional file reference.
@@ -171,6 +197,36 @@ export declare class Runner {
      * @returns True if the agent can transfer, False otherwise.
      */
     private isRoutableLlmAgent;
+    /**
+     * Runs the agent in the live (bidirectional streaming) mode.
+     *
+     * Model media events that carry raw inline bytes (audio, video, or image)
+     * are yielded but not appended to the session to avoid persisting large
+     * blobs; events with `fileData` references and most other live events
+     * (transcriptions, tool calls, usage) are persisted as in `runAsync`.
+     *
+     * This feature is **experimental** and its API may change.
+     *
+     * @param params.userId The user ID of the session.
+     * @param params.sessionId The session ID of the session.
+     * @param params.liveRequestQueue The queue used to feed the live model.
+     * @param params.runConfig The run config for the agent.
+     * @param params.abortSignal Optional signal to abort the live run.
+     * @param params.liveSessionResumptionHandle Optional session resumption
+     *     handle observed from a prior `runLive` cycle on the same conversation.
+     *     When set, the agent's live flow opens the connection with
+     *     `liveConnectConfig.sessionResumption.handle` so the server restores its
+     *     state instead of relying on client-side history replay.
+     * @yields The events generated by the agent.
+     */
+    runLive(params: {
+        userId: string;
+        sessionId: string;
+        liveRequestQueue: LiveRequestQueue;
+        runConfig?: RunConfig;
+        abortSignal?: AbortSignal;
+        liveSessionResumptionHandle?: string;
+    }): AsyncGenerator<Event, void, undefined>;
 }
 /**
  * Determines the next agent to run to continue the session. This is primarily

package/dist/types/sessions/base_session_service.d.ts

@@ -40,8 +40,8 @@ export interface GetSessionRequest extends CompositeSessionKey {
 export interface ListSessionsRequest {
     /** The name of the application. */
     appName: string;
-    /** The ID of the user. */
-    userId: string;
+    /** The ID of the user. Sessions of every user are listed if omitted. */
+    userId?: string;
     /** Maximum number of sessions to return. */
     limit?: number;
     /** Zero-based index of the first session to return. Ignored if `page` is set. */
@@ -145,6 +145,14 @@ export declare abstract class BaseSessionService {
 export declare function trimTempDeltaState(event: Event): Event;
 /**
  * Removes temporary state keys from the state.
+ *
+ * The result is a null-prototype map. `state` comes straight off the request
+ * body on a dev server (`POST /apps/:appName/users/:userId/sessions/:sessionId`),
+ * and `JSON.parse` makes `__proto__` an own key, so copying it into a plain
+ * object literal would invoke the inherited `__proto__` setter: the entry is
+ * dropped and the new state object is re-parented onto the attacker's object.
+ * `State.get`/`State.has` use the `in` operator, so every key on that object
+ * would then read back as session state.
  */
 export declare function trimTempState(state: Record<string, unknown>): Record<string, unknown>;
 /**

package/dist/types/sessions/in_memory_session_service.d.ts

@@ -7,6 +7,15 @@ import { Session } from './session.js';
 export declare function isInMemoryConnectionString(uri?: string): boolean;
 /**
  * An in-memory implementation of the session service.
+ *
+ * Every map below is keyed by untrusted input — `appName`, `userId`,
+ * `sessionId` and state keys all arrive straight off the request path or body
+ * on a dev server — so each is created with `Object.create(null)`. On an
+ * ordinary `{}` literal a key of `__proto__` resolves to the inherited
+ * `__proto__` accessor instead of creating an own property, so
+ * `map[appName][userId] = ...` writes onto `Object.prototype` and pollutes
+ * every object in the process. A null-prototype map has no such accessor, so
+ * those keys become ordinary own properties.
  */
 export declare class InMemorySessionService extends BaseSessionService {
     /**

package/dist/types/sessions/state.d.ts

@@ -3,6 +3,13 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { SchemaLike } from '../utils/schema.js';
+/** Raised when a state mutation violates the declared state schema. */
+export declare class StateSchemaError extends TypeError {
+    constructor(message: string);
+}
+/** Type guard for {@link StateSchemaError}. */
+export declare function isStateSchemaError(e: unknown): e is StateSchemaError;
 /**
  * A state mapping that maintains the current value and the pending-commit
  * delta.
@@ -12,6 +19,11 @@ export declare class State {
     private value;
     /** The delta change to the current value that hasn't been committed. */
     private delta;
+    /**
+     * Declares the keys this state may hold and their types. When set, every
+     * mutation is checked against it; prefixed keys are exempt.
+     */
+    readonly schema?: SchemaLike | undefined;
     static readonly APP_PREFIX = "app:";
     static readonly USER_PREFIX = "user:";
     static readonly TEMP_PREFIX = "temp:";
@@ -19,7 +31,28 @@ export declare class State {
     /** The current value of the state. */
     value?: Record<string, unknown>, 
     /** The delta change to the current value that hasn't been committed. */
-    delta?: Record<string, unknown>);
+    delta?: Record<string, unknown>, 
+    /**
+     * Declares the keys this state may hold and their types. When set, every
+     * mutation is checked against it; prefixed keys are exempt.
+     */
+    schema?: SchemaLike | undefined);
+    /**
+     * Checks a whole delta against {@link schema}, for writes that reach the
+     * session without passing through this object — a node emitting an event
+     * that carries its own `stateDelta`.
+     */
+    validateDelta(delta: Record<string, unknown>): void;
+    /**
+     * Checks one key/value pair against {@link schema}, throwing
+     * {@link StateSchemaError} when the key is undeclared or its value does not
+     * match the declared type.
+     *
+     * Prefixed keys (`app:`, `user:`, `temp:`, or any other namespace) belong to
+     * a scope wider than this state and are never validated — the same carve-out
+     * adk-python makes.
+     */
+    private validate;
     /**
      * Returns the value of the state dict for the given key.
      *

package/dist/types/sessions/state_write_order.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Records a direct write of `key` into `state`, and — when the same write is
+ * being recorded in `delta` for later commit — stamps it there too, so the
+ * commit can tell whether it has since been superseded.
+ */
+export declare function recordStateWrite(state: object, delta: object | undefined, key: string): void;
+/**
+ * Copies the stamp `delta` holds for `key` onto `state`, for a writer that
+ * mirrors one logical write into more than one state object (a workflow node
+ * writes through to `session.state` as well as to its own view). Both objects
+ * then carry the same stamp, so neither can roll the other back.
+ */
+export declare function adoptDeltaStamp(state: object, delta: object, key: string): void;
+/**
+ * Whether committing `key` from `delta` into `state` should go ahead, recording
+ * the write when it should.
+ *
+ * Returns false only when the delta entry is stamped and a newer write to that
+ * key has already landed — the rollback this module exists to prevent.
+ */
+export declare function shouldApplyDeltaWrite(state: object, delta: object, key: string): boolean;
+/**
+ * Carries the stamp for one key from one delta object to another.
+ *
+ * A delta is copied several times between the write and the commit — a node
+ * drains its pending entries into a fresh map, `createEventActions` copies that
+ * into the event, `trimTempDeltaState` rebuilds it again — and each copy is a
+ * new object, so the stamps have to be carried with it. An entry that arrives
+ * at the commit unstamped is applied unconditionally, which is the old
+ * behaviour, so a missed hop degrades rather than breaks.
+ */
+export declare function carryDeltaStamp(from: object, to: object, key: string): void;
+/** {@link carryDeltaStamp} for every key `from` carries a stamp for. */
+export declare function carryDeltaStamps(from: object, to: object): void;

package/dist/types/sessions/vertex_ai_session_service.d.ts

@@ -26,6 +26,19 @@ export interface VertexAiSessionServiceOptions {
     expressModeApiKey?: string;
     sessions?: Sessions;
 }
+/**
+ * The parameters for `VertexAiSessionService.createSession`.
+ *
+ * Extends the common {@link CreateSessionRequest} with the mutually exclusive
+ * session-expiration options supported by Vertex AI Agent Engine Sessions. See
+ * https://cloud.google.com/vertex-ai/generative-ai/docs/reference/rest/v1beta1/projects.locations.reasoningEngines.sessions
+ */
+export interface VertexAiCreateSessionRequest extends CreateSessionRequest {
+    /** Lifetime relative to creation, in seconds, e.g. `'7200s'`. */
+    ttl?: string;
+    /** Absolute RFC 3339 UTC expiration, e.g. `'2025-10-01T00:00:00Z'`. */
+    expireTime?: string;
+}
 /**
  * A session service implementation that integrates with Vertex AI Agent Engine Sessions.
  */
@@ -37,7 +50,12 @@ export declare class VertexAiSessionService extends BaseSessionService {
     private location?;
     constructor(options: VertexAiSessionServiceOptions);
     private getReasoningEngineId;
-    createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;
+    /**
+     * Creates a session on Vertex AI Agent Engine.
+     *
+     * @throws if both `ttl` and `expireTime` are specified.
+     */
+    createSession({ appName, userId, state, sessionId, ttl, expireTime, }: VertexAiCreateSessionRequest): Promise<Session>;
     getSession({ appName, userId, sessionId, config, }: GetSessionRequest): Promise<Session | undefined>;
     listSessions({ appName, userId, limit, offset, page, order, }: ListSessionsRequest): Promise<ListSessionsResponse>;
     deleteSession({ appName, userId, sessionId, }: DeleteSessionRequest): Promise<void>;

package/dist/types/skills/loader.d.ts

@@ -39,7 +39,12 @@ export declare function loadAllSkillsInDir(skillsBasePath: string): Promise<Reco
 /**
  * Loads a complete skill directly from in-memory zip file buffer.
  *
+ * The whole archive is rejected if any member name escapes the extraction
+ * root, and the skill name must be a bare path segment.
+ *
  * @param zipBuffer - The raw Buffer of the zip file containing the skill.
  * @returns A Skill object with all components loaded.
+ * @throws {Error} If a member name is a traversal path, if SKILL.md is missing,
+ * or if the skill name is missing or is not a bare path segment.
  */
 export declare function loadSkillFromZipBuffer(zipBuffer: Buffer): Skill;

package/dist/types/telemetry/tracing.d.ts

@@ -44,6 +44,21 @@ export interface TraceAgentInvocationParams {
  * `server.*` attributes are not set pending confirmation from aabmass.
  */
 export declare function traceAgentInvocation({ agent, invocationContext, }: TraceAgentInvocationParams): void;
+export interface TraceWorkflowInvocationParams {
+    workflowName: string;
+    nodePath: string;
+    sessionId: string;
+}
+export declare function traceWorkflowInvocation({ workflowName, nodePath, sessionId, }: TraceWorkflowInvocationParams): void;
+export type NodeExecutionStatus = 'completed' | 'waiting' | 'failed';
+export interface TraceNodeExecutionParams {
+    nodePath: string;
+    runId: string;
+    attempt: number;
+    status: NodeExecutionStatus;
+    interruptCount: number;
+}
+export declare function traceNodeExecution({ nodePath, runId, attempt, status, interruptCount, }: TraceNodeExecutionParams): void;
 export interface TraceToolCallParams {
     tool: BaseTool;
     args: Record<string, unknown>;

package/dist/types/tools/base_tool.d.ts

@@ -80,6 +80,21 @@ export declare abstract class BaseTool {
      * @return A promise that resolves to the tool response.
      */
     abstract runAsync(request: RunAsyncToolRequest): Promise<unknown>;
+    /**
+     * Whether this tool needs a human to approve `args` before it runs.
+     *
+     * The gate itself lives in the tool that owns it (see `FunctionTool`), but
+     * the resume path has to ask the same question a turn later, to check that an
+     * approval it is about to honour belongs to a tool that gates at all. A tool
+     * that never gates returns false here, which is the safe default: an approval
+     * naming it is meaningless and gets rejected rather than executed. Mirrors
+     * Python's `BaseTool.check_require_confirmation`.
+     *
+     * @param _args The arguments the tool would run with.
+     * @param _toolContext The context of the call, when there is one.
+     * @return Whether the call requires confirmation.
+     */
+    checkRequireConfirmation(_args: Record<string, unknown>, _toolContext?: Context): Promise<boolean>;
     /**
      * Processes the outgoing LLM request for this tool.
      *

package/dist/types/tools/finish_task_tool.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration, Schema } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/** The name of the finish_task tool. */
+export declare const FINISH_TASK_TOOL_NAME = "finish_task";
+/**
+ * The result returned by {@link FinishTaskTool.runAsync} when validation passes.
+ * The task-mode wrapper uses this to distinguish a successful completion from a
+ * validation-error retry signal.
+ */
+export declare const FINISH_TASK_SUCCESS_RESULT = "Task completed.";
+/**
+ * Tool for signaling that a task-mode {@link LlmAgent} has completed its task.
+ *
+ * The tool's parameters mirror the agent's `outputSchema` (or a default single
+ * `result` string). The task-mode wrapper sniffs the `finish_task` function call
+ * and, on a successful function response, promotes the call's arguments to the
+ * node's output.
+ *
+ * Ported from `google/adk-python`
+ * `agents/llm/task/_finish_task_tool.py::FinishTaskTool`.
+ */
+export declare class FinishTaskTool extends BaseTool {
+    /** The schema describing the expected task output. */
+    private readonly outputSchema;
+    /**
+     * When the output schema is a non-object (primitive/array), the value is
+     * wrapped under this key (the GenAI API requires object-typed parameters).
+     * `undefined` for object schemas (the value lives at the top level of args).
+     */
+    readonly wrapperKey?: string;
+    constructor(outputSchema?: Schema);
+    _getDeclaration(): FunctionDeclaration;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+    /**
+     * Extracts the task output from a `finish_task` call's arguments, applying the
+     * wrapper-key unwrapping when the schema is a non-object.
+     */
+    extractOutput(args: Record<string, unknown>): unknown;
+    runAsync({ args }: RunAsyncToolRequest): Promise<unknown>;
+    /** Returns any `required` keys the schema declares that are absent. */
+    private missingRequiredKeys;
+}