@google/adk 1.1.0 → 1.3.0

package/dist/esm/sessions/vertex_ai_session_service.js

@@ -0,0 +1,405 @@
+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 { Client } from "@google-cloud/vertexai/build/src/genai/client.js";
+import { isCompactedEvent } from "../events/compacted_event.js";
+import { experimental } from "../utils/experimental.js";
+import { logger } from "../utils/logger.js";
+import { getExpressModeApiKey } from "../utils/vertex_ai_utils.js";
+import { partialCopy } from "../utils/partial_copy.js";
+import {
+  BaseSessionService,
+  trimTempState
+} from "./base_session_service.js";
+import { createSession } from "./session.js";
+const DEFAULT_MAX_ATTEMPTS = 30;
+const GRPC_NOT_FOUND = 5;
+const HTTP_NOT_FOUND = 404;
+function isVertexAiConnectionString(uri) {
+  return (uri == null ? void 0 : uri.startsWith("vertexai://")) || false;
+}
+let VertexAiSessionService = class extends BaseSessionService {
+  constructor(options) {
+    super();
+    this.agentEngineId = options.agentEngineId;
+    this.projectId = options.projectId;
+    this.location = options.location;
+    this.expressModeApiKey = getExpressModeApiKey(
+      this.projectId,
+      this.location,
+      options.expressModeApiKey
+    );
+    if (!options.sessions) {
+      if (!this.expressModeApiKey && (!this.projectId || !this.location)) {
+        throw new Error(
+          "Either (Project ID and Location) or an expressModeApiKey is required."
+        );
+      }
+    }
+    if (options.sessions) {
+      this.sessions = options.sessions;
+    } else {
+      const client = new Client({
+        project: this.projectId,
+        location: this.location
+      });
+      this.sessions = client.agentEnginesInternal.sessions;
+    }
+  }
+  getReasoningEngineId(appName) {
+    if (this.agentEngineId) {
+      return this.agentEngineId;
+    }
+    if (/^\d+$/.test(appName)) {
+      return appName;
+    }
+    const pattern = /^projects\/([a-zA-Z0-9-_]+)\/locations\/([a-zA-Z0-9-_]+)\/reasoningEngines\/(\d+)$/;
+    const match = appName.match(pattern);
+    if (!match) {
+      throw new Error(
+        `App name ${appName} is not valid. It should either be the full ReasoningEngine resource name, or the reasoning engine id.`
+      );
+    }
+    return match[3];
+  }
+  async createSession({
+    appName,
+    userId,
+    state,
+    sessionId
+  }) {
+    var _a;
+    const reasoningEngineId = this.getReasoningEngineId(appName);
+    const filteredState = state ? trimTempState(state) : void 0;
+    let apiResponse = await this.sessions.createInternal({
+      name: `reasoningEngines/${reasoningEngineId}`,
+      userId,
+      config: {
+        ...filteredState ? { sessionState: filteredState } : {},
+        ...sessionId ? { sessionId } : {}
+      }
+    });
+    const operationName = apiResponse.name;
+    let attempts = 0;
+    while (!apiResponse.done && attempts < DEFAULT_MAX_ATTEMPTS) {
+      const [nextResponse] = await Promise.all([
+        this.sessions.getSessionOperationInternal({
+          operationName
+        }),
+        new Promise((resolve) => setTimeout(resolve, 1e3))
+      ]);
+      apiResponse = nextResponse;
+      attempts++;
+    }
+    if (!apiResponse.done) {
+      throw new Error(
+        `Session creation operation ${operationName} did not complete in time.`
+      );
+    }
+    const getSessionResponse = apiResponse.response;
+    const id = ((_a = getSessionResponse.name) == null ? void 0 : _a.split("/").pop()) || "";
+    return createSession({
+      id,
+      appName,
+      userId,
+      state: getSessionResponse.sessionState,
+      events: [],
+      lastUpdateTime: getSessionResponse.updateTime ? Date.parse(getSessionResponse.updateTime) : Date.now()
+    });
+  }
+  async getSession({
+    appName,
+    userId,
+    sessionId,
+    config
+  }) {
+    const reasoningEngineId = this.getReasoningEngineId(appName);
+    const sessionResourceName = `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}`;
+    try {
+      let getSessionResponse;
+      let eventsIterator = [];
+      if (config && config.numRecentEvents === 0) {
+        getSessionResponse = await this.sessions.get({
+          name: sessionResourceName
+        });
+      } else {
+        const listConfig = {};
+        if (config && config.afterTimestamp) {
+          listConfig.filter = `timestamp>="${new Date(
+            config.afterTimestamp
+          ).toISOString()}"`;
+        }
+        const [sessionRes, eventsRes] = await Promise.all([
+          this.sessions.get({ name: sessionResourceName }),
+          this.sessions.events.listInternal({
+            name: sessionResourceName,
+            config: listConfig
+          })
+        ]);
+        getSessionResponse = sessionRes;
+        eventsIterator = eventsRes.sessionEvents || [];
+      }
+      const sessionObj = getSessionResponse;
+      if (sessionObj.userId !== userId) {
+        throw new Error(
+          `Session ${sessionId} does not belong to user ${userId}.`
+        );
+      }
+      const session = createSession({
+        id: sessionId,
+        appName,
+        userId,
+        state: sessionObj.sessionState,
+        events: [],
+        lastUpdateTime: sessionObj.updateTime ? Date.parse(sessionObj.updateTime) : Date.now()
+      });
+      for (const event of eventsIterator) {
+        session.events.push(_fromApiEvent(event));
+      }
+      if (config && config.numRecentEvents) {
+        session.events = session.events.slice(-config.numRecentEvents);
+      }
+      return session;
+    } catch (error) {
+      const err = error;
+      if (err.code === GRPC_NOT_FOUND || err.code === HTTP_NOT_FOUND) {
+        return void 0;
+      }
+      logger.error(`Error getting session from Vertex AI: ${err.message}`);
+      throw error;
+    }
+  }
+  async listSessions({
+    appName,
+    userId,
+    limit,
+    offset,
+    page,
+    order
+  }) {
+    var _a;
+    const reasoningEngineId = this.getReasoningEngineId(appName);
+    const adkSessions = [];
+    let pageToken = void 0;
+    do {
+      const response = await this.sessions.listInternal({
+        name: `reasoningEngines/${reasoningEngineId}`,
+        config: {
+          ...userId ? { filter: `user_id="${userId}"` } : {},
+          ...pageToken ? { pageToken } : {}
+        }
+      });
+      const sessions = response.sessions || [];
+      for (const sessionObj of sessions) {
+        const id = ((_a = sessionObj.name) == null ? void 0 : _a.split("/").pop()) || "";
+        adkSessions.push(
+          createSession({
+            id,
+            appName,
+            userId: sessionObj.userId,
+            state: sessionObj.sessionState,
+            events: [],
+            lastUpdateTime: sessionObj.updateTime ? new Date(sessionObj.updateTime).getTime() : Date.now()
+          })
+        );
+      }
+      pageToken = response.nextPageToken;
+    } while (pageToken);
+    if (order === "asc") {
+      adkSessions.sort(
+        (a, b) => a.lastUpdateTime - b.lastUpdateTime || a.id.localeCompare(b.id)
+      );
+    } else if (order === "desc") {
+      adkSessions.sort(
+        (a, b) => b.lastUpdateTime - a.lastUpdateTime || a.id.localeCompare(b.id)
+      );
+    }
+    if (limit === void 0) {
+      const totalItems2 = adkSessions.length;
+      const sliced = offset ? adkSessions.slice(offset) : adkSessions;
+      return {
+        sessions: sliced,
+        page: 1,
+        limit: totalItems2,
+        totalItems: totalItems2,
+        totalPages: totalItems2 === 0 ? 0 : 1
+      };
+    }
+    const totalItems = adkSessions.length;
+    const totalPages = limit === 0 ? 0 : Math.ceil(totalItems / limit);
+    let effectiveOffset;
+    let effectivePage;
+    if (page !== void 0) {
+      effectiveOffset = (page - 1) * limit;
+      effectivePage = page;
+    } else {
+      effectiveOffset = offset != null ? offset : 0;
+      effectivePage = limit === 0 ? 1 : Math.floor(effectiveOffset / limit) + 1;
+    }
+    return {
+      sessions: adkSessions.slice(effectiveOffset, effectiveOffset + limit),
+      page: effectivePage,
+      limit,
+      totalItems,
+      totalPages
+    };
+  }
+  async deleteSession({
+    appName,
+    userId: _userId,
+    sessionId
+  }) {
+    const reasoningEngineId = this.getReasoningEngineId(appName);
+    await this.sessions.delete({
+      name: `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}`
+    });
+  }
+  async appendEvent({
+    session,
+    event
+  }) {
+    await super.appendEvent({ session, event });
+    session.lastUpdateTime = event.timestamp;
+    const reasoningEngineId = this.getReasoningEngineId(session.appName);
+    const customMetadata = { ...event.customMetadata };
+    if (isCompactedEvent(event)) {
+      customMetadata._compaction = {
+        startTime: event.startTime,
+        endTime: event.endTime,
+        compactedContent: event.compactedContent
+      };
+    }
+    if (event.usageMetadata) {
+      customMetadata._usage_metadata = event.usageMetadata;
+    }
+    const config = partialCopy(event, [
+      "content",
+      "actions",
+      "errorCode",
+      "errorMessage"
+    ]);
+    config.eventMetadata = {
+      ...partialCopy(event, [
+        "partial",
+        "turnComplete",
+        "interrupted",
+        "branch",
+        "longRunningToolIds",
+        "groundingMetadata"
+      ]),
+      customMetadata: Object.keys(customMetadata).length > 0 ? customMetadata : void 0
+    };
+    config.rawEvent = JSON.parse(JSON.stringify(event));
+    const params = {
+      name: `reasoningEngines/${reasoningEngineId}/sessions/${session.id}`,
+      author: event.author || "user",
+      invocationId: event.invocationId || `inv-${Date.now()}`,
+      timestamp: new Date(event.timestamp).toISOString(),
+      config
+    };
+    try {
+      await this.sessions.events.append(params);
+    } catch (error) {
+      logger.warn(
+        "Failed to append event with rawEvent, falling back...",
+        error
+      );
+      delete config.rawEvent;
+      await this.sessions.events.append({
+        name: `reasoningEngines/${reasoningEngineId}/sessions/${session.id}`,
+        author: event.author || "user",
+        invocationId: event.invocationId || `inv-${Date.now()}`,
+        timestamp: new Date(event.timestamp).toISOString(),
+        config
+      });
+    }
+    return event;
+  }
+};
+VertexAiSessionService = __decorateClass([
+  experimental
+], VertexAiSessionService);
+function _fromApiEvent(apiEventObj) {
+  var _a, _b, _c;
+  const rawEvent = apiEventObj.rawEvent;
+  if (rawEvent) {
+    const event2 = JSON.parse(JSON.stringify(rawEvent));
+    event2.id = ((_a = apiEventObj.name) == null ? void 0 : _a.split("/").pop()) || "";
+    event2.invocationId = apiEventObj.invocationId || "";
+    event2.author = apiEventObj.author;
+    if (apiEventObj.timestamp) {
+      event2.timestamp = new Date(apiEventObj.timestamp).getTime();
+    }
+    return event2;
+  }
+  const actions = apiEventObj.actions || {};
+  const eventMetadata = apiEventObj.eventMetadata || {};
+  let customMetadata = eventMetadata.customMetadata;
+  let compactionData = null;
+  let usageMetadataData = null;
+  if (customMetadata) {
+    if (customMetadata._compaction) {
+      compactionData = customMetadata._compaction;
+      delete customMetadata._compaction;
+    }
+    if (customMetadata._usage_metadata) {
+      usageMetadataData = customMetadata._usage_metadata;
+      delete customMetadata._usage_metadata;
+    }
+    if (Object.keys(customMetadata).length === 0) {
+      customMetadata = void 0;
+    }
+  }
+  const eventActions = {
+    stateDelta: actions["stateDelta"] || {},
+    artifactDelta: actions["artifactDelta"] || {},
+    requestedAuthConfigs: actions.requestedAuthConfigs || {},
+    requestedToolConfirmations: actions["requestedToolConfirmations"] || {},
+    skipSummarization: actions["skipSummarization"],
+    transferToAgent: actions["transferAgent"],
+    escalate: actions["escalate"],
+    compaction: compactionData || void 0
+  };
+  const event = {
+    id: ((_b = apiEventObj.name) == null ? void 0 : _b.split("/").pop()) || "",
+    invocationId: apiEventObj.invocationId || "",
+    author: apiEventObj.author,
+    actions: eventActions,
+    content: apiEventObj.content,
+    timestamp: apiEventObj.timestamp ? new Date(apiEventObj.timestamp).getTime() : Date.now(),
+    errorCode: (_c = apiEventObj.errorCode) == null ? void 0 : _c.toString(),
+    errorMessage: apiEventObj.errorMessage,
+    partial: eventMetadata["partial"],
+    turnComplete: eventMetadata["turnComplete"],
+    interrupted: eventMetadata["interrupted"],
+    branch: eventMetadata["branch"],
+    customMetadata,
+    longRunningToolIds: eventMetadata["longRunningToolIds"],
+    usageMetadata: usageMetadataData
+  };
+  if (compactionData) {
+    event.isCompacted = true;
+    event.startTime = compactionData.startTime;
+    event.endTime = compactionData.endTime;
+    event.compactedContent = compactionData.compactedContent;
+  }
+  return event;
+}
+export {
+  VertexAiSessionService,
+  isVertexAiConnectionString
+};

