@google/adk 1.1.0 → 1.3.0

package/dist/esm/tools/skill/load_skill_tool.js

@@ -53,7 +53,18 @@ let LoadSkillTool = class extends BaseTool {
         error_code: "MISSING_SKILL_NAME"
       };
     }
-    const skill = this.toolset.getSkill(skillName);
+    let skill;
+    try {
+      skill = await this.toolset.getOrFetchSkill(
+        skillName,
+        toolContext.invocationId
+      );
+    } catch (e) {
+      return {
+        error: `Failed to fetch skill '${skillName}' from registry: ${e.message || e}`,
+        error_code: "REGISTRY_ERROR"
+      };
+    }
     if (!skill) {
       return {
         error: `Skill '${skillName}' not found.`,

package/dist/esm/tools/skill/run_skill_script_tool.js

@@ -80,7 +80,18 @@ let RunSkillScriptTool = class extends BaseTool {
         errorCode: "MISSING_SCRIPT_PATH"
       };
     }
-    const skill = this.toolset.getSkill(skillName);
+    let skill;
+    try {
+      skill = await this.toolset.getOrFetchSkill(
+        skillName,
+        toolContext.invocationId
+      );
+    } catch (e) {
+      return {
+        error: `Failed to fetch skill '${skillName}' from registry: ${e.message || e}`,
+        errorCode: "REGISTRY_ERROR"
+      };
+    }
     if (!skill) {
       return {
         error: `Skill '${skillName}' not found.`,

package/dist/esm/tools/skill/search_skills_tool.js

@@ -0,0 +1,82 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 { Type } from "@google/genai";
+import { experimental } from "../../utils/experimental.js";
+import { logger } from "../../utils/logger.js";
+import { BaseTool } from "../base_tool.js";
+let SearchSkillsTool = class extends BaseTool {
+  constructor(toolset) {
+    var _a, _b;
+    if (!toolset.registry) {
+      throw new Error("SearchSkillsTool requires a configured skill registry.");
+    }
+    super({
+      name: "search_skills",
+      description: ((_b = (_a = toolset.registry).searchToolDescription) == null ? void 0 : _b.call(_a)) || "Searches for relevant skills in the registry based on a semantic or keyword query."
+    });
+    this.toolset = toolset;
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          query: {
+            type: Type.STRING,
+            description: "Semantic or keyword search query."
+          }
+        },
+        required: ["query"]
+      }
+    };
+  }
+  async runAsync({ args }) {
+    const query = args["query"];
+    if (!query) {
+      return {
+        error: "Argument 'query' is required.",
+        error_code: "INVALID_ARGUMENTS"
+      };
+    }
+    try {
+      const results = await this.toolset.registry.searchSkills(query);
+      return results.filter((r) => {
+        if (this.toolset.skills[r.name]) {
+          logger.warn(
+            `Skill naming conflict: skill '${r.name}' already exists locally. Registry skill is filtered.`
+          );
+          return false;
+        }
+        return true;
+      });
+    } catch (e) {
+      return {
+        error: `Failed to search skills from registry: ${e.message || e}`,
+        error_code: "REGISTRY_ERROR"
+      };
+    }
+  }
+};
+SearchSkillsTool = __decorateClass([
+  experimental
+], SearchSkillsTool);
+export {
+  SearchSkillsTool
+};

package/dist/esm/tools/skill/skill_toolset.js

@@ -18,6 +18,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 import { appendInstructions } from "../../models/llm_request.js";
 import { formatSkillsAsXml } from "../../skills/prompt.js";
 import { experimental } from "../../utils/experimental.js";
+import { logger } from "../../utils/logger.js";
 import { BaseTool } from "../base_tool.js";
 import { BaseToolset } from "../base_toolset.js";
 import { ListSkillsTool } from "./list_skills_tool.js";
@@ -25,6 +26,7 @@ import { LoadSkillResourceTool } from "./load_skill_resource_tool.js";
 import { LoadSkillTool } from "./load_skill_tool.js";
 import { RunSkillInlineScriptTool } from "./run_skill_inline_script_tool.js";
 import { RunSkillScriptTool } from "./run_skill_script_tool.js";
