@google/adk 1.2.0 → 1.4.0

package/dist/types/tools/openapi_tool/openapi_spec_parser/operation_parser.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+export interface ApiParameter {
+    originalName: string;
+    paramLocation: string;
+    paramSchema: OpenAPIV3.SchemaObject;
+    description?: string;
+    name: string;
+    required: boolean;
+}
+/**
+ * Parses an OpenAPI OperationObject and extracts its parameters, request body, and return value.
+ *
+ * It maps OpenAPI parameters and request bodies into a flat list of `ApiParameter` objects
+ * that are compatible with Gemini's tool function declarations.
+ */
+export declare class OperationParser {
+    private readonly operation;
+    private params;
+    private returnValue?;
+    private preservePropertyNames;
+    constructor(operation: OpenAPIV3.OperationObject, options?: {
+        preservePropertyNames?: boolean;
+    });
+    private getParamName;
+    private processOperationParameters;
+    private processRequestBody;
+    private processReturnValue;
+    private dedupeParamNames;
+    /**
+     * Gets the list of parsed parameters extracted from the OpenAPI operation.
+     *
+     * @returns An array of parsed parameters.
+     */
+    getParameters(): ApiParameter[];
+    /**
+     * Generates a JSON schema representing the arguments of the tool function call.
+     *
+     * @returns A JSON Schema object.
+     */
+    getJsonSchema(): Record<string, unknown>;
+    /**
+     * Gets a valid tool function name derived from the operation's operationId.
+     *
+     * @throws {Error} If the operation does not have an operationId.
+     * @returns A string representing the function name.
+     */
+    getFunctionName(): string;
+    /**
+     * Gets the description of the tool, derived from the operation's description or summary.
+     *
+     * @returns A string representing the description.
+     */
+    getDescription(): string;
+}

package/dist/types/tools/openapi_tool/openapi_spec_parser/tool_auth_handler.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+import { Context } from '../../../agents/context.js';
+import { AuthCredential } from '../../../auth/auth_credential.js';
+export interface AuthPreparationResult {
+    state: 'pending' | 'done';
+    authCredential?: AuthCredential;
+}
+export declare class ToolAuthHandler {
+    private readonly context;
+    private readonly authScheme?;
+    private readonly authCredential?;
+    private readonly credentialKey?;
+    constructor(context: Context, authScheme?: OpenAPIV3.SecuritySchemeObject | undefined, authCredential?: AuthCredential | undefined, credentialKey?: string | undefined);
+    static fromToolContext(context: Context, authScheme?: OpenAPIV3.SecuritySchemeObject, authCredential?: AuthCredential, options?: {
+        credentialKey?: string;
+    }): ToolAuthHandler;
+    prepareAuthCredentials(): Promise<AuthPreparationResult>;
+}

package/dist/types/tools/openapi_tool/openapi_toolset.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { AuthCredential } from '../../auth/auth_credential.js';
+import { BaseTool } from '../base_tool.js';
+import { BaseToolset, ToolPredicate } from '../base_toolset.js';
+export declare class OpenAPIToolset extends BaseToolset {
+    private tools;
+    constructor(options?: {
+        specDict?: OpenAPIV3.Document;
+        specStr?: string;
+        specType?: 'json' | 'yaml';
+        toolFilter?: ToolPredicate | string[];
+        prefix?: string;
+        preservePropertyNames?: boolean;
+        authScheme?: OpenAPIV3.SecuritySchemeObject;
+        authCredential?: AuthCredential;
+        credentialKey?: string;
+        headerProvider?: (context: ReadonlyContext) => Record<string, string>;
+    });
+    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    close(): Promise<void>;
+}