package/dist/esm/skills/gcp_skill_registry.js

@@ -0,0 +1,78 @@
+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 { Client } from "@google-cloud/vertexai";
+import { experimental } from "../utils/experimental.js";
+import { loadSkillFromZipBuffer } from "./loader.js";
+let GCPSkillRegistry = class {
+  constructor(options = {}) {
+    this.projectId = options.projectId || process.env.GOOGLE_CLOUD_PROJECT;
+    this.location = options.location || process.env.GOOGLE_CLOUD_LOCATION;
+    this.client = options.client || new Client({
+      project: this.projectId,
+      location: this.location
+    });
+  }
+  async getSkill(name) {
+    const apiClient = this.client.apiClient;
+    const httpResponse = await apiClient.request({
+      path: `skills/${name}`,
+      httpMethod: "GET",
+      httpOptions: { apiVersion: "v1beta1" }
+    });
+    const response = await httpResponse.json();
+    const zippedFilesystem = response.zippedFilesystem || response.zipped_filesystem;
+    if (!zippedFilesystem) {
+      throw new Error(`Skill '${name}' does not contain zipped filesystem.`);
+    }
+    const zipBuffer = Buffer.from(zippedFilesystem, "base64");
+    return loadSkillFromZipBuffer(zipBuffer);
+  }
+  async searchSkills(query) {
+    const apiClient = this.client.apiClient;
+    const trimmedQuery = query.trim();
+    const isSearch = trimmedQuery.length > 0;
+    const path = isSearch ? `skills:retrieve?query=${encodeURIComponent(trimmedQuery)}` : "skills";
+    const httpResponse = await apiClient.request({
+      path,
+      httpMethod: "GET",
+      httpOptions: { apiVersion: "v1beta1" }
+    });
+    const response = await httpResponse.json();
+    const skillsList = isSearch ? response.retrievedSkills || response.retrieved_skills : response.skills;
+    const results = [];
+    if (skillsList && Array.isArray(skillsList)) {
+      for (const s of skillsList) {
+        const skillNameStr = s.skillName || s.skill_name || s.name || "";
+        const descriptionStr = s.description || "";
+        const parts = skillNameStr.split("/");
+        const name = skillNameStr ? parts[parts.length - 1] : "";
+        results.push({
+          name,
+          description: descriptionStr
+        });
+      }
+    }
+    return results;
+  }
+};
+GCPSkillRegistry = __decorateClass([
+  experimental
+], GCPSkillRegistry);
+export {
+  GCPSkillRegistry
+};

