@google/adk 0.2.5 → 0.4.0

package/dist/web/artifacts/gcs_artifact_service.js

@@ -24,89 +24,155 @@ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
  */
 import { Storage } from "@google-cloud/storage";
 import { createPartFromBase64, createPartFromText } from "@google/genai";
+import { logger } from "../utils/logger.js";
 class GcsArtifactService {
   constructor(bucket) {
     this.bucket = new Storage().bucket(bucket);
   }
   async saveArtifact(request) {
+    if (!request.artifact.inlineData && !request.artifact.text) {
+      throw new Error("Artifact must have either inlineData or text content.");
+    }
     const versions = await this.listVersions(request);
     const version = versions.length > 0 ? Math.max(...versions) + 1 : 0;
-    const file = this.bucket.file(getFileName(__spreadProps(__spreadValues({}, request), {
-      version
-    })));
+    const file = this.bucket.file(
+      getFileName(__spreadProps(__spreadValues({}, request), {
+        version
+      }))
+    );
+    const metadata = request.customMetadata || {};
     if (request.artifact.inlineData) {
-      await file.save(JSON.stringify(request.artifact.inlineData.data), {
-        contentType: request.artifact.inlineData.mimeType
-      });
+      await file.save(
+        Buffer.from(request.artifact.inlineData.data || "", "base64"),
+        {
+          contentType: request.artifact.inlineData.mimeType,
+          metadata
+        }
+      );
       return version;
     }
-    if (request.artifact.text) {
-      await file.save(request.artifact.text, {
-        contentType: "text/plain"
-      });
-      return version;
-    }
-    throw new Error("Artifact must have either inlineData or text.");
+    await file.save(request.artifact.text, {
+      contentType: "text/plain",
+      metadata
+    });
+    return version;
   }
   async loadArtifact(request) {
-    let version = request.version;
-    if (version === void 0) {
-      const versions = await this.listVersions(request);
-      if (versions.length === 0) {
-        return void 0;
+    try {
+      let version = request.version;
+      if (version === void 0) {
+        const versions = await this.listVersions(request);
+        if (versions.length === 0) {
+          return void 0;
+        }
+        version = Math.max(...versions);
       }
-      version = Math.max(...versions);
-    }
-    const file = this.bucket.file(getFileName(__spreadProps(__spreadValues({}, request), {
-      version
-    })));
-    const [[metadata], [rawDataBuffer]] = await Promise.all([file.getMetadata(), file.download()]);
-    if (metadata.contentType === "text/plain") {
-      return createPartFromText(rawDataBuffer.toString("utf-8"));
+      const file = this.bucket.file(
+        getFileName(__spreadProps(__spreadValues({}, request), {
+          version
+        }))
+      );
+      const [[metadata], [rawDataBuffer]] = await Promise.all([
+        file.getMetadata(),
+        file.download()
+      ]);
+      if (metadata.contentType === "text/plain") {
+        return createPartFromText(rawDataBuffer.toString("utf-8"));
+      }
+      return createPartFromBase64(
+        rawDataBuffer.toString("base64"),
+        metadata.contentType
+      );
+    } catch (e) {
+      logger.warn(
+        "[GcsArtifactService] loadArtifact: Failed to load artifact ".concat(request.filename),
+        e
+      );
+      return void 0;
     }
-    return createPartFromBase64(
-      rawDataBuffer.toString("base64"),
-      metadata.contentType
-    );
   }
   async listArtifactKeys(request) {
-    const fileNames = [];
     const sessionPrefix = "".concat(request.appName, "/").concat(request.userId, "/").concat(request.sessionId, "/");
     const usernamePrefix = "".concat(request.appName, "/").concat(request.userId, "/user/");
-    const [
-      [sessionFiles],
-      [userSessionFiles]
-    ] = await Promise.all([
+    const [[sessionFiles], [userSessionFiles]] = await Promise.all([
       this.bucket.getFiles({ prefix: sessionPrefix }),
       this.bucket.getFiles({ prefix: usernamePrefix })
     ]);
-    for (const file of sessionFiles) {
-      fileNames.push(file.name.split("/").pop());
-    }
-    for (const file of userSessionFiles) {
-      fileNames.push(file.name.split("/").pop());
-    }
-    return fileNames.sort((a, b) => a.localeCompare(b));
+    return [
+      ...extractArtifactKeys(sessionFiles, sessionPrefix),
+      ...extractArtifactKeys(userSessionFiles, usernamePrefix, "user:")
+    ].sort((a, b) => a.localeCompare(b));
   }
   async deleteArtifact(request) {
     const versions = await this.listVersions(request);
-    await Promise.all(versions.map((version) => {
-      const file = this.bucket.file(getFileName(__spreadProps(__spreadValues({}, request), {
-        version
-      })));
-      return file.delete();
-    }));
+    await Promise.all(
+      versions.map((version) => {
+        const file = this.bucket.file(
+          getFileName(__spreadProps(__spreadValues({}, request), {
+            version
+          }))
+        );
+        return file.delete();
+      })
+    );
     return;
   }
   async listVersions(request) {
     const prefix = getFileName(request);
-    const [files] = await this.bucket.getFiles({ prefix });
+    const searchPrefix = prefix + "/";
+    const [files] = await this.bucket.getFiles({ prefix: searchPrefix });
     const versions = [];
     for (const file of files) {
       const version = file.name.split("/").pop();
-      versions.push(parseInt(version, 10));
+      const v = parseInt(version, 10);
+      if (!isNaN(v)) {
+        versions.push(v);
+      }
+    }
+    return versions.sort((a, b) => a - b);
+  }
+  async listArtifactVersions(request) {
+    const versions = await this.listVersions(request);
+    const artifactVersions = [];
+    for (const version of versions) {
+      const artifactVersion = await this.getArtifactVersion(__spreadProps(__spreadValues({}, request), {
+        version
+      }));
+      if (artifactVersion) {
+        artifactVersions.push(artifactVersion);
+      }
+    }
+    return artifactVersions;
+  }
+  async getArtifactVersion(request) {
+    try {
+      let version = request.version;
+      if (version === void 0) {
+        const versions = await this.listVersions(request);
+        if (versions.length === 0) {
+          return void 0;
+        }
+        version = Math.max(...versions);
+      }
+      const file = this.bucket.file(
+        getFileName(__spreadProps(__spreadValues({}, request), {
+          version
+        }))
+      );
+      const [metadata] = await file.getMetadata();
+      return {
+        version,
+        mimeType: metadata.contentType,
+        customMetadata: metadata.metadata,
+        canonicalUri: file.publicUrl()
+      };
+    } catch (e) {
+      logger.warn(
+        "[GcsArtifactService] getArtifactVersion: Failed to get artifact version for userId: ".concat(request.userId, " sessionId: ").concat(request.sessionId, " filename: ").concat(request.filename, " version: ").concat(request.version),
+        e
+      );
+      return void 0;
     }
-    return versions;
   }
 }
 function getFileName({
@@ -116,10 +182,29 @@ function getFileName({
   filename,
   version
 }) {
-  if (filename.startsWith("user:")) {
-    return "".concat(appName, "/").concat(userId, "/user/").concat(filename, "/").concat(version);
+  const isUser = filename.startsWith("user:");
+  const cleanFilename = isUser ? filename.substring(5) : filename;
+  const prefix = isUser ? "".concat(appName, "/").concat(userId, "/user/").concat(cleanFilename) : "".concat(appName, "/").concat(userId, "/").concat(sessionId, "/").concat(cleanFilename);
+  return version !== void 0 ? "".concat(prefix, "/").concat(version) : prefix;
+}
+function extractArtifactKeys(files, fileNamePrefix, keyPrefix = "") {
+  const keys = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    if (!file.name.startsWith(fileNamePrefix)) {
+      continue;
+    }
+    const relative = file.name.substring(fileNamePrefix.length);
+    const name = getFileNameFromPath(relative);
+    keys.add("".concat(keyPrefix).concat(name));
+  }
+  return [...keys];
+}
+function getFileNameFromPath(filePath) {
+  const parts = filePath.split("/");
+  if (parts.length < 2) {
+    return filePath;
   }
-  return "".concat(appName, "/").concat(userId, "/").concat(sessionId, "/").concat(filename, "/").concat(version);
+  return parts.slice(0, -1).join("/");
 }
 export {
   GcsArtifactService

package/dist/web/artifacts/in_memory_artifact_service.js

@@ -3,6 +3,9 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+function isInMemoryConnectionString(uri) {
+  return uri === "memory://";
+}
 class InMemoryArtifactService {
   constructor() {
     this.artifacts = {};
@@ -12,14 +15,24 @@ class InMemoryArtifactService {
     userId,
     sessionId,
     filename,
-    artifact
+    artifact,
+    customMetadata
   }) {
+    if (!artifact.inlineData && !artifact.text) {
+      return Promise.reject(
+        new Error("Artifact must have either inlineData or text content.")
+      );
+    }
     const path = artifactPath(appName, userId, sessionId, filename);
     if (!this.artifacts[path]) {
       this.artifacts[path] = [];
     }
     const version = this.artifacts[path].length;
-    this.artifacts[path].push(artifact);
+    const metadata = {
+      version,
+      customMetadata
+    };
+    this.artifacts[path].push({ part: artifact, metadata });
     return Promise.resolve(version);
   }
   loadArtifact({
@@ -37,9 +50,13 @@ class InMemoryArtifactService {
     if (version === void 0) {
       version = versions.length - 1;
     }
-    return Promise.resolve(versions[version]);
+    return Promise.resolve(versions[version].part);
   }
-  listArtifactKeys({ appName, userId, sessionId }) {
+  listArtifactKeys({
+    appName,
+    userId,
+    sessionId
+  }) {
     const sessionPrefix = "".concat(appName, "/").concat(userId, "/").concat(sessionId, "/");
     const usernamespacePrefix = "".concat(appName, "/").concat(userId, "/user/");
     const filenames = [];
@@ -54,7 +71,12 @@ class InMemoryArtifactService {
     }
     return Promise.resolve(filenames.sort());
   }
-  deleteArtifact({ appName, userId, sessionId, filename }) {
+  deleteArtifact({
+    appName,
+    userId,
+    sessionId,
+    filename
+  }) {
     const path = artifactPath(appName, userId, sessionId, filename);
     if (!this.artifacts[path]) {
       return Promise.resolve();
@@ -62,18 +84,56 @@ class InMemoryArtifactService {
     delete this.artifacts[path];
     return Promise.resolve();
   }
-  listVersions({ appName, userId, sessionId, filename }) {
+  listVersions({
+    appName,
+    userId,
+    sessionId,
+    filename
+  }) {
     const path = artifactPath(appName, userId, sessionId, filename);
     const artifacts = this.artifacts[path];
     if (!artifacts) {
       return Promise.resolve([]);
     }
-    let versions = [];
+    const versions = [];
     for (let i = 0; i < artifacts.length; i++) {
       versions.push(i);
     }
     return Promise.resolve(versions);
   }
+  listArtifactVersions({
+    appName,
+    userId,
+    sessionId,
+    filename
+  }) {
+    const path = artifactPath(appName, userId, sessionId, filename);
+    const artifacts = this.artifacts[path];
+    if (!artifacts) {
+      return Promise.resolve([]);
+    }
+    return Promise.resolve(artifacts.map((a) => a.metadata));
+  }
+  getArtifactVersion({
+    appName,
+    userId,
+    sessionId,
+    filename,
+    version
+  }) {
+    const path = artifactPath(appName, userId, sessionId, filename);
+    const versions = this.artifacts[path];
+    if (!versions) {
+      return Promise.resolve(void 0);
+    }
+    if (version === void 0) {
+      version = versions.length - 1;
+    }
+    if (versions[version]) {
+      return Promise.resolve(versions[version].metadata);
+    }
+    return Promise.resolve(void 0);
+  }
 }
 function artifactPath(appName, userId, sessionId, filename) {
   if (fileHasUserNamespace(filename)) {
@@ -85,5 +145,6 @@ function fileHasUserNamespace(filename) {
   return filename.startsWith("user:");
 }
 export {
-  InMemoryArtifactService
+  InMemoryArtifactService,
+  isInMemoryConnectionString
 };

package/dist/web/artifacts/registry.js

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FileArtifactService } from "./file_artifact_service.js";
+import { GcsArtifactService } from "./gcs_artifact_service.js";
+import {
+  InMemoryArtifactService,
+  isInMemoryConnectionString
+} from "./in_memory_artifact_service.js";
+function getArtifactServiceFromUri(uri) {
+  if (isInMemoryConnectionString(uri)) {
+    return new InMemoryArtifactService();
+  }
+  if (uri.startsWith("gs://")) {
+    const bucket = uri.split("://")[1];
+    return new GcsArtifactService(bucket);
+  }
+  if (uri.startsWith("file://")) {
+    const rootDir = uri.split("://")[1];
+    return new FileArtifactService(rootDir);
+  }
+  throw new Error("Unsupported artifact service URI: ".concat(uri));
+}
+export {
+  getArtifactServiceFromUri
+};

package/dist/web/auth/auth_handler.js

@@ -37,7 +37,9 @@ class AuthHandler {
       };
     }
     if (!this.authConfig.rawAuthCredential.oauth2.clientId || !this.authConfig.rawAuthCredential.oauth2.clientSecret) {
-      throw new Error("Auth Scheme ".concat(authSchemeType, " requires both clientId and clientSecret in authCredential.oauth2."));
+      throw new Error(
+        "Auth Scheme ".concat(authSchemeType, " requires both clientId and clientSecret in authCredential.oauth2.")
+      );
     }
     return {
       credentialKey: this.authConfig.credentialKey,

package/dist/web/code_executors/base_code_executor.js

@@ -4,7 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a;
-const BASE_CODE_EXECUTOR_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseCodeExecutor");
+const BASE_CODE_EXECUTOR_SIGNATURE_SYMBOL = Symbol.for(
+  "google.adk.baseCodeExecutor"
+);
 function isBaseCodeExecutor(obj) {
   return typeof obj === "object" && obj !== null && BASE_CODE_EXECUTOR_SIGNATURE_SYMBOL in obj && obj[BASE_CODE_EXECUTOR_SIGNATURE_SYMBOL] === true;
 }

package/dist/web/code_executors/built_in_code_executor.js

@@ -6,7 +6,9 @@
 var _a, _b;
 import { isGemini2OrAbove } from "../utils/model_name.js";
 import { BaseCodeExecutor } from "./base_code_executor.js";
-const BUILT_IN_CODE_EXECUTOR_SIGNATURE_SYMBOL = Symbol.for("google.adk.builtInCodeExecutor");
+const BUILT_IN_CODE_EXECUTOR_SIGNATURE_SYMBOL = Symbol.for(
+  "google.adk.builtInCodeExecutor"
+);
 function isBuiltInCodeExecutor(obj) {
   return typeof obj === "object" && obj !== null && BUILT_IN_CODE_EXECUTOR_SIGNATURE_SYMBOL in obj && obj[BUILT_IN_CODE_EXECUTOR_SIGNATURE_SYMBOL] === true;
 }
@@ -16,7 +18,7 @@ class BuiltInCodeExecutor extends (_b = BaseCodeExecutor, _a = BUILT_IN_CODE_EXE
     /** A unique symbol to identify BuiltInCodeExecutor class. */
     this[_a] = true;
   }
-  executeCode(params) {
+  executeCode(_params) {
     return Promise.resolve({
       stdout: "",
       stderr: "",
@@ -30,7 +32,9 @@ class BuiltInCodeExecutor extends (_b = BaseCodeExecutor, _a = BUILT_IN_CODE_EXE
       llmRequest.config.tools.push({ codeExecution: {} });
       return;
     }
-    throw new Error("Gemini code execution tool is not supported for model ".concat(llmRequest.model));
+    throw new Error(
+      "Gemini code execution tool is not supported for model ".concat(llmRequest.model)
+    );
   }
 }
 export {

package/dist/web/code_executors/code_executor_context.js

@@ -142,7 +142,9 @@ class CodeExecutorContext {
     if (!(CODE_EXECUTION_RESULTS_KEY in this.sessionState)) {
       this.sessionState.set(CODE_EXECUTION_RESULTS_KEY, {});
     }
-    const codeExecutionResults = this.sessionState.get(CODE_EXECUTION_RESULTS_KEY);
+    const codeExecutionResults = this.sessionState.get(
+      CODE_EXECUTION_RESULTS_KEY
+    );
     if (!(invocationId in codeExecutionResults)) {
       codeExecutionResults[invocationId] = [];
     }
@@ -154,12 +156,10 @@ class CodeExecutorContext {
     });
   }
   /**
-   * Gets the code executor context from the session state.
-   * @param invocationId The session state to get the code executor context
-   *     from.
+   * Gets the code execution context from the session state.
    * @return The code execution context for the given invocation ID.
    */
-  getCodeExecutionContext(invocationId) {
+  getCodeExecutionContext() {
     return this.sessionState.get(CONTEXT_KEY) || {};
   }
 }

package/dist/web/common.js

@@ -32,13 +32,15 @@ import {
   stringifyContent
 } from "./events/event.js";
 import { createEventActions } from "./events/event_actions.js";
+import { EventType, toStructuredEvents } from "./events/structured_events.js";
 import {
   BaseExampleProvider,
   isBaseExampleProvider
 } from "./examples/base_example_provider.js";
 import { InMemoryMemoryService } from "./memory/in_memory_memory_service.js";
+import { ApigeeLlm } from "./models/apigee_llm.js";
 import { BaseLlm, isBaseLlm } from "./models/base_llm.js";
-import { Gemini } from "./models/google_llm.js";
+import { Gemini, geminiInitParams } from "./models/google_llm.js";
 import { LLMRegistry } from "./models/registry.js";
 import { BasePlugin } from "./plugins/base_plugin.js";
 import { LoggingPlugin } from "./plugins/logging_plugin.js";
@@ -52,6 +54,7 @@ import {
 } from "./plugins/security_plugin.js";
 import { InMemoryRunner } from "./runner/in_memory_runner.js";
 import { Runner } from "./runner/runner.js";
+import { BaseSessionService } from "./sessions/base_session_service.js";
 import { InMemorySessionService } from "./sessions/in_memory_session_service.js";
 import { createSession } from "./sessions/session.js";
 import { State } from "./sessions/state.js";
@@ -63,7 +66,7 @@ import { GOOGLE_SEARCH, GoogleSearchTool } from "./tools/google_search_tool.js";
 import { LongRunningFunctionTool } from "./tools/long_running_tool.js";
 import { ToolConfirmation } from "./tools/tool_confirmation.js";
 import { ToolContext } from "./tools/tool_context.js";
-import { LogLevel, setLogLevel } from "./utils/logger.js";
+import { LogLevel, getLogger, setLogLevel, setLogger } from "./utils/logger.js";
 import { isGemini2OrAbove } from "./utils/model_name.js";
 import { zodObjectToSchema } from "./utils/simple_zod_to_json.js";
 import { GoogleLLMVariant } from "./utils/variant_utils.js";
@@ -75,6 +78,7 @@ export * from "./tools/base_tool.js";
 export {
   ActiveStreamingTool,
   AgentTool,
+  ApigeeLlm,
   AuthCredentialTypes,
   BaseAgent,
   BaseCodeExecutor,
@@ -83,10 +87,12 @@ export {
   BaseLlmRequestProcessor,
   BaseLlmResponseProcessor,
   BasePlugin,
+  BaseSessionService,
   BaseTool,
   BaseToolset,
   BuiltInCodeExecutor,
   CallbackContext,
+  EventType,
   FunctionTool,
   GOOGLE_SEARCH,
   Gemini,
@@ -121,9 +127,11 @@ export {
   createEventActions,
   createSession,
   functionsExportedForTestingOnly,
+  geminiInitParams,
   getAskUserConfirmationFunctionCalls,
   getFunctionCalls,
   getFunctionResponses,
+  getLogger,
   hasTrailingCodeExecutionResult,
   isAgentTool,
   isBaseAgent,
@@ -138,7 +146,9 @@ export {
   isParallelAgent,
   isSequentialAgent,
   setLogLevel,
+  setLogger,
   stringifyContent,
+  toStructuredEvents,
   version,
   zodObjectToSchema
 };

package/dist/web/events/event.js

@@ -19,9 +19,10 @@ var __spreadValues = (a, b) => {
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { toCamelCase, toSnakeCase } from "../utils/object_notation_utils.js";
 import { createEventActions } from "./event_actions.js";
 function createEvent(params = {}) {
   return __spreadProps(__spreadValues({}, params), {
@@ -84,12 +85,34 @@ const ASCII_LETTERS_AND_NUMBERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRS
 function createNewEventId() {
   let id = "";
   for (let i = 0; i < 8; i++) {
-    id += ASCII_LETTERS_AND_NUMBERS[Math.floor(
-      Math.random() * ASCII_LETTERS_AND_NUMBERS.length
-    )];
+    id += ASCII_LETTERS_AND_NUMBERS[Math.floor(Math.random() * ASCII_LETTERS_AND_NUMBERS.length)];
   }
   return id;
 }
+const PRESERVE_KEYS_CAMEL_CASE = [
+  "actions.stateDelta",
+  "actions.artifactDelta",
+  "actions.requestedAuthConfigs",
+  "actions.requestedToolConfirmations",
+  "actions.customMetadata",
+  "content.parts.functionCall.args",
+  "content.parts.functionResponse.response"
+];
+const PRESERVE_KEYS_SNAKE_CASE = [
+  "actions.state_delta",
+  "actions.artifact_delta",
+  "actions.requested_auth_configs",
+  "actions.requested_tool_confirmations",
+  "actions.custom_metadata",
+  "content.parts.function_call.args",
+  "content.parts.function_response.response"
+];
+function transformToCamelCaseEvent(event) {
+  return toCamelCase(event, PRESERVE_KEYS_SNAKE_CASE);
+}
+function transformToSnakeCaseEvent(event) {
+  return toSnakeCase(event, PRESERVE_KEYS_CAMEL_CASE);
+}
 export {
   createEvent,
   createNewEventId,
@@ -97,5 +120,7 @@ export {
   getFunctionResponses,
   hasTrailingCodeExecutionResult,
   isFinalResponse,
-  stringifyContent
+  stringifyContent,
+  transformToCamelCaseEvent,
+  transformToSnakeCaseEvent
 };

package/dist/web/events/event_actions.js

@@ -16,7 +16,7 @@ var __spreadValues = (a, b) => {
 };
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 function createEventActions(state = {}) {