package/dist/types/tools/openapi_tool/rest_api_tool.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { OpenAPIV3 } from 'openapi-types';
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { AuthCredential } from '../../auth/auth_credential.js';
+import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
+import { ApiParameter } from './openapi_spec_parser/operation_parser.js';
+import { OperationEndpoint } from './openapi_spec_parser/openapi_spec_parser.js';
+export declare class RestApiTool extends BaseTool {
+    private readonly endpoint;
+    private readonly operation;
+    private authScheme?;
+    private authCredential?;
+    private operationParser;
+    private headerProvider?;
+    private credentialKey?;
+    constructor(name: string, description: string, endpoint: OperationEndpoint, operation: OpenAPIV3.OperationObject, authScheme?: OpenAPIV3.SecuritySchemeObject | undefined, authCredential?: AuthCredential | undefined, options?: {
+        preservePropertyNames?: boolean;
+        headerProvider?: (context: ReadonlyContext) => Record<string, string>;
+        credentialKey?: string;
+    });
+    configureAuthScheme(authScheme: OpenAPIV3.SecuritySchemeObject): void;
+    configureAuthCredential(authCredential: AuthCredential): void;
+    configureCredentialKey(credentialKey: string): void;
+    _getDeclaration(): FunctionDeclaration;
+    runAsync(request: RunAsyncToolRequest): Promise<unknown>;
+}
+export interface PreparedParams {
+    url: string;
+    headers: Record<string, string>;
+    body: unknown;
+    bodyData: Record<string, unknown>;
+}
+export declare function prepareRequestParams(endpoint: OperationEndpoint, parameters: ApiParameter[], args: Record<string, unknown>): PreparedParams;
+export declare function prepareRequestBody(requestBody: OpenAPIV3.RequestBodyObject | OpenAPIV3.ReferenceObject | undefined, body: unknown, bodyData: Record<string, unknown>, headers: Record<string, string>): unknown;
+export declare function createRestApiTool(parsed: {
+    name: string;
+    description: string;
+    endpoint: OperationEndpoint;
+    operation: OpenAPIV3.OperationObject;
+    authScheme?: OpenAPIV3.SecuritySchemeObject;
+}, options?: {
+    preservePropertyNames?: boolean;
+    headerProvider?: (context: ReadonlyContext) => Record<string, string>;
+    credentialKey?: string;
+}): RestApiTool;

package/dist/types/tools/skill/load_skill_resource_tool.d.ts

@@ -10,6 +10,6 @@ export declare class LoadSkillResourceTool extends BaseTool {
     private toolset;
     constructor(toolset: SkillToolset);
     _getDeclaration(): FunctionDeclaration;
-    runAsync({ args }: RunAsyncToolRequest): Promise<unknown>;
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
     processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
 }

package/dist/types/tools/skill/search_skills_tool.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
+import { SkillToolset } from './skill_toolset.js';
+export declare class SearchSkillsTool extends BaseTool {
+    private toolset;
+    constructor(toolset: SkillToolset);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync({ args }: RunAsyncToolRequest): Promise<unknown>;
+}

package/dist/types/tools/skill/skill_toolset.d.ts

@@ -8,6 +8,7 @@ import { ReadonlyContext } from '../../agents/readonly_context.js';
 import { BaseCodeExecutor } from '../../code_executors/base_code_executor.js';
 import { LlmRequest } from '../../models/llm_request.js';
 import { Skill } from '../../skills/skill.js';
+import { SkillRegistry } from '../../skills/skill_registry.js';
 import { BaseTool } from '../base_tool.js';
 import { BaseToolset } from '../base_toolset.js';
 export declare class SkillToolset extends BaseToolset {
@@ -15,14 +16,18 @@ export declare class SkillToolset extends BaseToolset {
     private tools;
     additionalTools: Array<BaseTool | BaseToolset>;
     codeExecutor?: BaseCodeExecutor;
+    registry?: SkillRegistry;
     private toolCache;
+    private fetchedSkillCache;
     constructor(skills: Record<string, Skill> | Skill[], options?: {
         codeExecutor?: BaseCodeExecutor;
         additionalTools?: Array<BaseTool | BaseToolset>;
+        registry?: SkillRegistry;
     });
     getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
     close(): Promise<void>;
     getSkill(name: string): Skill | undefined;
+    getOrFetchSkill(name: string, invocationId?: string): Promise<Skill | undefined>;
     processLlmRequest(toolContext: Context, llmRequest: LlmRequest): Promise<void>;
     private resolveAdditionalTools;
 }

package/dist/types/utils/async_hooks_shim.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare class AsyncLocalStorage<T> {
+    private store;
+    run<R>(store: T, callback: () => R): R;
+    getStore(): T | undefined;
+}

package/dist/types/utils/async_queue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A generic, async-safe queue that implements AsyncIterable.
+ */
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private queue;
+    private resolvers;
+    private closed;
+    private errorVal?;
+    push(value: T): void;
+    error(err: unknown): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}

package/dist/types/utils/case_utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Recursively converts snake_case keys of an object to camelCase.
+ *
+ * @param val The value to convert.
+ * @returns The converted value.
+ */
+export declare function camelCaseKeys(val: unknown): unknown;

package/dist/types/utils/client_labels.d.ts

@@ -3,6 +3,16 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+export declare function parseUserAgent(userAgent: string): string;
+/**
+ * Runs the given callback within a context that has the specified client label.
+ * All LLM calls made within this callback will include the client label in their tracking headers.
+ *
+ * @param clientLabel The custom client label to apply.
+ * @param callback The callback function to execute.
+ * @return The result of the callback.
+ */
+export declare function runWithClientLabel<R>(clientLabel: string, callback: () => R): R;
 /**
  * Returns the current list of client labels that can be added to HTTP Headers.
  */

package/dist/types/utils/env_aware_utils.d.ts