package/dist/esm/skills/loader.js

@@ -5,6 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import AdmZip from "adm-zip";
 import yaml from "js-yaml";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
@@ -236,9 +237,72 @@ async function loadAllSkillsInDir(skillsBasePath) {
   }
   return skills;
 }
+function loadSkillFromZipBuffer(zipBuffer) {
+  const zip = new AdmZip(zipBuffer);
+  const entries = zip.getEntries();
+  let skillMdContent = "";
+  for (const entry of entries) {
+    if (entry.isDirectory) continue;
+    if (entry.entryName.toLowerCase() === "skill.md") {
+      skillMdContent = entry.getData().toString("utf-8");
+      break;
+    }
+  }
+  if (!skillMdContent) {
+    throw new Error("SKILL.md not found in zipped filesystem.");
+  }
+  const { frontmatter: parsed, body } = parseSkillMdContent(skillMdContent);
+  const frontmatter = FrontmatterSchema.parse(parsed);
+  const references = {};
+  const assets = {};
+  const scripts = {};
+  function loadZipDir(prefix) {
+    const res = {};
+    const normPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+    for (const entry of entries) {
+      if (entry.isDirectory) continue;
+      if (entry.entryName.startsWith(normPrefix)) {
+        if (entry.entryName.includes("__pycache__")) continue;
+        const relativePath = entry.entryName.substring(normPrefix.length);
+        if (!relativePath) continue;
+        const data = entry.getData();
+        try {
+          res[relativePath] = data.toString("utf-8");
+        } catch (_e) {
+          res[relativePath] = data;
+        }
+      }
+    }
+    return res;
+  }
+  const refFiles = loadZipDir("references");
+  for (const [key, val] of Object.entries(refFiles)) {
+    references[key] = val;
+  }
+  const assetFiles = loadZipDir("assets");
+  for (const [key, val] of Object.entries(assetFiles)) {
+    assets[key] = val;
+  }
+  const rawScripts = loadZipDir("scripts");
+  for (const [key, val] of Object.entries(rawScripts)) {
+    if (typeof val === "string") {
+      scripts[key] = { src: val };
+    }
+  }
+  return {
+    frontmatter,
+    instructions: body,
+    resources: {
+      references,
+      assets,
+      scripts
+    }
+  };
+}
 export {
   loadAllSkillsInDir,
   loadSkillFromDir,
+  loadSkillFromZipBuffer,
   parseSkillMdContent,
   validateSkillDir
 };