+import { SearchSkillsTool } from "./search_skills_tool.js";
 const DEFAULT_SKILL_SYSTEM_INSTRUCTION = `You can use specialized 'skills' to help you with complex tasks. You MUST use the skill tools to interact with these skills.
 
 Skills are folders of instructions and resources that extend your capabilities for specialized tasks. Each skill folder contains:
@@ -44,9 +46,11 @@ let SkillToolset = class extends BaseToolset {
   constructor(skills, options = {}) {
     super([], "adk_skill_toolset");
     this.toolCache = /* @__PURE__ */ new Map();
+    this.fetchedSkillCache = /* @__PURE__ */ new Map();
     this.skills = Array.isArray(skills) ? Object.fromEntries(skills.map((s) => [s.frontmatter.name, s])) : skills;
     this.codeExecutor = options.codeExecutor;
     this.additionalTools = options.additionalTools || [];
+    this.registry = options.registry;
     this.tools = [
       new ListSkillsTool(this),
       new LoadSkillTool(this),
@@ -54,24 +58,55 @@ let SkillToolset = class extends BaseToolset {
       new RunSkillScriptTool(this),
       new RunSkillInlineScriptTool(this)
     ];
+    if (this.registry) {
+      this.tools.push(new SearchSkillsTool(this));
+    }
   }
   async getTools(context) {
     const dynamicTools = await this.resolveAdditionalTools(context);
     return [...this.tools, ...dynamicTools];
   }
   async close() {
+    this.fetchedSkillCache.clear();
   }
   getSkill(name) {
     return this.skills[name];
   }
+  async getOrFetchSkill(name, invocationId) {
+    if (this.skills[name]) {
+      return this.skills[name];
+    }
+    if (!this.registry) {
+      return void 0;
+    }
+    const contextKey = invocationId || "default";
+    if (!this.fetchedSkillCache.has(contextKey)) {
+      this.fetchedSkillCache.set(contextKey, /* @__PURE__ */ new Map());
+    }
+    const cache = this.fetchedSkillCache.get(contextKey);
+    if (cache.has(name)) {
+      return cache.get(name);
+    }
+    try {
+      const skill = await this.registry.getSkill(name);
+      cache.set(name, skill);
+      return skill;
+    } catch (e) {
+      logger.warn(`Failed to fetch skill '${name}' from registry: ${e}`);
+      throw e;
+    }
+  }
   async processLlmRequest(toolContext, llmRequest) {
     await super.processLlmRequest(toolContext, llmRequest);
     const skills = Object.values(this.skills);
     const skillsXml = formatSkillsAsXml(skills);
-    appendInstructions(llmRequest, [
-      DEFAULT_SKILL_SYSTEM_INSTRUCTION,
-      skillsXml
-    ]);
+    const instructions = [DEFAULT_SKILL_SYSTEM_INSTRUCTION, skillsXml];
+    if (this.registry) {
+      instructions.push(
+        "\nIf the locally available skills are not sufficient to complete your task, you can use the `search_skills` tool to discover additional skills from the registry."
+      );
+    }
+    appendInstructions(llmRequest, instructions);
   }
   async resolveAdditionalTools(context) {
     if (!context) return [];
@@ -85,7 +120,7 @@ let SkillToolset = class extends BaseToolset {
     }
     const additionalToolNames = /* @__PURE__ */ new Set();
     for (const skillName of activatedSkills) {
-      const skill = this.skills[skillName];
+      const skill = await this.getOrFetchSkill(skillName, context.invocationId);
       if (skill && skill.frontmatter.metadata) {
         const tools = skill.frontmatter.metadata["adk_additional_tools"];
         if (tools) {

package/dist/esm/tools/vertex_rag_retrieval_tool.js

@@ -0,0 +1,36 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseTool } from "./base_tool.js";
+class VertexRagRetrievalTool extends BaseTool {
+  constructor(config) {
+    super({
+      name: "vertex_rag_retrieval",
+      description: "Vertex AI RAG Retrieval Tool"
+    });
+    this.vertexRagStore = config;
+  }
+  /**
+   * This tool is executed server-side by the Vertex AI RAG Engine.
+   * Local execution is not required.
+   */
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    llmRequest.config = llmRequest.config || {};
+    llmRequest.config.tools = llmRequest.config.tools || [];
+    llmRequest.config.tools.push({
+      retrieval: { vertexRagStore: this.vertexRagStore }
+    });
+  }
+}
+export {
+  VertexRagRetrievalTool
+};

package/dist/esm/utils/async_queue.js

@@ -0,0 +1,60 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class AsyncQueue {
+  constructor() {
+    this.queue = [];
+    this.resolvers = [];
+    this.closed = false;
+  }
+  push(value) {
+    if (this.closed) return;
+    if (this.resolvers.length > 0) {
+      const { resolve } = this.resolvers.shift();
+      resolve({ value, done: false });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  error(err) {
+    this.errorVal = err;
+    while (this.resolvers.length > 0) {
+      const { reject } = this.resolvers.shift();
+      reject(err);
+    }
+  }
+  close() {
+    this.closed = true;
+    while (this.resolvers.length > 0) {
+      const { resolve } = this.resolvers.shift();
+      resolve({ value: void 0, done: true });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.errorVal) {
+          const err = this.errorVal;
+          this.errorVal = void 0;
+          return Promise.reject(err);
+        }
+        if (this.queue.length > 0) {
+          return Promise.resolve({ value: this.queue.shift(), done: false });
+        }
+        if (this.closed) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve, reject) => {
+          this.resolvers.push({ resolve, reject });
+        });
+      }
+    };
+  }
+}
+export {
+  AsyncQueue
+};

package/dist/esm/utils/case_utils.js

@@ -0,0 +1,25 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function camelCaseKeys(val) {
+  if (Array.isArray(val)) {
+    return val.map(camelCaseKeys);
+  }
+  if (val !== null && typeof val === "object" && val.constructor === Object) {
+    const obj = val;
+    const newObj = {};
+    for (const key of Object.keys(obj)) {
+      const camelKey = key.replace(/_([a-z])/g, (_, g) => g.toUpperCase());
+      newObj[camelKey] = camelCaseKeys(obj[key]);
+    }
+    return newObj;
+  }
+  return val;
+}
+export {
+  camelCaseKeys
+};

package/dist/esm/utils/env_aware_utils.js

@@ -10,6 +10,10 @@ function isBrowser() {
 }
 const UUID_MASK = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
 function randomUUID() {
+  var _a;
+  if ((_a = globalThis.crypto) == null ? void 0 : _a.randomUUID) {
+    return globalThis.crypto.randomUUID();
+  }
   let uuid = "";
   for (let i = 0; i < UUID_MASK.length; i++) {
     const randomValue = Math.random() * 16 | 0;

package/dist/esm/utils/file_utils.js

@@ -51,6 +51,32 @@ async function materializeFiles(files, dir = process.cwd()) {
   }
   return createdFiles;
 }
+const EXTENSION_TO_MIME_TYPE = {
+  "pdf": "application/pdf",
+  "jpg": "image/jpeg",
+  "jpeg": "image/jpeg",
+  "png": "image/png",
+  "gif": "image/gif",
+  "csv": "text/csv",
+  "json": "application/json",
+  "xml": "application/xml",
+  "sh": "text/x-shellscript",
+  "bash": "text/x-shellscript",
+  "py": "text/x-python",
+  "js": "text/javascript",
+  "cjs": "text/javascript",
+  "mjs": "text/javascript",
+  "ts": "text/javascript",
+  "cts": "text/javascript",
+  "mts": "text/javascript"
+};
+function guessMimeType(filePath) {
+  var _a;
+  const ext = ((_a = filePath.split(".").pop()) == null ? void 0 : _a.toLowerCase()) || "";
+  return EXTENSION_TO_MIME_TYPE[ext] || "application/octet-stream";
+}
 export {
+  EXTENSION_TO_MIME_TYPE,
+  guessMimeType,
   materializeFiles
 };

package/dist/esm/utils/gemini_schema_util.js

@@ -81,6 +81,21 @@ function toGeminiSchema(mcpSchema) {
         mcp.type = "array";
       } else if (isNullable) {
         mcp.type = "null";
+      } else if (mcp.enum) {
+        const enumTypes = new Set(mcp.enum.map((v) => typeof v));
+        if (enumTypes.size === 1) {
+          const jsType = [...enumTypes][0];
+          if (jsType === "string") mcp.type = "string";
+          else if (jsType === "number") mcp.type = "number";
+          else if (jsType === "boolean") mcp.type = "boolean";
+        }
+      } else if (mcp.const !== void 0) {
+        const jsType = typeof mcp.const;
+        let inferredType;
+        if (jsType === "string") inferredType = "string";
+        else if (jsType === "number") inferredType = "number";
+        else if (jsType === "boolean") inferredType = "boolean";
+        mcp = { ...mcp, type: inferredType, enum: [mcp.const] };
       }
     }
     const geminiType = toGeminiType(mcp.type);
@@ -95,6 +110,9 @@ function toGeminiSchema(mcpSchema) {
     if (mcp.description) {
       geminiSchema.description = mcp.description;
     }
+    if (mcp.enum) {
+      geminiSchema.enum = mcp.enum.map(String);
+    }
     if (isNullable && mcp.type !== "null") {
       geminiSchema.nullable = true;
     }

package/dist/esm/utils/live_connection_utils.js

@@ -0,0 +1,256 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isGemini3xFlashLive } from "./model_name.js";
+class LiveResponseAggregator {
+  constructor(modelVersion) {
+    this.modelVersion = modelVersion;
+    this.text = "";
+    this.isThought = false;
+    this.toolCallParts = [];
+    this.pendingGroundingMetadata = void 0;
+    this.inputTranscriptionText = "";
+    this.outputTranscriptionText = "";
+  }
+  *processMessage(message) {
+    if (message.usageMetadata) {
+      yield {
+        usageMetadata: message.usageMetadata,
+        ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+      };
+    }
+    if (message.serverContent) {
+      const serverContent = message.serverContent;
+      const content = serverContent.modelTurn;
+      if (serverContent.groundingMetadata) {
+        this.pendingGroundingMetadata = serverContent.groundingMetadata;
+      }
+      if (!(content && content.parts) && serverContent.groundingMetadata && !serverContent.turnComplete) {
+        yield {
+          groundingMetadata: serverContent.groundingMetadata,
+          ...serverContent.interrupted !== void 0 ? { interrupted: serverContent.interrupted } : {},
+          ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+        };
+      }
+      if (content && content.parts) {
+        const llmResponse = {
+          content,
+          ...serverContent.interrupted !== void 0 ? { interrupted: serverContent.interrupted } : {},
+          ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+        };
+        if (!serverContent.turnComplete && serverContent.groundingMetadata) {
+          llmResponse.groundingMetadata = serverContent.groundingMetadata;
+        }
+        const hasInlineData = content.parts.some((p) => p.inlineData);
+        for (const part of content.parts) {
+          if (part.text) {
+            const currentIsThought = !!part.thought;
+            if (this.text && currentIsThought !== this.isThought) {
+              yield this.buildFullTextResponse(this.text, this.isThought);
+              this.text = "";
+              this.isThought = false;
+            }
+            this.text += part.text;
+            this.isThought = currentIsThought;
+            llmResponse.partial = true;
+          }
+        }
+        if (this.text && !content.parts.some((p) => p.text) && !hasInlineData) {
+          yield this.buildFullTextResponse(this.text, this.isThought);
+          this.text = "";
+          this.isThought = false;
+        }
+        yield llmResponse;
+      }
+      if (serverContent.inputTranscription) {
+        if (serverContent.inputTranscription.text) {
+          this.inputTranscriptionText += serverContent.inputTranscription.text;
+          yield {
+            inputTranscription: {
+              text: serverContent.inputTranscription.text,
+              finished: false
+            },
+            partial: true,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+        }
+        if (serverContent.inputTranscription.finished) {
+          yield {
+            inputTranscription: {
+              text: this.inputTranscriptionText,
+              finished: true
+            },
+            partial: false,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+          this.inputTranscriptionText = "";
+        }
+      }
+      if (serverContent.outputTranscription) {
+        if (serverContent.outputTranscription.text) {
+          this.outputTranscriptionText += serverContent.outputTranscription.text;
+          yield {
+            outputTranscription: {
+              text: serverContent.outputTranscription.text,
+              finished: false
+            },
+            partial: true,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+        }
+        if (serverContent.outputTranscription.finished) {
+          yield {
+            outputTranscription: {
+              text: this.outputTranscriptionText,
+              finished: true
+            },
+            partial: false,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+          this.outputTranscriptionText = "";
+        }
+      }
+      if (serverContent.interrupted || serverContent.turnComplete || serverContent.generationComplete) {
+        if (this.inputTranscriptionText) {
+          yield {
+            inputTranscription: {
+              text: this.inputTranscriptionText,
+              finished: true
+            },
+            partial: false,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+          this.inputTranscriptionText = "";
+        }
+        if (this.outputTranscriptionText) {
+          yield {
+            outputTranscription: {
+              text: this.outputTranscriptionText,
+              finished: true
+            },
+            partial: false,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+          this.outputTranscriptionText = "";
+        }
+      }
+      if (serverContent.turnComplete) {
+        let gMetadataToYield = this.pendingGroundingMetadata;
+        if (this.text) {
+          yield this.buildFullTextResponse(
+            this.text,
+            this.isThought,
+            gMetadataToYield
+          );
+          this.text = "";
+          this.isThought = false;
+          gMetadataToYield = void 0;
+        }
+        if (this.toolCallParts.length > 0) {
+          yield {
+            content: { role: "model", parts: this.toolCallParts },
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+          this.toolCallParts = [];
+        }
+        const finalResponse = {
+          turnComplete: true,
+          ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+        };
+        if (serverContent.interrupted !== void 0) {
+          finalResponse.interrupted = serverContent.interrupted;
+        }
+        const finalGrounding = serverContent.groundingMetadata || gMetadataToYield;
+        if (finalGrounding !== void 0 && finalGrounding !== null) {
+          finalResponse.groundingMetadata = finalGrounding;
+        }
+        yield finalResponse;
+      }
+      if (serverContent.interrupted) {
+        if (this.text) {
+          yield this.buildFullTextResponse(this.text, this.isThought);
+          this.text = "";
+          this.isThought = false;
+        } else {
+          yield {
+            interrupted: serverContent.interrupted,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+        }
+      }
+    }
+    if (message.toolCall) {
+      if (this.text) {
+        yield this.buildFullTextResponse(this.text, this.isThought);
+        this.text = "";
+        this.isThought = false;
+      }
+      if (message.toolCall.functionCalls) {
+        this.toolCallParts.push(
+          ...message.toolCall.functionCalls.map((fc) => ({
+            functionCall: fc
+          }))
+        );
+      }
+      const isGemini3x = isGemini3xFlashLive(this.modelVersion);
+      if (isGemini3x && this.toolCallParts.length > 0) {
+        yield {
+          content: { role: "model", parts: this.toolCallParts },
+          ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+        };
+        this.toolCallParts = [];
+      }
+    }
+    if (message.sessionResumptionUpdate) {
+      yield {
+        liveSessionResumptionUpdate: message.sessionResumptionUpdate,
+        ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+      };
+    }
+    if (message.goAway) {
+      yield {
+        goAway: message.goAway,
+        ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+      };
+    }
+  }
+  /**
+   * Flushes any remaining aggregated components when the connection is closed.
+   */
+  *close() {
+    if (this.toolCallParts.length > 0) {
+      yield {
+        content: { role: "model", parts: this.toolCallParts },
+        ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+      };
+      this.toolCallParts = [];
+    }
+  }
+  buildFullTextResponse(text, isThought, groundingMetadata) {
+    const part = { text };
+    if (isThought) {
+      part.thought = true;
+    }
+    const response = {
+      content: {
+        role: "model",
+        parts: [part]
+      },
+      partial: false
+    };
+    if (groundingMetadata !== void 0 && groundingMetadata !== null) {
+      response.groundingMetadata = groundingMetadata;
+    }
+    if (this.modelVersion) {
+      response.modelVersion = this.modelVersion;
+    }
+    return response;
+  }
+}
+export {
+  LiveResponseAggregator
+};