@@ -9,12 +9,12 @@
 export declare function isBrowser(): boolean;
 export declare function randomUUID(): string;
 /**
- * Encodes the given string to base64.
+ * Encodes the given string or Uint8Array to base64.
  *
- * @param data The string to encode.
+ * @param data The data to encode.
  * @return The base64-encoded string.
  */
-export declare function base64Encode(data: string): string;
+export declare function base64Encode(data: string | Uint8Array): string;
 /**
  * Decodes the given base64 string to a string.
  *

package/dist/types/utils/live_connection_utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LiveServerMessage } from '@google/genai';
+import { LlmResponse } from '../models/llm_response.js';
+/**
+ * Aggregator and mapper for Gemini Live WebSocket server messages.
+ *
+ * Translates incoming raw WebSocket server messages (push stream) into unified
+ * agent-consumable LlmResponse objects (pull stream), managing transcription buffers,
+ * grounding metadata, text segments, and tool calls.
+ */
+export declare class LiveResponseAggregator {
+    private readonly modelVersion?;
+    private text;
+    private isThought;
+    private toolCallParts;
+    private pendingGroundingMetadata;
+    private inputTranscriptionText;
+    private outputTranscriptionText;
+    constructor(modelVersion?: string | undefined);
+    processMessage(message: LiveServerMessage): Generator<LlmResponse, void, void>;
+    /**
+     * Flushes any remaining aggregated components when the connection is closed.
+     */
+    close(): Generator<LlmResponse, void, void>;
+    private buildFullTextResponse;
+}

package/dist/types/utils/model_name.d.ts

@@ -32,6 +32,13 @@ export declare function isGemini1Model(modelString: string): boolean;
  * @return true if it's a Gemini 2.x model, false otherwise.
  */
 export declare function isGemini2OrAbove(modelString: string): boolean;
+/**
+ * Check if the model is a Gemini 3.x Flash Live model.
+ *
+ * @param modelString Either a simple model name or path-based model name
+ * @return true if it's a Gemini 3.x Flash Live model, false otherwise.
+ */
+export declare function isGemini3xFlashLive(modelString: string | undefined): boolean;
 /**
  * Returns True when Gemini model-id validation should be bypassed.
  */

package/dist/types/utils/streaming_utils.d.ts

@@ -19,7 +19,6 @@ export declare class StreamingResponseAggregator {
     private response?;
     private finishReason?;
     private lastThoughtSignature;
-    private sawFunctionCall;
     private readonly strategy;
     constructor(isProgressiveMode?: boolean);
     processResponse(response: GenerateContentResponse): AsyncGenerator<LlmResponse, void, void>;

package/dist/types/utils/task.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export type TaskExecutable<T = void> = (abortSignal: AbortSignal) => Promise<T>;
+/**
+ * Represents a runtime task wrapping a promise, allowing status check and cancellation.
+ */
+export declare class Task<T = void> {
+    executable: TaskExecutable<T>;
+    private isDone;
+    private abortController;
+    promise: Promise<T>;
+    constructor(executable: TaskExecutable<T>);
+    /**
+     * Cancels the task execution.
+     */
+    cancel(): void;
+    /**
+     * Returns true if the task has completed (either resolved or rejected).
+     */
+    done(): boolean;
+}

package/dist/types/version.d.ts

@@ -3,4 +3,4 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export declare const version = "1.2.0";
+export declare const version = "1.4.0";

package/dist/web/agents/active_streaming_tool.js

@@ -5,9 +5,14 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { Task } from "../utils/task.js";
 class ActiveStreamingTool {
   constructor(params = {}) {
-    this.task = params.task;
+    if (params.task instanceof Promise) {
+      this.task = new Task(() => params.task);
+    } else {
+      this.task = params.task;
+    }
     this.stream = params.stream;
   }
 }

package/dist/web/agents/base_agent.js

@@ -184,10 +184,40 @@ class BaseAgent {
           this,
           function() {
             return __asyncGenerator(this, null, function* () {
+              var _a2, _b;
+              const context2 = this.createInvocationContext(parentContext);
+              const beforeAgentCallbackEvent = yield new __await(this.handleBeforeAgentCallback(context2));
+              if (beforeAgentCallbackEvent) {
+                yield beforeAgentCallbackEvent;
+              }
+              if (context2.endInvocation || ((_a2 = parentContext.abortSignal) == null ? void 0 : _a2.aborted)) {
+                return;
+              }
+              try {
+                for (var iter = __forAwait(this.runLiveImpl(context2)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+                  const event = temp.value;
+                  yield event;
+                }
+              } catch (temp) {
+                error = [temp];
+              } finally {
+                try {
+                  more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+                } finally {
+                  if (error)
+                    throw error[0];
+                }
+              }
+              if (context2.endInvocation || ((_b = parentContext.abortSignal) == null ? void 0 : _b.aborted)) {
+                return;
+              }
+              const afterAgentCallbackEvent = yield new __await(this.handleAfterAgentCallback(context2));
+              if (afterAgentCallbackEvent) {
+                yield afterAgentCallbackEvent;
+              }
             });
           }
         ));
-        throw new Error("Live mode is not implemented yet.");
       } finally {
         span.end();
       }

