@google/adk 2.0.0 → 2.2.0

package/dist/esm/sessions/db/schema.js

@@ -1,22 +1,17 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Entity, JsonType, PrimaryKey, Property } from "@mikro-orm/core";
+import {
+  EntitySchema,
+  JsonType,
+  PrimaryKeyProp
+} from "@mikro-orm/core";
 import {
   transformToCamelCaseEvent,
   transformToSnakeCaseEvent
@@ -24,6 +19,7 @@ import {
 const SCHEMA_VERSION_KEY = "schema_version";
 const SCHEMA_VERSION_1_JSON = "1";
 const STORAGE_KEY_COLUMN_LENGTH = 191;
+const EVENT_TIMESTAMP_PRECISION = 6;
 const _CamelCaseToSnakeCaseJsonType = class _CamelCaseToSnakeCaseJsonType extends JsonType {
   convertToDatabaseValue(value) {
     return JSON.stringify(transformToSnakeCaseEvent(value));
@@ -37,174 +33,124 @@ const _CamelCaseToSnakeCaseJsonType = class _CamelCaseToSnakeCaseJsonType extend
 };
 __name(_CamelCaseToSnakeCaseJsonType, "CamelCaseToSnakeCaseJsonType");
 let CamelCaseToSnakeCaseJsonType = _CamelCaseToSnakeCaseJsonType;
-let StorageMetadata = class {
+const KEY_COLUMN = {
+  type: "string",
+  length: STORAGE_KEY_COLUMN_LENGTH,
+  primary: true
 };
-__name(StorageMetadata, "StorageMetadata");
-__decorateClass([
-  PrimaryKey({ type: "string" })
-], StorageMetadata.prototype, "key", 2);
-__decorateClass([
-  Property({ type: "string" })
-], StorageMetadata.prototype, "value", 2);
-StorageMetadata = __decorateClass([
-  Entity({ tableName: "adk_internal_metadata" })
-], StorageMetadata);
-let StorageAppState = class {
+const _StorageMetadata = class _StorageMetadata {
+};
+__name(_StorageMetadata, "StorageMetadata");
+let StorageMetadata = _StorageMetadata;
+const storageMetadataSchema = new EntitySchema({
+  class: StorageMetadata,
+  tableName: "adk_internal_metadata",
+  properties: {
+    key: { type: "string", primary: true },
+    value: { type: "string" }
+  }
+});
+const _StorageAppState = class _StorageAppState {
   constructor() {
     this.updateTime = /* @__PURE__ */ new Date();
   }
 };
-__name(StorageAppState, "StorageAppState");
-__decorateClass([
-  PrimaryKey({
-    type: "string",
-    fieldName: "app_name",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageAppState.prototype, "appName", 2);
-__decorateClass([
-  Property({ type: "json" })
-], StorageAppState.prototype, "state", 2);
-__decorateClass([
-  Property({
-    type: "datetime",
-    fieldName: "update_time",
-    onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate"),
-    onUpdate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onUpdate")
-  })
-], StorageAppState.prototype, "updateTime", 2);
-StorageAppState = __decorateClass([
-  Entity({ tableName: "app_states" })
-], StorageAppState);
-PrimaryKey.name;
-let StorageUserState = class {
+__name(_StorageAppState, "StorageAppState");
+let StorageAppState = _StorageAppState;
+const storageAppStateSchema = new EntitySchema({
+  class: StorageAppState,
+  tableName: "app_states",
+  properties: {
+    appName: { ...KEY_COLUMN, fieldName: "app_name" },
+    state: { type: "json" },
+    updateTime: {
+      type: "datetime",
+      fieldName: "update_time",
+      onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate"),
+      onUpdate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onUpdate")
+    }
+  }
+});
+PrimaryKeyProp;
+const _StorageUserState = class _StorageUserState {
   constructor() {
     this.updateTime = /* @__PURE__ */ new Date();
   }
 };
-__name(StorageUserState, "StorageUserState");
-__decorateClass([
-  PrimaryKey({
-    type: "string",
-    fieldName: "app_name",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageUserState.prototype, "appName", 2);
-__decorateClass([
-  PrimaryKey({
-    type: "string",
-    fieldName: "user_id",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageUserState.prototype, "userId", 2);
-__decorateClass([
-  Property({ type: "json" })
-], StorageUserState.prototype, "state", 2);
-__decorateClass([
-  Property({
-    type: "datetime",
-    fieldName: "update_time",
-    onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate"),
-    onUpdate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onUpdate")
-  })
-], StorageUserState.prototype, "updateTime", 2);
-StorageUserState = __decorateClass([
-  Entity({ tableName: "user_states" })
-], StorageUserState);
-PrimaryKey.name;
-let StorageSession = class {
+__name(_StorageUserState, "StorageUserState");
+let StorageUserState = _StorageUserState;
+const storageUserStateSchema = new EntitySchema({
+  class: StorageUserState,
+  tableName: "user_states",
+  properties: {
+    appName: { ...KEY_COLUMN, fieldName: "app_name" },
+    userId: { ...KEY_COLUMN, fieldName: "user_id" },
+    state: { type: "json" },
+    updateTime: {
+      type: "datetime",
+      fieldName: "update_time",
+      onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate"),
+      onUpdate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onUpdate")
+    }
+  }
+});
+PrimaryKeyProp;
+const _StorageSession = class _StorageSession {
   constructor() {
     this.createTime = /* @__PURE__ */ new Date();
     this.updateTime = /* @__PURE__ */ new Date();
   }
 };
-__name(StorageSession, "StorageSession");
-__decorateClass([
-  PrimaryKey({ type: "string", length: STORAGE_KEY_COLUMN_LENGTH })
-], StorageSession.prototype, "id", 2);
-__decorateClass([
-  PrimaryKey({
-    type: "string",
-    fieldName: "app_name",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageSession.prototype, "appName", 2);
-__decorateClass([
-  PrimaryKey({
-    type: "string",
-    fieldName: "user_id",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageSession.prototype, "userId", 2);
-__decorateClass([
-  Property({ type: "json" })
-], StorageSession.prototype, "state", 2);
-__decorateClass([
-  Property({
-    type: "datetime",
-    fieldName: "create_time",
-    onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate")
-  })
-], StorageSession.prototype, "createTime", 2);
-__decorateClass([
-  Property({
-    type: "datetime",
-    fieldName: "update_time",
-    onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate")
-  })
-], StorageSession.prototype, "updateTime", 2);
-StorageSession = __decorateClass([
-  Entity({ tableName: "sessions" })
-], StorageSession);
-PrimaryKey.name;
-let StorageEvent = class {
+__name(_StorageSession, "StorageSession");
+let StorageSession = _StorageSession;
+const storageSessionSchema = new EntitySchema({
+  class: StorageSession,
+  tableName: "sessions",
+  properties: {
+    id: KEY_COLUMN,
+    appName: { ...KEY_COLUMN, fieldName: "app_name" },
+    userId: { ...KEY_COLUMN, fieldName: "user_id" },
+    state: { type: "json" },
+    createTime: {
+      type: "datetime",
+      fieldName: "create_time",
+      onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate")
+    },
+    updateTime: {
+      type: "datetime",
+      fieldName: "update_time",
+      onCreate: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "onCreate")
+    }
+  }
+});
+PrimaryKeyProp;
+const _StorageEvent = class _StorageEvent {
 };
-__name(StorageEvent, "StorageEvent");
-__decorateClass([
-  PrimaryKey({ type: "string", length: STORAGE_KEY_COLUMN_LENGTH })
-], StorageEvent.prototype, "id", 2);
-__decorateClass([
-  PrimaryKey({
-    type: "string",
-    fieldName: "app_name",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageEvent.prototype, "appName", 2);
-__decorateClass([
-  PrimaryKey({
-    type: "string",
-    fieldName: "user_id",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageEvent.prototype, "userId", 2);
-__decorateClass([
-  PrimaryKey({
-    type: "string",
-    fieldName: "session_id",
-    length: STORAGE_KEY_COLUMN_LENGTH
-  })
-], StorageEvent.prototype, "sessionId", 2);
-__decorateClass([
-  Property({ type: "string", fieldName: "invocation_id" })
-], StorageEvent.prototype, "invocationId", 2);
-__decorateClass([
-  Property({ type: "datetime" })
-], StorageEvent.prototype, "timestamp", 2);
-__decorateClass([
-  Property({ type: CamelCaseToSnakeCaseJsonType, fieldName: "event_data" })
-], StorageEvent.prototype, "eventData", 2);
-StorageEvent = __decorateClass([
-  Entity({ tableName: "events" })
-], StorageEvent);
+__name(_StorageEvent, "StorageEvent");
+let StorageEvent = _StorageEvent;
+const storageEventSchema = new EntitySchema({
+  class: StorageEvent,
+  tableName: "events",
+  properties: {
+    id: KEY_COLUMN,
+    appName: { ...KEY_COLUMN, fieldName: "app_name" },
+    userId: { ...KEY_COLUMN, fieldName: "user_id" },
+    sessionId: { ...KEY_COLUMN, fieldName: "session_id" },
+    invocationId: { type: "string", fieldName: "invocation_id" },
+    timestamp: { type: "datetime", length: EVENT_TIMESTAMP_PRECISION },
+    eventData: { type: CamelCaseToSnakeCaseJsonType, fieldName: "event_data" }
+  }
+});
 const ENTITIES = [
-  StorageMetadata,
-  StorageAppState,
-  StorageUserState,
-  StorageSession,
-  StorageEvent
+  storageMetadataSchema,
+  storageAppStateSchema,
+  storageUserStateSchema,
+  storageSessionSchema,
+  storageEventSchema
 ];
 export {
   ENTITIES,
+  EVENT_TIMESTAMP_PRECISION,
   SCHEMA_VERSION_1_JSON,
   SCHEMA_VERSION_KEY,
   STORAGE_KEY_COLUMN_LENGTH,
@@ -212,5 +158,10 @@ export {
   StorageEvent,
   StorageMetadata,
   StorageSession,
-  StorageUserState
+  StorageUserState,
+  storageAppStateSchema,
+  storageEventSchema,
+  storageMetadataSchema,
+  storageSessionSchema,
+  storageUserStateSchema
 };

package/dist/esm/sessions/registry.js

@@ -28,7 +28,11 @@ function getSessionServiceFromUri(uri) {
     return new DatabaseSessionService(uri);
   }
   if (isVertexAiConnectionString(uri)) {
-    return new VertexAiSessionService({});
+    return new VertexAiSessionService({
+      projectId: process.env.GOOGLE_CLOUD_PROJECT,
+      location: process.env.GOOGLE_CLOUD_LOCATION,
+      agentEngineId: process.env.GOOGLE_CLOUD_AGENT_ENGINE_ID
+    });
   }
   throw new Error(`Unsupported session service URI: ${redactUriPassword(uri)}`);
 }

package/dist/esm/sessions/vertex_ai_session_service.js

@@ -16,7 +16,7 @@ var __decorateClass = (decorators, target, key, kind) => {
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Client } from "@google-cloud/vertexai/build/src/genai/client.js";
+import { Client } from "@google-cloud/vertexai";
 import { isCompactedEvent } from "../events/compacted_event.js";
 import { experimental } from "../utils/experimental.js";
 import { logger } from "../utils/logger.js";

package/dist/esm/telemetry/setup.js

@@ -80,7 +80,7 @@ function getOtelExporters(config = getOtelExportersConfig()) {
         exporter: new OTLPMetricExporter()
       })
     ] : [],
-    logRecordProcessors: enableLogging ? [new BatchLogRecordProcessor(new OTLPLogExporter())] : []
+    logRecordProcessors: enableLogging ? [new BatchLogRecordProcessor({ exporter: new OTLPLogExporter() })] : []
   };
 }
 __name(getOtelExporters, "getOtelExporters");

package/dist/esm/telemetry/tracing.js

@@ -214,13 +214,23 @@ function traceSendData({
   );
 }
 __name(traceSendData, "traceSendData");
+function redactHttpOptions(httpOptions) {
+  const redacted = { ...httpOptions };
+  delete redacted.headers;
+  delete redacted.extraBody;
+  return redacted;
+}
+__name(redactHttpOptions, "redactHttpOptions");
 function buildLlmRequestForTrace(llmRequest) {
   const result = {
     model: llmRequest.model,
     contents: []
   };
   if (llmRequest.config) {
-    const { responseSchema, ...cleanConfig } = llmRequest.config;
+    const { responseSchema: _responseSchema, ...cleanConfig } = llmRequest.config;
+    if (cleanConfig.httpOptions) {
+      cleanConfig.httpOptions = redactHttpOptions(cleanConfig.httpOptions);
+    }
     result.config = cleanConfig;
   }
   result.contents = llmRequest.contents.map((content) => {

package/dist/esm/tools/agent_tool.js

@@ -17,7 +17,7 @@ import { GoogleLLMVariant } from "../utils/variant_utils.js";
 import { State } from "../sessions/state.js";
 import { BaseTool } from "./base_tool.js";
 import { ForwardingArtifactService } from "./forwarding_artifact_service.js";
-const AGENT_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.agentTool");
+const AGENT_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.agentTool");
 function isAgentTool(obj) {
   return typeof obj === "object" && obj !== null && AGENT_TOOL_SIGNATURE_SYMBOL in obj && obj[AGENT_TOOL_SIGNATURE_SYMBOL] === true;
 }
@@ -40,8 +40,7 @@ const _AgentTool = class _AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGN
         name: this.name,
         description: this.description,
         // TODO(b/425992518): We should not use the agent's input schema as is.
-        // It should be validated and possibly transformed. Consider similar
-        // logic to one we have in Python ADK.
+        // It should be validated and possibly transformed first.
         parameters: this.agent.inputSchema
       };
     } else {
@@ -75,8 +74,8 @@ const _AgentTool = class _AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGN
       role: "user",
       parts: [
         {
-          // TODO(b/425992518): Should be validated. Consider similar
-          // logic to one we have in Python ADK.
+          // TODO(b/425992518): Args should be validated against the agent's
+          // input schema before being forwarded.
           text: hasInputSchema ? JSON.stringify(args) : args["request"]
         }
       ]

package/dist/esm/tools/base_tool.js

@@ -9,7 +9,12 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 var _a;
 import { getGoogleLlmVariant } from "../utils/variant_utils.js";
-const BASE_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseTool");
+const BASE_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.baseTool");
+const IN_MODEL_TOOL_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.inModelTool");
+function isInModelTool(tool) {
+  return typeof tool === "object" && tool !== null && tool[IN_MODEL_TOOL_SYMBOL] === true;
+}
+__name(isInModelTool, "isInModelTool");
 function isBaseTool(obj) {
   return typeof obj === "object" && obj !== null && BASE_TOOL_SIGNATURE_SYMBOL in obj && obj[BASE_TOOL_SIGNATURE_SYMBOL] === true;
 }
@@ -76,7 +81,8 @@ const _BaseTool = class _BaseTool {
     if (!functionDeclaration) {
       return;
     }
-    if (this.name in llmRequest.toolsDict) {
+    const registered = Object.hasOwn(llmRequest.toolsDict, this.name) ? llmRequest.toolsDict[this.name] : void 0;
+    if (registered && !isInModelTool(registered)) {
       throw new Error(`Duplicate tool name: ${this.name}`);
     }
     llmRequest.toolsDict[this.name] = this;
@@ -112,5 +118,7 @@ function findToolWithFunctionDeclarations(llmRequest) {
 __name(findToolWithFunctionDeclarations, "findToolWithFunctionDeclarations");
 export {
   BaseTool,
-  isBaseTool
+  IN_MODEL_TOOL_SYMBOL,
+  isBaseTool,
+  isInModelTool
 };

package/dist/esm/tools/base_toolset.js

@@ -8,7 +8,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a;
-const BASE_TOOLSET_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseToolset");
+const BASE_TOOLSET_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.baseToolset");
 function isBaseToolset(obj) {
   return typeof obj === "object" && obj !== null && BASE_TOOLSET_SIGNATURE_SYMBOL in obj && obj[BASE_TOOLSET_SIGNATURE_SYMBOL] === true;
 }
@@ -48,10 +48,10 @@ const _BaseToolset = 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.
    */
-  async processLlmRequest(toolContext, llmRequest) {
+  async processLlmRequest(_toolContext, _llmRequest) {
   }
 };
 __name(_BaseToolset, "BaseToolset");

package/dist/esm/tools/built_in_tool.js

@@ -0,0 +1,51 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+import { logger } from "../utils/logger.js";
+import {
+  BaseTool,
+  IN_MODEL_TOOL_SYMBOL
+} from "./base_tool.js";
+const _BuiltInTool = class _BuiltInTool extends (_b = BaseTool, _a = IN_MODEL_TOOL_SYMBOL, _b) {
+  constructor() {
+    super(...arguments);
+    /** Marks this tool as one the model runs itself. */
+    this[_a] = true;
+  }
+  async processLlmRequest(request) {
+    if (this._getDeclaration()) {
+      throw new Error(
+        `${this.name} extends BuiltInTool but returns a function declaration. A tool the model runs itself cannot declare a callable function; extend BaseTool instead.`
+      );
+    }
+    await this.applyBuiltInConfig(request);
+    if (!Object.hasOwn(request.llmRequest.toolsDict, this.name)) {
+      request.llmRequest.toolsDict[this.name] = this;
+    }
+  }
+  /**
+   * 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.
+   */
+  async runAsync() {
+    logger.warn(
+      `${this.name} runs inside the model but was called as a function; answering with guidance instead of executing anything.`
+    );
+    return {
+      error: `${this.name} runs inside the model and cannot be called as a function. It is already enabled on this request and its results arrive as grounding metadata; answer from those instead of calling it.`
+    };
+  }
+};
+__name(_BuiltInTool, "BuiltInTool");
+let BuiltInTool = _BuiltInTool;
+export {
+  BuiltInTool
+};

package/dist/esm/tools/enterprise_web_search_tool.js

@@ -12,7 +12,7 @@ import {
   isGeminiModel,
   isGeminiModelIdCheckDisabled
 } from "../utils/model_name.js";
-import { BaseTool } from "./base_tool.js";
+import { BuiltInTool } from "./built_in_tool.js";
 function applyEnterpriseWebSearch(llmRequest) {
   if (!llmRequest.model) {
     return;
@@ -34,17 +34,14 @@ function applyEnterpriseWebSearch(llmRequest) {
   );
 }
 __name(applyEnterpriseWebSearch, "applyEnterpriseWebSearch");
-const _EnterpriseWebSearchTool = class _EnterpriseWebSearchTool extends BaseTool {
+const _EnterpriseWebSearchTool = class _EnterpriseWebSearchTool extends BuiltInTool {
   constructor() {
     super({
       name: "enterprise_web_search",
       description: "Enterprise Web Search Tool"
     });
   }
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     llmRequest
   }) {
     applyEnterpriseWebSearch(llmRequest);

package/dist/esm/tools/example_tool.js

@@ -35,7 +35,7 @@ const _ExampleTool = class _ExampleTool extends BaseTool {
       return;
     }
     appendInstructions(llmRequest, [
-      buildExampleSi(this.examples, parts[0].text, llmRequest.model)
+      await buildExampleSi(this.examples, parts[0].text, llmRequest.model)
     ]);
   }
 };

package/dist/esm/tools/forwarding_artifact_service.js

@@ -7,10 +7,18 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
+const SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.sessionArtifactService"
+);
+_a = SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL;
 const _ForwardingArtifactService = class _ForwardingArtifactService {
   constructor(toolContext) {
     this.toolContext = toolContext;
-    this.invocationContext = toolContext.invocationContext;
+    /**
+     * Brands this class as a session-scoped artifact service.
+     */
+    this[_a] = true;
   }
   async saveArtifact(request) {
     return this.toolContext.saveArtifact(request.filename, request.artifact);
@@ -18,30 +26,27 @@ const _ForwardingArtifactService = class _ForwardingArtifactService {
   async loadArtifact(request) {
     return this.toolContext.loadArtifact(request.filename, request.version);
   }
-  async listArtifactKeys(_request) {
+  async listArtifactKeys() {
     return this.toolContext.listArtifacts();
   }
   getArtifactService() {
-    const service = this.invocationContext.artifactService;
+    const service = this.toolContext.invocationContext.artifactService;
     if (!service) {
       throw new Error("Artifact service is not initialized.");
     }
     return service;
   }
-  async deleteArtifact(request) {
-    return this.getArtifactService().deleteArtifact(request.filename);
+  async deleteArtifact(filename) {
+    return this.getArtifactService().deleteArtifact(filename);
   }
-  async listVersions(request) {
-    return this.getArtifactService().listVersions(request.filename);
+  async listVersions(filename) {
+    return this.getArtifactService().listVersions(filename);
   }
-  async listArtifactVersions(request) {
-    return this.getArtifactService().listArtifactVersions(request.filename);
+  async listArtifactVersions(filename) {
+    return this.getArtifactService().listArtifactVersions(filename);
   }
   async getArtifactVersion(request) {
-    return this.getArtifactService().getArtifactVersion({
-      filename: request.filename,
-      version: request.version
-    });
+    return this.getArtifactService().getArtifactVersion(request);
   }
 };
 __name(_ForwardingArtifactService, "ForwardingArtifactService");

package/dist/esm/tools/function_tool.js

@@ -21,7 +21,7 @@ function toSchema(parameters) {
   return parameters;
 }
 __name(toSchema, "toSchema");
-const FUNCTION_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.functionTool");
+const FUNCTION_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.functionTool");
 function isFunctionTool(obj) {
   return typeof obj === "object" && obj !== null && FUNCTION_TOOL_SIGNATURE_SYMBOL in obj && obj[FUNCTION_TOOL_SIGNATURE_SYMBOL] === true;
 }
@@ -62,11 +62,14 @@ const _FunctionTool = class _FunctionTool extends (_b = BaseTool, _a = FUNCTION_
     };
   }
   /**
-   * Validates the model-provided arguments against the parameter schema and
-   * invokes the user-defined `execute` function.
+   * Invokes the user-defined `execute` function with the model-provided
+   * arguments, after parsing them when `parameters` is a Zod object schema.
+   * Any other `parameters` value is passed through unchecked.
    *
    * @param req The tool request containing arguments and tool context.
    * @returns A promise resolving to the function's return value.
+   * @throws {Error} Wrapped as `Error in tool '<name>': …` when a Zod
+   *     `parameters` schema rejects the arguments or `execute` throws.
    */
   async runAsync(req) {
     try {