package/dist/esm/skills/skill_registry.js

@@ -0,0 +1,7 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/esm/tools/agent_tool.js

@@ -12,6 +12,7 @@ import { InMemoryMemoryService } from "../memory/in_memory_memory_service.js";
 import { Runner } from "../runner/runner.js";
 import { InMemorySessionService } from "../sessions/in_memory_session_service.js";
 import { GoogleLLMVariant } from "../utils/variant_utils.js";
+import { State } from "../sessions/state.js";
 import { BaseTool } from "./base_tool.js";
 import { ForwardingArtifactService } from "./forwarding_artifact_service.js";
 const AGENT_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.agentTool");
@@ -66,9 +67,6 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
     toolContext
   }) {
     var _a2, _b2, _c, _d, _e, _f;
-    if (this.skipSummarization) {
-      toolContext.actions.skipSummarization = true;
-    }
     const hasInputSchema = isLlmAgent(this.agent) && this.agent.inputSchema;
     const content = {
       role: "user",
@@ -108,7 +106,14 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
         return;
       }
       if (event.actions.stateDelta) {
-        toolContext.state.update(event.actions.stateDelta);
+        const filteredDelta = Object.fromEntries(
+          Object.entries(event.actions.stateDelta).filter(
+            ([key]) => !key.startsWith(State.TEMP_PREFIX)
+          )
+        );
+        if (Object.keys(filteredDelta).length > 0) {
+          toolContext.state.update(filteredDelta);
+        }
       }
       lastEvent = event;
     }