package/dist/web/agents/context.js

@@ -56,9 +56,6 @@ class Context extends ReadonlyContext {
       throw new Error("Artifact service is not initialized.");
     }
     return this.invocationContext.artifactService.loadArtifact({
-      appName: this.invocationContext.appName,
-      userId: this.invocationContext.userId,
-      sessionId: this.invocationContext.session.id,
       filename,
       version
     });
@@ -75,9 +72,6 @@ class Context extends ReadonlyContext {
       throw new Error("Artifact service is not initialized.");
     }
     const version = await this.invocationContext.artifactService.saveArtifact({
-      appName: this.invocationContext.appName,
-      userId: this.invocationContext.userId,
-      sessionId: this.invocationContext.session.id,
       filename,
       artifact
     });
@@ -110,11 +104,7 @@ class Context extends ReadonlyContext {
     if (!this.invocationContext.artifactService) {
       throw new Error("Artifact service is not initialized.");
     }
-    return this.invocationContext.artifactService.listArtifactKeys({
-      appName: this.invocationContext.session.appName,
-      userId: this.invocationContext.session.userId,
-      sessionId: this.invocationContext.session.id
-    });
+    return this.invocationContext.artifactService.listArtifactKeys();
   }
   /**
    * Searches the memory of the current user.

package/dist/web/agents/functions.js

@@ -7,7 +7,11 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import { createUserContent } from "@google/genai";
 import { isEmpty } from "lodash-es";
-import { createEvent, getFunctionCalls } from "../events/event.js";
+import {
+  createEvent,
+  getFunctionCalls,
+  getFunctionResponses
+} from "../events/event.js";
 import { mergeEventActions } from "../events/event_actions.js";
 import { randomUUID } from "../utils/env_aware_utils.js";
 import { logger } from "../utils/logger.js";
@@ -39,18 +43,6 @@ function populateClientFunctionCallId(modelResponseEvent) {
     }
   }
 }
-function removeClientFunctionCallId(content) {
-  if (content && content.parts) {
-    for (const part of content.parts) {
-      if (part.functionCall && part.functionCall.id && part.functionCall.id.startsWith(AF_FUNCTION_CALL_ID_PREFIX)) {
-        part.functionCall.id = void 0;
-      }
-      if (part.functionResponse && part.functionResponse.id && part.functionResponse.id.startsWith(AF_FUNCTION_CALL_ID_PREFIX)) {
-        part.functionResponse.id = void 0;
-      }
-    }
-  }
-}
 function getLongRunningFunctionCalls(functionCalls, toolsDict) {
   const longRunningToolIds = /* @__PURE__ */ new Set();
   for (const functionCall of functionCalls) {
@@ -393,9 +385,39 @@ function mergeParallelFunctionResponseEvents(functionResponseEvents) {
     timestamp: baseEvent.timestamp
   });
 }
+function findEventByFunctionCallId(events, functionCallId, endIndex = events.length) {
+  for (let i = endIndex - 1; i >= 0; i--) {
+    const event = events[i];
+    const functionCalls = getFunctionCalls(event);
+    for (const functionCall of functionCalls) {
+      if (functionCall.id === functionCallId) {
+        return event;
+      }
+    }
+  }
+  return void 0;
+}
+function findMatchingFunctionCall(events) {
+  if (!events.length) {
+    return void 0;
+  }
+  const lastEvent = events[events.length - 1];
+  const functionResponses = getFunctionResponses(lastEvent);
+  if (!functionResponses.length || !functionResponses[0].id) {
+    return void 0;
+  }
+  return findEventByFunctionCallId(
+    events,
+    functionResponses[0].id,
+    events.length - 1
+  );
+}
 export {
+  AF_FUNCTION_CALL_ID_PREFIX,
   REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
   REQUEST_EUC_FUNCTION_CALL_NAME,
+  findEventByFunctionCallId,
+  findMatchingFunctionCall,
   functionsExportedForTestingOnly,
   generateAuthEvent,
   generateClientFunctionCallId,
@@ -404,6 +426,5 @@ export {
   handleFunctionCallList,
   handleFunctionCallsAsync,
   mergeParallelFunctionResponseEvents,
-  populateClientFunctionCallId,
-  removeClientFunctionCallId
+  populateClientFunctionCallId
 };