@google/adk 0.5.0 → 0.6.1

package/dist/web/memory/in_memory_memory_service.js

@@ -58,7 +58,7 @@ function getUserKey(appName, userId) {
 }
 function extractWordsLower(text) {
   return new Set(
-    [...text.matchAll(/[A-Za-z]+/)].map((match) => match[0].toLowerCase())
+    [...text.matchAll(/[A-Za-z]+/g)].map((match) => match[0].toLowerCase())
   );
 }
 function formatTimestamp(timestamp) {

package/dist/web/runner/runner.js

@@ -51,6 +51,7 @@ var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")])
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
 import { createPartFromText } from "@google/genai";
 import { context, trace } from "@opentelemetry/api";
 import {
@@ -72,12 +73,18 @@ import {
 } from "../telemetry/tracing.js";
 import { logger } from "../utils/logger.js";
 import { isGemini2OrAbove } from "../utils/model_name.js";
+const RUNNER_SIGNATURE_SYMBOL = Symbol.for("google.adk.runner");
+function isRunner(obj) {
+  return typeof obj === "object" && obj !== null && RUNNER_SIGNATURE_SYMBOL in obj && obj[RUNNER_SIGNATURE_SYMBOL] === true;
+}
+_a = RUNNER_SIGNATURE_SYMBOL;
 class Runner {
   constructor(input) {
-    var _a;
+    this[_a] = true;
+    var _a2;
     this.appName = input.appName;
     this.agent = input.agent;
-    this.pluginManager = new PluginManager((_a = input.plugins) != null ? _a : []);
+    this.pluginManager = new PluginManager((_a2 = input.plugins) != null ? _a2 : []);
     this.artifactService = input.artifactService;
     this.sessionService = input.sessionService;
     this.memoryService = input.memoryService;
@@ -141,7 +148,7 @@ class Runner {
           this,
           function() {
             return __asyncGenerator(this, null, function* () {
-              var _a;
+              var _a2;
               const session = yield new __await(this.sessionService.getSession({
                 appName: this.appName,
                 userId,
@@ -186,7 +193,7 @@ class Runner {
                 newMessage = pluginUserMessage;
               }
               if (newMessage) {
-                if (!((_a = newMessage.parts) == null ? void 0 : _a.length)) {
+                if (!((_a2 = newMessage.parts) == null ? void 0 : _a2.length)) {
                   throw new Error("No parts in the newMessage.");
                 }
                 if (runConfig.saveInputBlobsAsArtifacts) {
@@ -276,8 +283,8 @@ class Runner {
    * @param message The message containing parts to process.
    */
   async saveArtifacts(invocationId, userId, sessionId, message) {
-    var _a;
-    if (!this.artifactService || !((_a = message.parts) == null ? void 0 : _a.length)) {
+    var _a2;
+    if (!this.artifactService || !((_a2 = message.parts) == null ? void 0 : _a2.length)) {
       return;
     }
     for (let i = 0; i < message.parts.length; i++) {
@@ -358,12 +365,12 @@ class Runner {
   // TODO - b/425992518: Implement runLive and related methods.
 }
 function findEventByLastFunctionResponseId(events) {
-  var _a, _b, _c, _d;
+  var _a2, _b, _c, _d;
   if (!events.length) {
     return null;
   }
   const lastEvent = events[events.length - 1];
-  const functionCallId = (_d = (_c = (_b = (_a = lastEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.find(
+  const functionCallId = (_d = (_c = (_b = (_a2 = lastEvent.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b.find(
     (part) => part.functionResponse
   )) == null ? void 0 : _c.functionResponse) == null ? void 0 : _d.id;
   if (!functionCallId) {
@@ -384,5 +391,6 @@ function findEventByLastFunctionResponseId(events) {
   return null;
 }
 export {
-  Runner
+  Runner,
+  isRunner
 };

package/dist/web/sessions/db/operations.js

@@ -25,7 +25,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { MikroORM } from "@mikro-orm/core";
 import {
   ENTITIES,
   SCHEMA_VERSION_1_JSON,
@@ -61,9 +60,10 @@ async function getConnectionOptionsFromUri(uri) {
   }
   const { host, port, username, password, pathname } = new URL(uri);
   const hostName = host.split(":")[0];
+  const dbName = uri.startsWith("sqlite://") ? uri.substring("sqlite://".length) : pathname.slice(1);
   return {
     entities: ENTITIES,
-    dbName: pathname.slice(1),
+    dbName,
     host: hostName,
     port: port ? parseInt(port) : void 0,
     user: username,
@@ -71,19 +71,9 @@ async function getConnectionOptionsFromUri(uri) {
     driver
   };
 }
-async function ensureDatabaseCreated(ormOrUrlOrOptions) {
-  let orm;
-  if (ormOrUrlOrOptions instanceof MikroORM) {
-    orm = ormOrUrlOrOptions;
-  } else if (typeof ormOrUrlOrOptions === "string") {
-    orm = await MikroORM.init(
-      await getConnectionOptionsFromUri(ormOrUrlOrOptions)
-    );
-  } else {
-    orm = await MikroORM.init(ormOrUrlOrOptions);
-  }
+async function ensureDatabaseCreated(orm) {
   await orm.schema.ensureDatabase();
-  await orm.schema.updateSchema();
+  await orm.schema.updateSchema({ safe: true });
 }
 async function validateDatabaseSchemaVersion(orm) {
   const em = orm.em.fork();

package/dist/web/sessions/state.js

@@ -69,8 +69,8 @@ class State {
    * @param delta The delta to update the state with.
    */
   update(delta) {
-    this.delta = __spreadValues(__spreadValues({}, this.delta), delta);
-    this.value = __spreadValues(__spreadValues({}, this.value), delta);
+    Object.assign(this.delta, delta);
+    Object.assign(this.value, delta);
   }
   /**
    * Returns the state as a plain JSON object.

package/dist/web/tools/agent_tool.js

@@ -65,7 +65,7 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
     args,
     toolContext
   }) {
-    var _a2, _b2;
+    var _a2, _b2, _c, _d;
     if (this.skipSummarization) {
       toolContext.actions.skipSummarization = true;
     }
@@ -84,13 +84,14 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
       appName: this.agent.name,
       agent: this.agent,
       artifactService: new ForwardingArtifactService(toolContext),
-      sessionService: new InMemorySessionService(),
-      memoryService: new InMemoryMemoryService(),
+      sessionService: (_a2 = toolContext.invocationContext.sessionService) != null ? _a2 : new InMemorySessionService(),
+      memoryService: (_b2 = toolContext.invocationContext.memoryService) != null ? _b2 : new InMemoryMemoryService(),
       credentialService: toolContext.invocationContext.credentialService
     });
     const session = await runner.sessionService.createSession({
       appName: this.agent.name,
-      userId: "tmp_user",
+      userId: toolContext.invocationContext.userId,
+      sessionId: toolContext.invocationContext.session.id,
       state: toolContext.state.toRecord()
     });
     let lastEvent;
@@ -116,7 +117,7 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
           throw error[0];
       }
     }
-    if (!((_b2 = (_a2 = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b2.length)) {
+    if (!((_d = (_c = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _c.parts) == null ? void 0 : _d.length)) {
       return "";
     }
     const hasOutputSchema = isLlmAgent(this.agent) && this.agent.outputSchema;

package/dist/web/tools/load_artifacts_tool.js

@@ -0,0 +1,150 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { appendInstructions } from "../models/llm_request.js";
+import { getLogger } from "../utils/logger.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+const logger = getLogger();
+const GEMINI_SUPPORTED_INLINE_MIME_PREFIXES = ["image/", "audio/", "video/"];
+const GEMINI_SUPPORTED_INLINE_MIME_TYPES = /* @__PURE__ */ new Set(["application/pdf"]);
+const TEXT_LIKE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "application/csv",
+  "application/json",
+  "application/xml"
+]);
+function normalizeMimeType(mimeType) {
+  if (!mimeType) {
+    return void 0;
+  }
+  return mimeType.split(";")[0].trim();
+}
+function isInlineMimeTypeSupported(mimeType) {
+  const normalized = normalizeMimeType(mimeType);
+  if (!normalized) {
+    return false;
+  }
+  return GEMINI_SUPPORTED_INLINE_MIME_PREFIXES.some(
+    (prefix) => normalized.startsWith(prefix)
+  ) || GEMINI_SUPPORTED_INLINE_MIME_TYPES.has(normalized);
+}
+function asSafePartForLlm(artifact, artifactName) {
+  const inlineData = artifact.inlineData;
+  if (!inlineData) {
+    return artifact;
+  }
+  if (isInlineMimeTypeSupported(inlineData.mimeType)) {
+    return artifact;
+  }
+  const mimeType = normalizeMimeType(inlineData.mimeType) || "application/octet-stream";
+  const data = inlineData.data;
+  if (!data) {
+    return {
+      text: "[Artifact: ".concat(artifactName, ", type: ").concat(mimeType, ". No inline data was provided.]")
+    };
+  }
+  const isTextLike = mimeType.startsWith("text/") || TEXT_LIKE_MIME_TYPES.has(mimeType);
+  const decodedBuffer = Buffer.from(data, "base64");
+  if (isTextLike) {
+    try {
+      const decoded = decodedBuffer.toString("utf8");
+      return { text: decoded };
+    } catch (e) {
+    }
+  }
+  const sizeKb = decodedBuffer.length / 1024;
+  return {
+    text: "[Binary artifact: ".concat(artifactName, ", type: ").concat(mimeType, ", size: ").concat(sizeKb.toFixed(1), " KB. Content cannot be displayed inline.]")
+  };
+}
+class LoadArtifactsTool extends BaseTool {
+  constructor() {
+    super({
+      name: "load_artifacts",
+      description: "Loads artifacts into the session for this request.\n\nNOTE: Call when you need access to artifacts (for example, uploads saved by the web UI)."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          artifact_names: {
+            type: Type.ARRAY,
+            items: {
+              type: Type.STRING
+            },
+            description: "The names of the artifacts to load."
+          }
+        }
+      }
+    };
+  }
+  async runAsync({ args }) {
+    const artifactNames = args["artifact_names"] || [];
+    return {
+      artifact_names: artifactNames,
+      status: "artifact contents temporarily inserted and removed. to access these artifacts, call load_artifacts tool again."
+    };
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    await this.appendArtifactsToLlmRequest(
+      request.toolContext,
+      request.llmRequest
+    );
+  }
+  async appendArtifactsToLlmRequest(toolContext, llmRequest) {
+    if (!toolContext.invocationContext.artifactService) {
+      return;
+    }
+    const artifactNames = await toolContext.listArtifacts();
+    if (!artifactNames || artifactNames.length === 0) {
+      return;
+    }
+    appendInstructions(llmRequest, [
+      "You have a list of artifacts:\n  ".concat(JSON.stringify(
+        artifactNames
+      ), "\n\n  When the user asks questions about any of the artifacts, you should call the\n  `load_artifacts` function to load the artifact. Always call load_artifacts\n  before answering questions related to the artifacts, regardless of whether the\n  artifacts have been loaded before. Do not depend on prior answers about the\n  artifacts.")
+    ]);
+    const contents = llmRequest.contents;
+    if (contents && contents.length > 0) {
+      const lastContent = contents[contents.length - 1];
+      if (lastContent.role === "user" && lastContent.parts && lastContent.parts.length > 0) {
+        const functionResponsePart = lastContent.parts[0];
+        const functionResponse = functionResponsePart.functionResponse;
+        if (functionResponse && functionResponse.name === "load_artifacts") {
+          const response = functionResponse.response || {};
+          const namesToLoad = response["artifact_names"] || [];
+          for (const artifactName of namesToLoad) {
+            let artifact = await toolContext.loadArtifact(artifactName);
+            if (!artifact && !artifactName.startsWith("user:")) {
+              const prefixedName = "user:".concat(artifactName);
+              artifact = await toolContext.loadArtifact(prefixedName);
+            }
+            if (!artifact) {
+              logger.warn('Artifact "'.concat(artifactName, '" not found, skipping'));
+              continue;
+            }
+            const artifactPart = asSafePartForLlm(artifact, artifactName);
+            llmRequest.contents.push({
+              role: "user",
+              parts: [{ text: "Artifact ".concat(artifactName, " is:") }, artifactPart]
+            });
+          }
+        }
+      }
+    }
+  }
+}
+const LOAD_ARTIFACTS = new LoadArtifactsTool();
+export {
+  LOAD_ARTIFACTS,
+  LoadArtifactsTool
+};

package/dist/web/tools/load_memory_tool.js

@@ -0,0 +1,77 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { appendInstructions } from "../models/llm_request.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+class LoadMemoryTool extends BaseTool {
+  constructor() {
+    super({
+      name: "load_memory",
+      description: "Loads the memory for the current user.\n\nNOTE: Currently this tool only uses text part from the memory."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          query: {
+            type: Type.STRING,
+            description: "The query to load the memory for."
+          }
+        },
+        required: ["query"]
+      }
+    };
+  }
+  async runAsync({
+    args,
+    toolContext
+  }) {
+    try {
+      const query = args["query"];
+      if (!toolContext.invocationContext.memoryService) {
+        throw new Error("Memory service is not initialized.");
+      }
+      const searchMemoryResponse = await toolContext.searchMemory(query);
+      return {
+        memories: searchMemoryResponse.memories.map((m) => {
+          var _a, _b;
+          return {
+            // Join all text parts by a space, or empty string if no text parts
+            content: (_b = (_a = m.content.parts) == null ? void 0 : _a.map((p) => {
+              var _a2;
+              return (_a2 = p.text) != null ? _a2 : "";
+            }).join(" ")) != null ? _b : "",
+            author: m.author,
+            timestamp: m.timestamp
+          };
+        })
+      };
+    } catch (e) {
+      console.error("ERROR in LoadMemoryTool runAsync:", e);
+      throw e;
+    }
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    if (!request.toolContext.invocationContext.memoryService) {
+      return;
+    }
+    appendInstructions(request.llmRequest, [
+      "You have memory. You can use it to answer questions. If any questions need\nyou to look up the memory, you should call load_memory function with a query."
+    ]);
+  }
+}
+const LOAD_MEMORY = new LoadMemoryTool();
+export {
+  LOAD_MEMORY,
+  LoadMemoryTool
+};

package/dist/web/tools/preload_memory_tool.js

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { appendInstructions } from "../models/llm_request.js";
+import { logger } from "../utils/logger.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+class PreloadMemoryTool extends BaseTool {
+  constructor() {
+    super({
+      // Name and description are not used because this tool only
+      // changes llm_request.
+      name: "preload_memory",
+      description: "preload_memory"
+    });
+  }
+  async runAsync({
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    args,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    toolContext
+  }) {
+    throw new Error("PreloadMemoryTool should not be called by model");
+  }
+  async processLlmRequest(request) {
+    var _a, _b, _c;
+    await super.processLlmRequest(request);
+    const userContent = request.toolContext.userContent;
+    if (!userContent || !userContent.parts || !((_a = userContent.parts[0]) == null ? void 0 : _a.text)) {
+      return;
+    }
+    const userQuery = userContent.parts[0].text;
+    let response;
+    try {
+      if (!request.toolContext.invocationContext.memoryService) {
+        return;
+      }
+      response = await request.toolContext.searchMemory(userQuery);
+    } catch (_) {
+      logger.warn("Failed to preload memory for query: ".concat(userQuery));
+      return;
+    }
+    if (!response.memories || response.memories.length === 0) {
+      return;
+    }
+    const memoryTextLines = [];
+    for (const memory of response.memories) {
+      const timeStr = memory.timestamp ? "Time: ".concat(memory.timestamp) : "";
+      if (timeStr) memoryTextLines.push(timeStr);
+      const memoryText = (_c = (_b = memory.content.parts) == null ? void 0 : _b.map((p) => {
+        var _a2;
+        return (_a2 = p.text) != null ? _a2 : "";
+      }).join(" ")) != null ? _c : "";
+      if (memoryText) {
+        memoryTextLines.push(
+          memory.author ? "".concat(memory.author, ": ").concat(memoryText) : memoryText
+        );
+      }
+    }
+    if (memoryTextLines.length === 0) {
+      return;
+    }
+    const fullMemoryText = memoryTextLines.join("\n");
+    const si = "The following content is from your previous conversations with the user.\nThey may be useful for answering the user's current query.\n<PAST_CONVERSATIONS>\n".concat(fullMemoryText, "\n</PAST_CONVERSATIONS>\n");
+    appendInstructions(request.llmRequest, [si]);
+  }
+}
+const PRELOAD_MEMORY = new PreloadMemoryTool();
+export {
+  PRELOAD_MEMORY,
+  PreloadMemoryTool
+};

package/dist/web/utils/gemini_schema_util.js

@@ -1,3 +1,34 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -26,22 +57,50 @@ function toGeminiType(mcpType) {
       return Type.ARRAY;
     case "object":
       return Type.OBJECT;
+    case "null":
+      return Type.NULL;
     default:
       return Type.TYPE_UNSPECIFIED;
   }
 }
+const getTypeFromArrayItem = (mcpType) => {
+  var _a, _b;
+  if (typeof mcpType === "string") {
+    return mcpType.toLowerCase();
+  }
+  return (_b = (_a = mcpType == null ? void 0 : mcpType.type) == null ? void 0 : _a.toLowerCase) == null ? void 0 : _b.call(_a);
+};
 function toGeminiSchema(mcpSchema) {
   if (!mcpSchema) {
     return void 0;
   }
   function recursiveConvert(mcp) {
-    if (!mcp.type && mcp.anyOf && Array.isArray(mcp.anyOf)) {
-      const nonNullOption = mcp.anyOf.find((opt) => {
-        const t = opt.type;
-        return t !== "null" && t !== "NULL";
-      });
-      if (nonNullOption) {
-        mcp = nonNullOption;
+    var _a;
+    const sourceType = (_a = mcp.anyOf) != null ? _a : mcp.type;
+    let isNullable = false;
+    let nonNullTypes;
+    if (Array.isArray(sourceType)) {
+      nonNullTypes = sourceType.filter(
+        (t) => getTypeFromArrayItem(t) !== "null"
+      );
+      isNullable = sourceType.some(
+        (t) => getTypeFromArrayItem(t) === "null"
+      );
+      if (nonNullTypes.length === 1) {
+        const nonNullType = nonNullTypes[0];
+        if (typeof nonNullType === "object") {
+          mcp = nonNullType;
+        } else {
+          const _b = mcp, { type: _removed, anyOf: _removedAnyOf } = _b, rest = __objRest(_b, ["type", "anyOf"]);
+          mcp = __spreadProps(__spreadValues({}, rest), { type: nonNullType });
+        }
+      } else if (nonNullTypes.length === 0 && isNullable) {
+        const _c = mcp, { type: _removed, anyOf: _removedAnyOf } = _c, rest = __objRest(_c, ["type", "anyOf"]);
+        mcp = __spreadProps(__spreadValues({}, rest), { type: "null" });
+      } else if (typeof mcp.anyOf === "undefined") {
+        const anyOfItems = mcp.type.map((t) => ({ type: t }));
+        const _d = mcp, { type: _removed } = _d, rest = __objRest(_d, ["type"]);
+        mcp = __spreadProps(__spreadValues({}, rest), { anyOf: anyOfItems });
       }
     }
     if (!mcp.type) {
@@ -49,13 +108,25 @@ function toGeminiSchema(mcpSchema) {
         mcp.type = "object";
       } else if (mcp.items) {
         mcp.type = "array";
+      } else if (isNullable) {
+        mcp.type = "null";
       }
     }
     const geminiType = toGeminiType(mcp.type);
-    const geminiSchema = {
-      type: geminiType,
-      description: mcp.description
-    };
+    const geminiSchema = {};
+    if (mcp.anyOf) {
+      geminiSchema.anyOf = mcp.anyOf.map(
+        (item) => recursiveConvert(item)
+      );
+    } else {
+      geminiSchema.type = geminiType;
+    }
+    if (mcp.description) {
+      geminiSchema.description = mcp.description;
+    }
+    if (isNullable && mcp.type !== "null") {
+      geminiSchema.nullable = true;
+    }
     if (geminiType === Type.OBJECT) {
       geminiSchema.properties = {};
       if (mcp.properties) {
@@ -65,7 +136,9 @@ function toGeminiSchema(mcpSchema) {
           );
         }
       }
-      geminiSchema.required = mcp.required;
+      if (mcp.required) {
+        geminiSchema.required = mcp.required;
+      }
     } else if (geminiType === Type.ARRAY) {
       if (mcp.items) {
         geminiSchema.items = recursiveConvert(mcp.items);

package/dist/web/utils/logger.js

@@ -21,6 +21,7 @@ class SimpleLogger {
         "warn": 2 /* WARN */,
         "error": 3 /* ERROR */
       },
+      level: "error",
       format: winston.format.combine(
         winston.format.label({ label: "ADK" }),
         winston.format((info) => {

package/dist/web/version.js

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "0.5.0";
+const version = "0.6.1";
 export {
   version
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google/adk",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Google ADK JS",
   "author": "Google",
   "license": "Apache-2.0",
@@ -41,20 +41,22 @@
   },
   "dependencies": {
     "@a2a-js/sdk": "^0.3.10",
-    "winston": "^3.19.0",
     "@google/genai": "^1.37.0",
-    "@mikro-orm/core": "^6.6.6",
+    "@mikro-orm/core": "^6.6.10",
     "@mikro-orm/reflection": "^6.6.6",
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "express": "^4.22.1",
     "google-auth-library": "^10.3.0",
     "lodash-es": "^4.17.23",
+    "winston": "^3.19.0",
     "zod": "^4.2.1",
     "zod-to-json-schema": "^3.25.1"
   },
   "devDependencies": {
+    "@mikro-orm/sqlite": "^6.6.6",
+    "@types/express": "^4.17.25",
     "@types/lodash-es": "^4.17.12",
-    "openapi-types": "^12.1.3",
-    "@mikro-orm/sqlite": "^6.6.6"
+    "openapi-types": "^12.1.3"
   },
   "peerDependencies": {
     "@google-cloud/opentelemetry-cloud-monitoring-exporter": "^0.21.0",