@@ -116,7 +121,7 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
       return "";
     }
     const hasOutputSchema = isLlmAgent(this.agent) && this.agent.outputSchema;
-    const mergedText = lastEvent.content.parts.map((part) => part.text).filter((text) => text).join("\n");
+    const mergedText = lastEvent.content.parts.filter((part) => !part.thought).map((part) => part.text).filter((text) => text).join("\n");
     return hasOutputSchema ? JSON.parse(mergedText) : mergedText;
   }
 }

package/dist/esm/tools/exit_loop_tool.js

@@ -7,18 +7,27 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import { BaseTool } from "./base_tool.js";
 class ExitLoopTool extends BaseTool {
+  /** Creates an ExitLoopTool with its fixed name and description. */
   constructor() {
     super({
       name: "exit_loop",
       description: "Exits the loop.\n\nCall this function only when you are instructed to do so."
     });
   }
+  /** Returns the function declaration for this tool. */
   _getDeclaration() {
     return {
       name: this.name,
       description: this.description
     };
   }
+  /**
+   * Sets `escalate` and `skipSummarization` on the event actions, signalling
+   * the {@link LoopAgent} to stop iterating.
+   *
+   * @param request The tool request containing the current tool context.
+   * @returns An empty string response.
+   */
   async runAsync({
     toolContext
   }) {

package/dist/esm/tools/function_tool.js

@@ -46,7 +46,8 @@ class FunctionTool extends (_b = BaseTool, _a = FUNCTION_TOOL_SIGNATURE_SYMBOL,
     this.parameters = options.parameters;
   }
   /**
-   * Provide a schema for the function.
+   * Returns the function declaration derived from the tool's name, description,
+   * and parameter schema.
    */
   _getDeclaration() {
     return {
@@ -56,7 +57,11 @@ class FunctionTool extends (_b = BaseTool, _a = FUNCTION_TOOL_SIGNATURE_SYMBOL,
     };
   }
   /**
-   * Logic for running the tool.
+   * Validates the model-provided arguments against the parameter schema and
+   * invokes the user-defined `execute` function.
+   *
+   * @param req The tool request containing arguments and tool context.
+   * @returns A promise resolving to the function's return value.
    */
   async runAsync(req) {
     try {