@google/adk 0.5.0 → 0.6.1

package/dist/cjs/memory/in_memory_memory_service.js

@@ -87,7 +87,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/cjs/runner/runner.js

@@ -24,7 +24,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var runner_exports = {};
 __export(runner_exports, {
-  Runner: () => Runner
+  Runner: () => Runner,
+  isRunner: () => isRunner
 });
 module.exports = __toCommonJS(runner_exports);
 var import_genai = require("@google/genai");
@@ -44,12 +45,19 @@ var import_model_name = require("../utils/model_name.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
+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 import_plugin_manager.PluginManager((_a = input.plugins) != null ? _a : []);
+    this.pluginManager = new import_plugin_manager.PluginManager((_a2 = input.plugins) != null ? _a2 : []);
     this.artifactService = input.artifactService;
     this.sessionService = input.sessionService;
     this.memoryService = input.memoryService;
@@ -109,7 +117,7 @@ class Runner {
         ctx,
         this,
         async function* () {
-          var _a;
+          var _a2;
           const session = await this.sessionService.getSession({
             appName: this.appName,
             userId,
@@ -154,7 +162,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) {
@@ -230,8 +238,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++) {
@@ -312,12 +320,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) {
@@ -339,5 +347,6 @@ function findEventByLastFunctionResponseId(events) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Runner
+  Runner,
+  isRunner
 });

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

@@ -39,7 +39,6 @@ __export(operations_exports, {
   validateDatabaseSchemaVersion: () => validateDatabaseSchemaVersion
 });
 module.exports = __toCommonJS(operations_exports);
-var import_core = require("@mikro-orm/core");
 var import_schema = require("./schema.js");
 /**
  * @license
@@ -75,9 +74,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: import_schema.ENTITIES,
-    dbName: pathname.slice(1),
+    dbName,
     host: hostName,
     port: port ? parseInt(port) : void 0,
     user: username,
@@ -85,19 +85,9 @@ async function getConnectionOptionsFromUri(uri) {
     driver
   };
 }
-async function ensureDatabaseCreated(ormOrUrlOrOptions) {
-  let orm;
-  if (ormOrUrlOrOptions instanceof import_core.MikroORM) {
-    orm = ormOrUrlOrOptions;
-  } else if (typeof ormOrUrlOrOptions === "string") {
-    orm = await import_core.MikroORM.init(
-      await getConnectionOptionsFromUri(ormOrUrlOrOptions)
-    );
-  } else {
-    orm = await import_core.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/cjs/sessions/state.js

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

package/dist/cjs/tools/agent_tool.js

@@ -93,7 +93,7 @@ class AgentTool extends (_b = import_base_tool.BaseTool, _a = AGENT_TOOL_SIGNATU
     args,
     toolContext
   }) {
-    var _a2, _b2;
+    var _a2, _b2, _c, _d;
     if (this.skipSummarization) {
       toolContext.actions.skipSummarization = true;
     }
@@ -112,13 +112,14 @@ class AgentTool extends (_b = import_base_tool.BaseTool, _a = AGENT_TOOL_SIGNATU
       appName: this.agent.name,
       agent: this.agent,
       artifactService: new import_forwarding_artifact_service.ForwardingArtifactService(toolContext),
-      sessionService: new import_in_memory_session_service.InMemorySessionService(),
-      memoryService: new import_in_memory_memory_service.InMemoryMemoryService(),
+      sessionService: (_a2 = toolContext.invocationContext.sessionService) != null ? _a2 : new import_in_memory_session_service.InMemorySessionService(),
+      memoryService: (_b2 = toolContext.invocationContext.memoryService) != null ? _b2 : new import_in_memory_memory_service.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;
@@ -132,7 +133,7 @@ class AgentTool extends (_b = import_base_tool.BaseTool, _a = AGENT_TOOL_SIGNATU
       }
       lastEvent = event;
     }
-    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 = (0, import_llm_agent.isLlmAgent)(this.agent) && this.agent.outputSchema;

package/dist/cjs/tools/load_artifacts_tool.js

@@ -0,0 +1,188 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var load_artifacts_tool_exports = {};
+__export(load_artifacts_tool_exports, {
+  LOAD_ARTIFACTS: () => LOAD_ARTIFACTS,
+  LoadArtifactsTool: () => LoadArtifactsTool
+});
+module.exports = __toCommonJS(load_artifacts_tool_exports);
+var import_genai = require("@google/genai");
+var import_llm_request = require("../models/llm_request.js");
+var import_logger = require("../utils/logger.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = (0, import_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: ${artifactName}, type: ${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 {
+    }
+  }
+  const sizeKb = decodedBuffer.length / 1024;
+  return {
+    text: `[Binary artifact: ${artifactName}, type: ${mimeType}, size: ${sizeKb.toFixed(1)} KB. Content cannot be displayed inline.]`
+  };
+}
+class LoadArtifactsTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({
+      name: "load_artifacts",
+      description: `Loads artifacts into the session for this request.
+
+NOTE: 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: import_genai.Type.OBJECT,
+        properties: {
+          artifact_names: {
+            type: import_genai.Type.ARRAY,
+            items: {
+              type: import_genai.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;
+    }
+    (0, import_llm_request.appendInstructions)(llmRequest, [
+      `You have a list of artifacts:
+  ${JSON.stringify(
+        artifactNames
+      )}
+
+  When the user asks questions about any of the artifacts, you should call the
+  \`load_artifacts\` function to load the artifact. Always call load_artifacts
+  before answering questions related to the artifacts, regardless of whether the
+  artifacts have been loaded before. Do not depend on prior answers about the
+  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:${artifactName}`;
+              artifact = await toolContext.loadArtifact(prefixedName);
+            }
+            if (!artifact) {
+              logger.warn(`Artifact "${artifactName}" not found, skipping`);
+              continue;
+            }
+            const artifactPart = asSafePartForLlm(artifact, artifactName);
+            llmRequest.contents.push({
+              role: "user",
+              parts: [{ text: `Artifact ${artifactName} is:` }, artifactPart]
+            });
+          }
+        }
+      }
+    }
+  }
+}
+const LOAD_ARTIFACTS = new LoadArtifactsTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOAD_ARTIFACTS,
+  LoadArtifactsTool
+});

package/dist/cjs/tools/load_memory_tool.js

@@ -0,0 +1,107 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var load_memory_tool_exports = {};
+__export(load_memory_tool_exports, {
+  LOAD_MEMORY: () => LOAD_MEMORY,
+  LoadMemoryTool: () => LoadMemoryTool
+});
+module.exports = __toCommonJS(load_memory_tool_exports);
+var import_genai = require("@google/genai");
+var import_llm_request = require("../models/llm_request.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class LoadMemoryTool extends import_base_tool.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: import_genai.Type.OBJECT,
+        properties: {
+          query: {
+            type: import_genai.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;
+    }
+    (0, import_llm_request.appendInstructions)(request.llmRequest, [
+      `You have memory. You can use it to answer questions. If any questions need
+you to look up the memory, you should call load_memory function with a query.`
+    ]);
+  }
+}
+const LOAD_MEMORY = new LoadMemoryTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOAD_MEMORY,
+  LoadMemoryTool
+});

package/dist/cjs/tools/preload_memory_tool.js

@@ -0,0 +1,109 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var preload_memory_tool_exports = {};
+__export(preload_memory_tool_exports, {
+  PRELOAD_MEMORY: () => PRELOAD_MEMORY,
+  PreloadMemoryTool: () => PreloadMemoryTool
+});
+module.exports = __toCommonJS(preload_memory_tool_exports);
+var import_llm_request = require("../models/llm_request.js");
+var import_logger = require("../utils/logger.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class PreloadMemoryTool extends import_base_tool.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 (_) {
+      import_logger.logger.warn(`Failed to preload memory for query: ${userQuery}`);
+      return;
+    }
+    if (!response.memories || response.memories.length === 0) {
+      return;
+    }
+    const memoryTextLines = [];
+    for (const memory of response.memories) {
+      const timeStr = memory.timestamp ? `Time: ${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 ? `${memory.author}: ${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.
+They may be useful for answering the user's current query.
+<PAST_CONVERSATIONS>
+${fullMemoryText}
+</PAST_CONVERSATIONS>
+`;
+    (0, import_llm_request.appendInstructions)(request.llmRequest, [si]);
+  }
+}
+const PRELOAD_MEMORY = new PreloadMemoryTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PRELOAD_MEMORY,
+  PreloadMemoryTool
+});

package/dist/cjs/utils/gemini_schema_util.js

@@ -55,22 +55,50 @@ function toGeminiType(mcpType) {
       return import_genai.Type.ARRAY;
     case "object":
       return import_genai.Type.OBJECT;
+    case "null":
+      return import_genai.Type.NULL;
     default:
       return import_genai.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 { type: _removed, anyOf: _removedAnyOf, ...rest } = mcp;
+          mcp = { ...rest, type: nonNullType };
+        }
+      } else if (nonNullTypes.length === 0 && isNullable) {
+        const { type: _removed, anyOf: _removedAnyOf, ...rest } = mcp;
+        mcp = { ...rest, type: "null" };
+      } else if (typeof mcp.anyOf === "undefined") {
+        const anyOfItems = mcp.type.map((t) => ({ type: t }));
+        const { type: _removed, ...rest } = mcp;
+        mcp = { ...rest, anyOf: anyOfItems };
       }
     }
     if (!mcp.type) {
@@ -78,13 +106,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 === import_genai.Type.OBJECT) {
       geminiSchema.properties = {};
       if (mcp.properties) {
@@ -94,7 +134,9 @@ function toGeminiSchema(mcpSchema) {
           );
         }
       }
-      geminiSchema.required = mcp.required;
+      if (mcp.required) {
+        geminiSchema.required = mcp.required;
+      }
     } else if (geminiType === import_genai.Type.ARRAY) {
       if (mcp.items) {
         geminiSchema.items = recursiveConvert(mcp.items);