@google/adk 1.5.0 → 1.6.0

package/dist/esm/tools/get_user_choice_tool.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
+ */
+import { z } from "zod";
+import { LongRunningFunctionTool } from "./long_running_tool.js";
+const getUserChoiceTool = new LongRunningFunctionTool({
+  name: "get_user_choice",
+  description: "Presents a list of options to the user and awaits their selection.",
+  parameters: z.object({
+    options: z.array(z.string()).describe("List of options to present to the user.")
+  }),
+  execute: async (input, context) => {
+    if (context) {
+      context.actions.skipSummarization = true;
+    }
+    return null;
+  }
+});
+export {
+  getUserChoiceTool
+};

package/dist/esm/tools/mcp/mcp_session_manager.js

@@ -12,6 +12,11 @@ import {
 import {
   StreamableHTTPClientTransport
 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { formatError } from "../../utils/error_utils.js";
+import { logger } from "../../utils/logger.js";
+function logTransportError(err) {
+  logger.error("MCP transport error: " + formatError(err));
+}
 class MCPSessionManager {
   constructor(connectionParams) {
     this.activeSessions = /* @__PURE__ */ new Set();
@@ -20,31 +25,40 @@ class MCPSessionManager {
   async createSession() {
     var _a;
     const client = new Client({ name: "MCPClient", version: "1.0.0" });
-    switch (this.connectionParams.type) {
-      case "StdioConnectionParams":
-        await client.connect(
-          new StdioClientTransport(this.connectionParams.serverParams)
-        );
-        break;
-      case "StreamableHTTPConnectionParams": {
-        const options = (_a = this.connectionParams.transportOptions) != null ? _a : {};
-        if (!options.requestInit && this.connectionParams.header !== void 0) {
-          options.requestInit = {
-            headers: this.connectionParams.header
-          };
+    try {
+      switch (this.connectionParams.type) {
+        case "StdioConnectionParams": {
+          const transport = new StdioClientTransport(
+            this.connectionParams.serverParams
+          );
+          transport.onerror = logTransportError;
+          await client.connect(transport);
+          break;
         }
-        await client.connect(
-          new StreamableHTTPClientTransport(
+        case "StreamableHTTPConnectionParams": {
+          const options = (_a = this.connectionParams.transportOptions) != null ? _a : {};
+          if (!options.requestInit && this.connectionParams.header !== void 0) {
+            options.requestInit = {
+              headers: this.connectionParams.header
+            };
+          }
+          const transport = new StreamableHTTPClientTransport(
             new URL(this.connectionParams.url),
             options
-          )
-        );
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = this.connectionParams;
-        break;
+          );
+          transport.onerror = logTransportError;
+          await client.connect(transport);
+          break;
+        }
+        default: {
+          const _exhaustiveCheck = this.connectionParams;
+          break;
+        }
       }
+    } catch (err) {
+      throw new Error("Failed to create MCP session: " + formatError(err), {
+        cause: err
+      });
     }
     this.activeSessions.add(client);
     return client;

package/dist/esm/tools/request_input_tool.js

@@ -0,0 +1,26 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from "zod";
+import { LongRunningFunctionTool } from "./long_running_tool.js";
+const requestInputTool = new LongRunningFunctionTool({
+  name: "adk_request_input",
+  description: "Presents a custom message to the user and awaits unstructured or structured input.",
+  parameters: z.object({
+    message: z.string().describe("The prompt for the user."),
+    responseSchema: z.record(z.string(), z.unknown()).optional().describe("Expected schema of the response.")
+  }),
+  execute: async (input, context) => {
+    if (context) {
+      context.actions.skipSummarization = true;
+    }
+    return null;
+  }
+});
+export {
+  requestInputTool
+};

package/dist/esm/utils/crypto_shim.js

@@ -0,0 +1,15 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function randomUUID() {
+  throw new Error(
+    "randomUUID: no cryptographically secure source of randomness is available. Neither crypto.randomUUID() nor crypto.getRandomValues() is present in this environment."
+  );
+}
+export {
+  randomUUID
+};

package/dist/esm/utils/env_aware_utils.js

@@ -5,27 +5,29 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { randomUUID as nodeRandomUUID } from "node:crypto";
 function isBrowser() {
   return typeof window !== "undefined";
 }
-const UUID_MASK = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
 function randomUUID() {
-  var _a;
+  var _a, _b;
   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;
-    if (UUID_MASK[i] === "x") {
-      uuid += randomValue.toString(16);
-    } else if (UUID_MASK[i] === "y") {
-      uuid += (randomValue & 3 | 8).toString(16);
-    } else {
-      uuid += UUID_MASK[i];
-    }
+  if ((_b = globalThis.crypto) == null ? void 0 : _b.getRandomValues) {
+    const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16));
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+    return [
+      hex.slice(0, 4),
+      hex.slice(4, 6),
+      hex.slice(6, 8),
+      hex.slice(8, 10),
+      hex.slice(10, 16)
+    ].map((group) => group.join("")).join("-");
   }
-  return uuid;
+  return nodeRandomUUID();
 }
 function base64Encode(data) {
   if (isBrowser()) {

package/dist/esm/utils/error_utils.js

@@ -0,0 +1,92 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const MAX_RESPONSE_BODY_LENGTH = 1e3;
+const TRUNCATION_MARKER = "... [truncated]";
+const UNKNOWN_ERROR = "Unknown error";
+const MIN_HTTP_STATUS = 100;
+const MAX_HTTP_STATUS = 599;
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : void 0;
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function truncateBody(body) {
+  return body.length > MAX_RESPONSE_BODY_LENGTH ? body.slice(0, MAX_RESPONSE_BODY_LENGTH) + TRUNCATION_MARKER : body;
+}
+function baseMessage(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  return String(err);
+}
+function extractHttpDetails(err) {
+  var _a, _b;
+  const record = asRecord(err);
+  if (record === void 0) {
+    return void 0;
+  }
+  const response = asRecord(record["response"]);
+  const rawStatus = (_b = (_a = record["status"]) != null ? _a : record["code"]) != null ? _b : response == null ? void 0 : response["status"];
+  const status = typeof rawStatus === "number" && rawStatus >= MIN_HTTP_STATUS && rawStatus <= MAX_HTTP_STATUS ? rawStatus : void 0;
+  const statusText = firstString(
+    record["statusText"],
+    response == null ? void 0 : response["statusText"]
+  );
+  const body = firstString(
+    response == null ? void 0 : response["data"],
+    response == null ? void 0 : response["body"],
+    response == null ? void 0 : response["text"]
+  );
+  if (status === void 0 && body === void 0) {
+    return void 0;
+  }
+  const head = status === void 0 ? "HTTP error" : `HTTP ${status}${statusText === void 0 ? "" : ` ${statusText}`}`;
+  return body === void 0 ? head : `${head}: ${truncateBody(body)}`;
+}
+function formatErrorRecursive(err, seen) {
+  var _a;
+  if (err === null || err === void 0) {
+    return UNKNOWN_ERROR;
+  }
+  if (typeof err === "object") {
+    if (seen.has(err)) {
+      return baseMessage(err);
+    }
+    seen.add(err);
+  }
+  if (err instanceof AggregateError && err.errors.length > 0) {
+    return err.errors.map((sub) => formatErrorRecursive(sub, seen)).join(" | ");
+  }
+  const http = extractHttpDetails(err);
+  const base = baseMessage(err);
+  const cause = (_a = asRecord(err)) == null ? void 0 : _a["cause"];
+  const causeMessage = cause !== void 0 ? formatErrorRecursive(cause, seen) : void 0;
+  let message = base.length > 0 ? base : UNKNOWN_ERROR;
+  if (http !== void 0) {
+    message = `${message} (${http})`;
+  }
+  if (causeMessage !== void 0 && http === void 0 && !message.includes(causeMessage)) {
+    message = `${message}: ${causeMessage}`;
+  }
+  return message;
+}
+function formatError(err) {
+  return formatErrorRecursive(err, /* @__PURE__ */ new Set());
+}
+export {
+  formatError
+};

package/dist/esm/utils/file_utils.js

@@ -7,12 +7,15 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+function isInsideDir(resolvedPath, resolvedBaseDir) {
+  return resolvedPath === resolvedBaseDir || resolvedPath.startsWith(resolvedBaseDir + path.sep);
+}
 async function materializeFiles(files, dir = process.cwd()) {
   const resolvedBaseDir = path.resolve(dir);
   const createdFiles = [];
   for (const file of files) {
     const fullPath = path.resolve(dir, file.name);
-    if (!fullPath.startsWith(resolvedBaseDir)) {
+    if (!isInsideDir(fullPath, resolvedBaseDir)) {
       throw new Error(
         `Path traversal detected: ${file.name} resolves outside of ${dir}`
       );
@@ -34,7 +37,7 @@ async function materializeFiles(files, dir = process.cwd()) {
         break;
       }
     }
-    if (!finalPath.startsWith(resolvedBaseDir)) {
+    if (!isInsideDir(finalPath, resolvedBaseDir)) {
       throw new Error(
         `Path traversal detected: ${file.name} resolves outside of ${dir}`
       );

package/dist/esm/utils/output_schema_utils.js

@@ -0,0 +1,15 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isGemini2OrAbove } from "./model_name.js";
+import { getGoogleLlmVariant, GoogleLLMVariant } from "./variant_utils.js";
+function canUseOutputSchemaWithTools(modelString) {
+  return getGoogleLlmVariant() === GoogleLLMVariant.VERTEX_AI && isGemini2OrAbove(modelString);
+}
+export {
+  canUseOutputSchemaWithTools
+};

package/dist/esm/utils/vertex_ai_utils.js

@@ -6,6 +6,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * SPDX-License-Identifier: Apache-2.0
  */
 import { getBooleanEnvVar } from "./env_aware_utils.js";
+const EXPRESS_MODE_UNSUPPORTED_MESSAGE = "Vertex AI Express Mode (expressModeApiKey / GOOGLE_API_KEY) is not supported: the @google-cloud/vertexai Agent Engine client cannot send an API key. Provide projectId and location (with Application Default Credentials), or inject a preconfigured client.";
 function getExpressModeApiKey(project, location, expressModeApiKey) {
   if ((project || location) && expressModeApiKey) {
     throw new Error(
@@ -18,5 +19,6 @@ function getExpressModeApiKey(project, location, expressModeApiKey) {
   return void 0;
 }
 export {
+  EXPRESS_MODE_UNSUPPORTED_MESSAGE,
   getExpressModeApiKey
 };

package/dist/esm/version.js

@@ -5,7 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "1.5.0";
+const version = "1.6.0";
 export {
   version
 };

package/dist/types/a2a/auth.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2aUserBuilder } from './agent_to_a2a.js';
+/**
+ * Builds an {@link A2aUserBuilder} that authenticates A2A requests against a
+ * shared bearer token.
+ *
+ * Callers must send `Authorization: Bearer <token>`; the credential is
+ * compared against `token` in constant time, and a request with a missing,
+ * malformed or incorrect one is rejected before the agent or any of its tools
+ * is invoked. Serve the surface over HTTPS, or the secret travels in clear
+ * text on every call.
+ *
+ * ```ts
+ * toA2a(agent, {authentication: bearerTokenUserBuilder(process.env.MY_TOKEN)});
+ * ```
+ *
+ * A rejected request surfaces as whatever the `@a2a-js/sdk` handler produces
+ * for a failing `UserBuilder`, which is an HTTP 500 rather than a 401. The
+ * guarantee here is that the agent is never reached, not that the caller gets
+ * a particular status code.
+ *
+ * @param token The shared secret callers must present; surrounding whitespace
+ *   is trimmed, because HTTP strips it from header values anyway.
+ * @throws If `token` is empty or contains only whitespace.
+ */
+export declare function bearerTokenUserBuilder(token: string): A2aUserBuilder;

package/dist/types/a2a/event_converter_utils.d.ts

@@ -27,7 +27,10 @@ export declare function toA2AMessage(event: AdkEvent, { appName, userId, session
  *   status update).
  * @param invocationId - The ADK invocation ID to attach to the resulting event.
  * @param agentName - The name of the agent to use as the event author.
+ * @param branch - The local invocation's branch to attach to the resulting
+ *   event. Must come from the caller's own `InvocationContext`, never from
+ *   the A2A peer: see the comment on `createAdkEventFromMetadata` for why.
  * @returns The converted ADK event, or `undefined` if the A2A event type
  *   produces no content.
  */
-export declare function toAdkEvent(event: A2AEvent, invocationId: string, agentName: string): AdkEvent | undefined;
+export declare function toAdkEvent(event: A2AEvent, invocationId: string, agentName: string, branch?: string): AdkEvent | undefined;

package/dist/types/auth/credential_service/in_memory_credential_service.d.ts

@@ -12,6 +12,17 @@ import { BaseCredentialService } from './base_credential_service.js';
  * implementation of credential service
  */
 export declare class InMemoryCredentialService implements BaseCredentialService {
+    /**
+     * A map from app name to a map from user ID to a map from credential key to
+     * credential.
+     *
+     * `appName`, `userId` and `credentialKey` are all attacker-influenced, so
+     * every level is created with `Object.create(null)`. On an ordinary `{}`
+     * literal a key of `__proto__` resolves to the inherited `__proto__`
+     * accessor rather than creating an own property, so nested assignment
+     * pollutes every object in the process, and a lookup of an inherited key
+     * such as `toString` returns a function instead of `undefined`.
+     */
     private readonly credentials;
     loadCredential(authConfig: AuthConfig, toolContext: Context): Promise<AuthCredential | undefined>;
     saveCredential(authConfig: AuthConfig, toolContext: Context): Promise<void>;

package/dist/types/code_executors/unsafe_local_code_executor.d.ts

@@ -23,6 +23,10 @@ export interface UnsafeLocalCodeExecutorOptions {
     pythonCommandPath?: string;
     /**
      * The command to run Shell code. Default is `bash`.
+     *
+     * When it names `powershell` or `pwsh` (with or without `.exe`) the script
+     * is written as `.ps1` and run through PowerShell rather than as a bare
+     * shell script.
      */
     shellCommandPath?: string;
 }
@@ -33,7 +37,7 @@ export interface UnsafeLocalCodeExecutorOptions {
  * **Execution Details**:
  * - **JavaScript**: Executed via `node` (defaults to `process.execPath`).
  * - **Python**: Executed via `python3` on Unix, and `python` on Windows.
- * - **Shell**: Executed via `bash` on Unix, and defaults to `powershell` (injecting ExecutionPolicy Bypass) or `cmd.exe` on Windows.
+ * - **Shell**: Executed via `bash` on Unix, and defaults to `powershell` (injecting `-NoProfile` and `-ExecutionPolicy Bypass`) or `cmd.exe` (injecting `/D`) on Windows.
  *
  * WARNING: This executor runs code in the local environment without sandboxing or security restrictions.
  * Use with caution and only for trusted code.

package/dist/types/common.d.ts

@@ -124,6 +124,7 @@ export { ExampleTool } from './tools/example_tool.js';
 export { EXIT_LOOP, ExitLoopTool } from './tools/exit_loop_tool.js';
 export { FunctionTool, isFunctionTool } from './tools/function_tool.js';
 export type { ToolExecuteArgument, ToolExecuteFunction, ToolInputParameters, ToolOptions, } from './tools/function_tool.js';
+export { getUserChoiceTool } from './tools/get_user_choice_tool.js';
 export { GOOGLE_MAPS_GROUNDING, GoogleMapsGroundingTool, } from './tools/google_maps_grounding_tool.js';
 export { GOOGLE_SEARCH, GoogleSearchTool } from './tools/google_search_tool.js';
 export { LOAD_ARTIFACTS, LoadArtifactsTool, } from './tools/load_artifacts_tool.js';
@@ -132,6 +133,7 @@ export { LOAD_WEB_PAGE, loadWebPage } from './tools/load_web_page.js';
 export type { LoadWebPageOptions } from './tools/load_web_page.js';
 export { LongRunningFunctionTool } from './tools/long_running_tool.js';
 export { PRELOAD_MEMORY, PreloadMemoryTool, } from './tools/preload_memory_tool.js';
+export { requestInputTool } from './tools/request_input_tool.js';
 export { ToolConfirmation } from './tools/tool_confirmation.js';
 export { URL_CONTEXT, UrlContextTool } from './tools/url_context_tool.js';
 export { VertexAiSearchTool } from './tools/vertex_ai_search_tool.js';

package/dist/types/context/agent_controlled_context_compactor.d.ts

@@ -20,5 +20,4 @@ export declare class AgentControlledContextCompactor implements BaseContextCompa
     shouldCompact(invocationContext: InvocationContext): boolean;
     compact(invocationContext: InvocationContext): Promise<void>;
     private clearFlags;
-    private getActiveEvents;
 }

package/dist/types/context/compaction_utils.d.ts

@@ -4,6 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Event } from '../events/event.js';
+/**
+ * Filters the events to return only the active events since the latest compaction.
+ * If no compaction has occurred, returns all events.
+ *
+ * @param events The full history of events.
+ * @returns The active events, starting with the latest CompactedEvent if present.
+ */
+export declare function getActiveEvents(events: Event[]): Event[];
 /**
  * Determines the baseline index to retain from active raw events,
  * ensuring we don't split between a function call and its response.

package/dist/types/context/token_based_context_compactor.d.ts

@@ -32,7 +32,6 @@ export declare class TokenBasedContextCompactor implements BaseContextCompactor
     private readonly eventRetentionSize;
     private readonly summarizer;
     constructor(options: TokenBasedContextCompactorOptions);
-    private getActiveEvents;
     shouldCompact(invocationContext: InvocationContext): boolean | Promise<boolean>;
     compact(invocationContext: InvocationContext): Promise<void>;
 }

package/dist/types/index.d.ts

@@ -10,6 +10,7 @@ export { A2AAgentExecutor } from './a2a/agent_executor.js';
 export type { AfterEventCallback, AfterExecuteCallback, AgentExecutorConfig, BeforeExecuteCallback, RunnerOrRunnerConfig, } from './a2a/agent_executor.js';
 export { toA2a } from './a2a/agent_to_a2a.js';
 export type { A2aUserBuilder, ToA2aOptions } from './a2a/agent_to_a2a.js';
+export { bearerTokenUserBuilder } from './a2a/auth.js';
 export type { ExecutorContext } from './a2a/executor_context.js';
 export { InvocationContext } from './agents/invocation_context.js';
 export { FileArtifactService } from './artifacts/file_artifact_service.js';
@@ -22,7 +23,7 @@ export * from './common.js';
 export { DatabaseSessionService } from './sessions/database_session_service.js';
 export { getSessionServiceFromUri } from './sessions/registry.js';
 export { VertexAiSessionService } from './sessions/vertex_ai_session_service.js';
-export type { VertexAiSessionServiceOptions } from './sessions/vertex_ai_session_service.js';
+export type { VertexAiCreateSessionRequest, VertexAiSessionServiceOptions, } from './sessions/vertex_ai_session_service.js';
 export { loadAllSkillsInDir, loadSkillFromDir, validateSkillDir, } from './skills/loader.js';
 export { RunSkillInlineScriptErrorCode, RunSkillInlineScriptTool, } from './tools/skill/run_skill_inline_script_tool.js';
 export { RunSkillScriptTool } from './tools/skill/run_skill_script_tool.js';

package/dist/types/memory/in_memory_memory_service.d.ts

@@ -12,6 +12,17 @@ import { BaseMemoryService, SearchMemoryRequest, SearchMemoryResponse } from './
  */
 export declare class InMemoryMemoryService implements BaseMemoryService {
     private readonly memories;
+    /**
+     * A map from user key to a map from session ID to events.
+     *
+     * The inner map is keyed by `session.id`, which arrives off the request path
+     * and contains no `/`, so it can be exactly `__proto__`. On a plain object
+     * literal that key would reach the inherited `__proto__` setter and
+     * re-parent the map instead of creating an own property, silently dropping
+     * the session from the `Object.values` scan in `searchMemory`. The outer key
+     * always contains a `/` (see `getUserKey`) and cannot collide, but is
+     * created the same way for consistency.
+     */
     private readonly sessionEvents;
     addSessionToMemory(session: Session): Promise<void>;
     searchMemory(req: SearchMemoryRequest): Promise<SearchMemoryResponse>;

package/dist/types/plugins/base_plugin.d.ts

@@ -151,8 +151,10 @@ export declare abstract class BasePlugin {
      * @param params.invocationContext The context for the entire invocation.
      * @param params.event The event raised by the runner.
      * @returns An optional value. A non-`undefined` return may be used by the
-     *     framework to modify or replace the response. Returning `undefined`
-     *     allows the original response to be used.
+     *     framework to modify or replace the response. Copy `params.event` when
+     *     constructing a replacement to preserve fields that are not being
+     *     modified, such as event actions. Returning `undefined` allows the
+     *     original response to be used.
      */
     onEventCallback(params: {
         invocationContext: InvocationContext;

package/dist/types/sessions/base_session_service.d.ts

@@ -145,6 +145,14 @@ export declare abstract class BaseSessionService {
 export declare function trimTempDeltaState(event: Event): Event;
 /**
  * Removes temporary state keys from the state.
+ *
+ * The result is a null-prototype map. `state` comes straight off the request
+ * body on a dev server (`POST /apps/:appName/users/:userId/sessions/:sessionId`),
+ * and `JSON.parse` makes `__proto__` an own key, so copying it into a plain
+ * object literal would invoke the inherited `__proto__` setter: the entry is
+ * dropped and the new state object is re-parented onto the attacker's object.
+ * `State.get`/`State.has` use the `in` operator, so every key on that object
+ * would then read back as session state.
  */
 export declare function trimTempState(state: Record<string, unknown>): Record<string, unknown>;
 /**

package/dist/types/sessions/in_memory_session_service.d.ts

@@ -7,6 +7,15 @@ import { Session } from './session.js';
 export declare function isInMemoryConnectionString(uri?: string): boolean;
 /**
  * An in-memory implementation of the session service.
+ *
+ * Every map below is keyed by untrusted input — `appName`, `userId`,
+ * `sessionId` and state keys all arrive straight off the request path or body
+ * on a dev server — so each is created with `Object.create(null)`. On an
+ * ordinary `{}` literal a key of `__proto__` resolves to the inherited
+ * `__proto__` accessor instead of creating an own property, so
+ * `map[appName][userId] = ...` writes onto `Object.prototype` and pollutes
+ * every object in the process. A null-prototype map has no such accessor, so
+ * those keys become ordinary own properties.
  */
 export declare class InMemorySessionService extends BaseSessionService {
     /**

package/dist/types/sessions/vertex_ai_session_service.d.ts

@@ -26,6 +26,19 @@ export interface VertexAiSessionServiceOptions {
     expressModeApiKey?: string;
     sessions?: Sessions;
 }
+/**
+ * The parameters for `VertexAiSessionService.createSession`.
+ *
+ * Extends the common {@link CreateSessionRequest} with the mutually exclusive
+ * session-expiration options supported by Vertex AI Agent Engine Sessions. See
+ * https://cloud.google.com/vertex-ai/generative-ai/docs/reference/rest/v1beta1/projects.locations.reasoningEngines.sessions
+ */
+export interface VertexAiCreateSessionRequest extends CreateSessionRequest {
+    /** Lifetime relative to creation, in seconds, e.g. `'7200s'`. */
+    ttl?: string;
+    /** Absolute RFC 3339 UTC expiration, e.g. `'2025-10-01T00:00:00Z'`. */
+    expireTime?: string;
+}
 /**
  * A session service implementation that integrates with Vertex AI Agent Engine Sessions.
  */
@@ -37,7 +50,12 @@ export declare class VertexAiSessionService extends BaseSessionService {
     private location?;
     constructor(options: VertexAiSessionServiceOptions);
     private getReasoningEngineId;
-    createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;
+    /**
+     * Creates a session on Vertex AI Agent Engine.
+     *
+     * @throws if both `ttl` and `expireTime` are specified.
+     */
+    createSession({ appName, userId, state, sessionId, ttl, expireTime, }: VertexAiCreateSessionRequest): Promise<Session>;
     getSession({ appName, userId, sessionId, config, }: GetSessionRequest): Promise<Session | undefined>;
     listSessions({ appName, userId, limit, offset, page, order, }: ListSessionsRequest): Promise<ListSessionsResponse>;
     deleteSession({ appName, userId, sessionId, }: DeleteSessionRequest): Promise<void>;

package/dist/types/skills/loader.d.ts

@@ -39,7 +39,12 @@ export declare function loadAllSkillsInDir(skillsBasePath: string): Promise<Reco
 /**
  * Loads a complete skill directly from in-memory zip file buffer.
  *
+ * The whole archive is rejected if any member name escapes the extraction
+ * root, and the skill name must be a bare path segment.
+ *
  * @param zipBuffer - The raw Buffer of the zip file containing the skill.
  * @returns A Skill object with all components loaded.
+ * @throws {Error} If a member name is a traversal path, if SKILL.md is missing,
+ * or if the skill name is missing or is not a bare path segment.
  */
 export declare function loadSkillFromZipBuffer(zipBuffer: Buffer): Skill;

package/dist/types/tools/get_user_choice_tool.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import { LongRunningFunctionTool } from './long_running_tool.js';
+/**
+ * A long-running tool that presents a list of options to the user and awaits
+ * their selection.
+ */
+export declare const getUserChoiceTool: LongRunningFunctionTool<z.ZodObject<{
+    options: z.ZodArray<z.ZodString>;
+}, z.core.$strip>>;

package/dist/types/tools/request_input_tool.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import { LongRunningFunctionTool } from './long_running_tool.js';
+/**
+ * A long-running tool that presents a custom message to the user and awaits
+ * unstructured or structured input.
+ */
+export declare const requestInputTool: LongRunningFunctionTool<z.ZodObject<{
+    message: z.ZodString;
+    responseSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>>;