@google/adk 1.6.0 → 2.1.0

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

@@ -5,10 +5,12 @@
  */
 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';
 import { BaseArtifactService } from '../artifacts/base_artifact_service.js';
+import { SessionArtifactService } from '../artifacts/session_artifact_service.js';
 import { BaseCredentialService } from '../auth/credential_service/base_credential_service.js';
 import { Event } from '../events/event.js';
 import { BaseMemoryService } from '../memory/base_memory_service.js';
@@ -16,6 +18,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 +33,14 @@ 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.
      */
-    agent?: BaseAgent;
+    agent?: RunnableNode;
     /**
      * An optional list of plugins to apply globally across all agents.
      */
@@ -39,7 +48,7 @@ export interface RunnerConfig {
     /**
      * An optional service for storing and retrieving artifacts.
      */
-    artifactService?: BaseArtifactService;
+    artifactService?: BaseArtifactService | SessionArtifactService;
     /**
      * The service for managing sessions.
      */
@@ -96,9 +105,13 @@ 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 artifactService?: BaseArtifactService | SessionArtifactService;
     readonly sessionService: BaseSessionService;
     readonly memoryService?: BaseMemoryService;
     readonly credentialService?: BaseCredentialService;
@@ -145,13 +158,25 @@ 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.
      *
+     * @param artifactService The session-scoped artifact service to save to.
      * @param invocationId The current invocation ID.
-     * @param userId The user ID of the session.
-     * @param sessionId The session ID of the session.
      * @param message The message containing parts to process.
      */
     private saveArtifacts;
@@ -168,9 +193,39 @@ export declare class Runner {
      * Whether the agent to run can transfer to any other agent in the agent tree.
      *
      * @param agentToRun The agent to check for transferability.
-     * @returns True if the agent can transfer, False otherwise.
+     * @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
@@ -186,7 +241,7 @@ export declare function determineAgentForResumption(session: Session, rootAgent:
  *    `disallowTransferToParent` set to false).
  *
  * @param agentToRun The agent to check for transferability.
- * @returns True if the agent can transfer, False otherwise.
+ * @returns True if the agent can transfer, false otherwise.
  */
 export declare function isRoutableLlmAgent(agentToRun: BaseAgent): boolean;
 /**

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. */

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

@@ -3,7 +3,7 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Options as MikroDBOptions } from '@mikro-orm/core';
+import type { MikroORMOptions as MikroDBOptions } from './db/operations.js';
 import { Event } from '../events/event.js';
 import { AppendEventRequest, BaseSessionService, CreateSessionRequest, DeleteSessionRequest, GetSessionRequest, ListSessionsRequest, ListSessionsResponse } from './base_session_service.js';
 import { Session } from './session.js';

package/dist/types/sessions/db/operations.d.ts

@@ -3,10 +3,22 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { MikroORM, Options as MikroORMOptions } from '@mikro-orm/core';
+import type { MikroORM, Options } from '@mikro-orm/core';
+/**
+ * The user-facing MikroORM config shape. Since v7 `Options` marks every key
+ * that has a default as required, so a partial config has to be described as
+ * `Partial<Options>`.
+ */
+export type MikroORMOptions = Partial<Options>;
 /**
  * Parses a database connection URI and returns MikroORM Options.
  *
+ * Dialect drivers are imported dynamically so that installing `@google/adk`
+ * does not pull in five database drivers. Adding a dialect here therefore also
+ * means adding it to core's `peerDependencies` and to dev's `dependencies` (see
+ * "Dependency declarations" in CONTRIBUTING.md);
+ * `tests/integration/lazy_load_db_drivers/driver_manifest_test.ts` enforces it.
+ *
  * @param uri The database connection URI (e.g., "postgres://user:password@host:port/database")
  * @returns MikroORM Options configured for the database
  * @throws Error if the URI is invalid or unsupported

package/dist/types/sessions/db/schema.d.ts

@@ -3,38 +3,50 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { PrimaryKey } from '@mikro-orm/core';
+import { EntitySchema, type Opt, PrimaryKeyProp } from '@mikro-orm/core';
 import { Event } from '../../events/event.js';
 export declare const SCHEMA_VERSION_KEY = "schema_version";
 export declare const SCHEMA_VERSION_1_JSON = "1";
 export declare const STORAGE_KEY_COLUMN_LENGTH = 191;
+/**
+ * Fractional-second digits requested for the stored event timestamp.
+ *
+ * MySQL and MariaDB round a `datetime` column to whole seconds unless a
+ * precision is given. That collapses events written in the same second onto one
+ * value and leaves their order undefined. Other backends are unaffected:
+ * PostgreSQL already defaults to six digits and SQLite ignores the precision.
+ */
+export declare const EVENT_TIMESTAMP_PRECISION = 6;
 export declare class StorageMetadata {
     key: string;
     value: string;
 }
+export declare const storageMetadataSchema: EntitySchema<StorageMetadata, never, import("@mikro-orm/core").EntityCtor<StorageMetadata>>;
 export declare class StorageAppState {
     appName: string;
     state: Record<string, unknown>;
-    updateTime: Date;
+    updateTime: Opt<Date>;
 }
+export declare const storageAppStateSchema: EntitySchema<StorageAppState, never, import("@mikro-orm/core").EntityCtor<StorageAppState>>;
 export declare class StorageUserState {
-    [PrimaryKey.name]?: [string, string] | undefined;
     appName: string;
     userId: string;
     state: Record<string, unknown>;
-    updateTime: Date;
+    updateTime: Opt<Date>;
+    [PrimaryKeyProp]?: ['appName', 'userId'];
 }
+export declare const storageUserStateSchema: EntitySchema<StorageUserState, never, import("@mikro-orm/core").EntityCtor<StorageUserState>>;
 export declare class StorageSession {
-    [PrimaryKey.name]?: [string, string, string] | undefined;
     id: string;
     appName: string;
     userId: string;
     state: Record<string, unknown>;
-    createTime: Date;
-    updateTime: Date;
+    createTime: Opt<Date>;
+    updateTime: Opt<Date>;
+    [PrimaryKeyProp]?: ['id', 'appName', 'userId'];
 }
+export declare const storageSessionSchema: EntitySchema<StorageSession, never, import("@mikro-orm/core").EntityCtor<StorageSession>>;
 export declare class StorageEvent {
-    [PrimaryKey.name]?: [string, string, string, string] | undefined;
     id: string;
     appName: string;
     userId: string;
@@ -42,5 +54,7 @@ export declare class StorageEvent {
     invocationId: string;
     timestamp: Date;
     eventData: Event;
+    [PrimaryKeyProp]?: ['id', 'appName', 'userId', 'sessionId'];
 }
-export declare const ENTITIES: (typeof StorageMetadata | typeof StorageAppState | typeof StorageEvent)[];
+export declare const storageEventSchema: EntitySchema<StorageEvent, never, import("@mikro-orm/core").EntityCtor<StorageEvent>>;
+export declare const ENTITIES: (EntitySchema<StorageMetadata, never, import("@mikro-orm/core").EntityCtor<StorageMetadata>> | EntitySchema<StorageAppState, never, import("@mikro-orm/core").EntityCtor<StorageAppState>> | EntitySchema<StorageUserState, never, import("@mikro-orm/core").EntityCtor<StorageUserState>> | EntitySchema<StorageSession, never, import("@mikro-orm/core").EntityCtor<StorageSession>> | EntitySchema<StorageEvent, never, import("@mikro-orm/core").EntityCtor<StorageEvent>>)[];

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/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

@@ -33,6 +33,17 @@ export interface BaseToolParams {
  * Defined once and shared by all BaseTool instances.
  */
 declare const BASE_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Marks a tool the model runs itself rather than the framework — see
+ * `BuiltInTool`. Such a tool claims its name in the `toolsDict` only so a
+ * function call naming it can be routed, so a genuinely callable tool of the
+ * same name takes precedence over it.
+ */
+export declare const IN_MODEL_TOOL_SYMBOL: unique symbol;
+/**
+ * Whether `tool` is one the model runs itself.
+ */
+export declare function isInModelTool(tool: unknown): boolean;
 /**
  * Type guard to check if an object is an instance of BaseTool.
  * @param obj The object to check.
@@ -80,6 +91,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/base_toolset.d.ts

@@ -65,10 +65,9 @@ export declare abstract class BaseToolset {
      *   process the llm request. e.g. ComputerUseToolset can add computer use
      *   tool to the llm request.
      *
-     * @param toolContext The context of the tool.
-     * @param llmRequest The outgoing LLM request, mutable this method.
+     * @param _toolContext The context of the tool.
+     * @param _llmRequest The outgoing LLM request, mutable this method.
      */
-    processLlmRequest(toolContext: Context, // eslint-disable-line @typescript-eslint/no-unused-vars
-    llmRequest: LlmRequest): Promise<void>;
+    processLlmRequest(_toolContext: Context, _llmRequest: LlmRequest): Promise<void>;
 }
 export {};

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

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseTool, IN_MODEL_TOOL_SYMBOL, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool the model runs itself. It is switched on through request parameters
+ * — Google Search, URL context, the grounding and retrieval tools — and never
+ * executes here.
+ *
+ * Such a tool has no function declaration, so `BaseTool.processLlmRequest`
+ * returns before the line that registers it in `llmRequest.toolsDict`. That
+ * left the model primed with a name the framework could not route: a model
+ * that returns one as an explicit function call, rather than running it,
+ * produced a call that failed to resolve even though the user had registered
+ * the tool. Registering the name here keeps the call resolvable, and
+ * `runAsync` answers it by telling the model the tool is not callable.
+ *
+ * A tool whose `applyBuiltInConfig` returns without configuring anything —
+ * every one of them does when the request carries no model — still claims its
+ * name. That request never reaches a model, so no function call can come back
+ * for it and the registration is inert.
+ */
+export declare abstract class BuiltInTool extends BaseTool {
+    /** Marks this tool as one the model runs itself. */
+    readonly [IN_MODEL_TOOL_SYMBOL] = true;
+    /**
+     * Adds this tool's configuration to the request.
+     *
+     * @param request The request to process the LLM request.
+     */
+    protected abstract applyBuiltInConfig(request: ToolProcessLlmRequest): Promise<void>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+    /**
+     * Answers a function call the model should not have made. The tool is
+     * already configured on the request and its results arrive as grounding
+     * metadata, so the model is told to use those rather than call again.
+     */
+    runAsync(): Promise<unknown>;
+}

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

@@ -1,5 +1,6 @@
 import { LlmRequest } from '../models/llm_request.js';
-import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+import { ToolProcessLlmRequest } from './base_tool.js';
+import { BuiltInTool } from './built_in_tool.js';
 /**
  * Appends the Enterprise Web Search built-in tool to the LLM request when the
  * target model supports it.
@@ -15,10 +16,9 @@ export declare function applyEnterpriseWebSearch(llmRequest: LlmRequest): void;
  * This tool operates internally within the model and does not require or
  * perform local code execution.
  */
-export declare class EnterpriseWebSearchTool extends BaseTool {
+export declare class EnterpriseWebSearchTool extends BuiltInTool {
     constructor();
-    runAsync(): Promise<unknown>;
-    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+    protected applyBuiltInConfig({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
 }
 /**
  * A global instance of {@link EnterpriseWebSearchTool}.

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;
+}

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

@@ -4,21 +4,34 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Part } from '@google/genai';
-import { ArtifactVersion, BaseArtifactService, DeleteArtifactRequest, ListArtifactKeysRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from '../artifacts/base_artifact_service.js';
+import { ArtifactVersion } from '../artifacts/base_artifact_service.js';
+import { SessionArtifactService, SessionLoadArtifactRequest, SessionSaveArtifactRequest } from '../artifacts/session_artifact_service.js';
 import { Context } from '../agents/context.js';
+/**
+ * A unique symbol to identify session-scoped artifact services.
+ *
+ * Resolves to the same symbol as the one used by `isSessionArtifactService` in
+ * `session_artifact_service.ts` because `Symbol.for` looks up the global
+ * symbol registry.
+ */
+declare const SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL: unique symbol;
 /**
  * Artifact service that forwards to the parent tool context.
  */
-export declare class ForwardingArtifactService implements BaseArtifactService {
+export declare class ForwardingArtifactService implements SessionArtifactService {
     private readonly toolContext;
-    private readonly invocationContext;
+    /**
+     * Brands this class as a session-scoped artifact service.
+     */
+    readonly [SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL] = true;
     constructor(toolContext: Context);
-    saveArtifact(request: SaveArtifactRequest): Promise<number>;
-    loadArtifact(request: LoadArtifactRequest): Promise<Part | undefined>;
-    listArtifactKeys(_request: ListArtifactKeysRequest): Promise<string[]>;
+    saveArtifact(request: SessionSaveArtifactRequest): Promise<number>;
+    loadArtifact(request: SessionLoadArtifactRequest): Promise<Part | undefined>;
+    listArtifactKeys(): Promise<string[]>;
     private getArtifactService;
-    deleteArtifact(request: DeleteArtifactRequest): Promise<void>;
-    listVersions(request: ListVersionsRequest): Promise<number[]>;
-    listArtifactVersions(request: ListVersionsRequest): Promise<ArtifactVersion[]>;
-    getArtifactVersion(request: LoadArtifactRequest): Promise<ArtifactVersion | undefined>;
+    deleteArtifact(filename: string): Promise<void>;
+    listVersions(filename: string): Promise<number[]>;
+    listArtifactVersions(filename: string): Promise<ArtifactVersion[]>;
+    getArtifactVersion(request: SessionLoadArtifactRequest): Promise<ArtifactVersion | undefined>;
 }
+export {};