@google/adk 0.6.1 → 1.1.0

package/dist/esm/utils/streaming_utils.js

@@ -0,0 +1,307 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  FinishReason
+} from "@google/genai";
+import { JSONPath } from "jsonpath-plus";
+import { generateClientFunctionCallId } from "../agents/functions.js";
+import { FeatureName, isFeatureEnabled } from "../features/feature_registry.js";
+import { createLlmResponse } from "../models/llm_response.js";
+class StreamingResponseAggregator {
+  constructor(isProgressiveMode = isFeatureEnabled(
+    FeatureName.PROGRESSIVE_SSE_STREAMING
+  )) {
+    this.isProgressiveMode = isProgressiveMode;
+    // For non-progressive SSE streaming mode
+    this.text = "";
+    this.thoughtText = "";
+    // For progressive SSE streaming mode: accumulate parts in order
+    this.partsSequence = [];
+    this.currentTextBuffer = "";
+    this.currentFcArgs = {};
+  }
+  flushTextBufferToSequence() {
+    if (!this.currentTextBuffer) {
+      return;
+    }
+    if (this.currentTextIsThought) {
+      this.partsSequence.push({
+        text: this.currentTextBuffer,
+        thought: true
+      });
+    } else {
+      this.partsSequence.push({
+        text: this.currentTextBuffer
+      });
+    }
+    this.currentTextBuffer = "";
+    this.currentTextIsThought = void 0;
+  }
+  getValueFromPartialArg(partialArg, jsonPath) {
+    let value = null;
+    let hasValue = false;
+    const stringValue = partialArg.stringValue;
+    const numberValue = partialArg.numberValue;
+    const boolValue = partialArg.boolValue;
+    const nullValue = partialArg.nullValue;
+    if (stringValue !== void 0) {
+      const stringChunk = stringValue;
+      hasValue = true;
+      const pathParts = JSONPath.toPathArray(jsonPath).filter(
+        (p) => p !== "$" && p !== "$["
+      );
+      let existingValue = this.currentFcArgs;
+      for (const part of pathParts) {
+        if (existingValue && typeof existingValue === "object" && part in existingValue) {
+          existingValue = existingValue[part];
+        } else {
+          existingValue = void 0;
+          break;
+        }
+      }
+      if (typeof existingValue === "string") {
+        value = existingValue + stringChunk;
+      } else {
+        value = stringChunk;
+      }
+    } else if (numberValue !== void 0) {
+      value = numberValue;
+      hasValue = true;
+    } else if (boolValue !== void 0) {
+      value = boolValue;
+      hasValue = true;
+    } else if (nullValue !== void 0) {
+      value = null;
+      hasValue = true;
+    }
+    return [value, hasValue];
+  }
+  setValueByJsonPath(jsonPath, value) {
+    const pathParts = JSONPath.toPathArray(jsonPath).filter(
+      (p) => p !== "$" && p !== "$["
+    );
+    let current = this.currentFcArgs;
+    for (let i = 0; i < pathParts.length - 1; i++) {
+      const part = pathParts[i];
+      if (!(part in current)) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+    if (pathParts.length > 0) {
+      current[pathParts[pathParts.length - 1]] = value;
+    }
+  }
+  flushFunctionCallToSequence() {
+    var _a;
+    if (this.currentFcName) {
+      const fcPart = {
+        functionCall: {
+          name: this.currentFcName,
+          args: JSON.parse(JSON.stringify(this.currentFcArgs)),
+          id: (_a = this.currentFcId) != null ? _a : generateClientFunctionCallId()
+        }
+      };
+      if (this.currentThoughtSignature) {
+        fcPart.thoughtSignature = this.currentThoughtSignature.toString();
+      }
+      this.partsSequence.push(fcPart);
+      this.currentFcName = void 0;
+      this.currentFcArgs = {};
+      this.currentFcId = void 0;
+      this.currentThoughtSignature = void 0;
+    }
+  }
+  processStreamingFunctionCall(fc) {
+    if (fc.name) {
+      this.currentFcName = fc.name;
+    }
+    if (fc.id) {
+      this.currentFcId = fc.id;
+    }
+    for (const partialArg of fc.partialArgs || []) {
+      const jsonPath = partialArg.jsonPath;
+      if (!jsonPath) {
+        continue;
+      }
+      const [value, hasValue] = this.getValueFromPartialArg(
+        partialArg,
+        jsonPath
+      );
+      if (hasValue) {
+        this.setValueByJsonPath(jsonPath, value);
+      }
+    }
+    if (!fc.willContinue) {
+      this.flushTextBufferToSequence();
+      this.flushFunctionCallToSequence();
+    }
+  }
+  processFunctionCallPart(part) {
+    const fc = part.functionCall;
+    if (!fc) {
+      return;
+    }
+    if (part.thoughtSignature) {
+      this.lastThoughtSignature = part.thoughtSignature;
+    } else if (this.lastThoughtSignature) {
+      part.thoughtSignature = this.lastThoughtSignature.toString();
+    }
+    if (fc.partialArgs || fc.willContinue) {
+      if (!fc.id && !this.currentFcId) {
+        fc.id = generateClientFunctionCallId();
+      }
+      if (part.thoughtSignature && !this.currentThoughtSignature) {
+        this.currentThoughtSignature = part.thoughtSignature;
+      }
+      this.processStreamingFunctionCall(fc);
+    } else {
+      if (fc.name) {
+        if (!fc.id) {
+          fc.id = generateClientFunctionCallId();
+        }
+        this.flushTextBufferToSequence();
+        this.partsSequence.push(part);
+      }
+    }
+  }
+  async *processResponse(response) {
+    var _a, _b, _c;
+    this.response = response;
+    const llmResponse = createLlmResponse(response);
+    this.usageMetadata = llmResponse.usageMetadata;
+    if (llmResponse.groundingMetadata) {
+      this.groundingMetadata = llmResponse.groundingMetadata;
+    }
+    if (llmResponse.citationMetadata) {
+      this.citationMetadata = llmResponse.citationMetadata;
+    }
+    if (llmResponse.finishReason) {
+      this.finishReason = llmResponse.finishReason;
+    }
+    if (llmResponse.content && llmResponse.content.parts) {
+      for (const part of llmResponse.content.parts) {
+        if (part.thoughtSignature) {
+          this.lastThoughtSignature = part.thoughtSignature;
+        } else if (part.functionCall && this.lastThoughtSignature) {
+          part.thoughtSignature = this.lastThoughtSignature.toString();
+        }
+      }
+    }
+    if (this.isProgressiveMode) {
+      if (llmResponse.content && llmResponse.content.parts) {
+        for (const part of llmResponse.content.parts) {
+          if (part.text) {
+            const isThought = (_a = part.thought) != null ? _a : false;
+            if (this.currentTextBuffer && isThought !== this.currentTextIsThought) {
+              this.flushTextBufferToSequence();
+            }
+            if (!this.currentTextBuffer) {
+              this.currentTextIsThought = isThought;
+            }
+            this.currentTextBuffer += part.text;
+          } else if (part.functionCall) {
+            this.processFunctionCallPart(part);
+          } else {
+            this.flushTextBufferToSequence();
+            this.partsSequence.push(part);
+          }
+        }
+      }
+      llmResponse.partial = true;
+      yield llmResponse;
+      return;
+    }
+    if (llmResponse.content && llmResponse.content.parts && typeof ((_b = llmResponse.content.parts[0]) == null ? void 0 : _b.text) === "string") {
+      const part0 = llmResponse.content.parts[0];
+      const partText = part0.text || "";
+      if (part0.thought) {
+        this.thoughtText += partText;
+      } else {
+        this.text += partText;
+      }
+      llmResponse.partial = true;
+    } else if ((this.thoughtText || this.text) && (!llmResponse.content || !llmResponse.content.parts || !((_c = llmResponse.content.parts[0]) == null ? void 0 : _c.inlineData))) {
+      const parts = [];
+      if (this.thoughtText) {
+        parts.push({ text: this.thoughtText, thought: true });
+      }
+      if (this.text) {
+        parts.push({ text: this.text });
+      }
+      yield {
+        content: {
+          role: "model",
+          parts
+        },
+        usageMetadata: llmResponse.usageMetadata,
+        partial: false
+      };
+      this.thoughtText = "";
+      this.text = "";
+    }
+    yield llmResponse;
+  }
+  close() {
+    var _a, _b;
+    if (!((_a = this.response) == null ? void 0 : _a.candidates) || this.response.candidates.length === 0) {
+      return;
+    }
+    if (this.isProgressiveMode) {
+      this.flushTextBufferToSequence();
+      this.flushFunctionCallToSequence();
+      const finalParts = this.partsSequence;
+      if (finalParts.length === 0) {
+        return;
+      }
+      const candidate = this.response.candidates[0];
+      const finishReason = (_b = this.finishReason) != null ? _b : candidate.finishReason;
+      return {
+        content: {
+          role: "model",
+          parts: finalParts
+        },
+        groundingMetadata: this.groundingMetadata,
+        citationMetadata: this.citationMetadata,
+        errorCode: finishReason === FinishReason.STOP ? void 0 : finishReason,
+        errorMessage: finishReason === FinishReason.STOP ? void 0 : candidate.finishMessage,
+        usageMetadata: this.usageMetadata,
+        finishReason,
+        partial: false
+      };
+    }
+    if ((this.text || this.thoughtText) && this.response.candidates && this.response.candidates.length > 0) {
+      const parts = [];
+      if (this.thoughtText) {
+        parts.push({ text: this.thoughtText, thought: true });
+      }
+      if (this.text) {
+        parts.push({ text: this.text });
+      }
+      const candidate = this.response.candidates[0];
+      const finishReason = candidate.finishReason;
+      return {
+        content: {
+          role: "model",
+          parts
+        },
+        groundingMetadata: this.groundingMetadata,
+        citationMetadata: this.citationMetadata,
+        errorCode: finishReason === FinishReason.STOP ? void 0 : finishReason,
+        errorMessage: finishReason === FinishReason.STOP ? void 0 : candidate.finishMessage,
+        usageMetadata: this.usageMetadata,
+        finishReason,
+        partial: false
+      };
+    }
+    return void 0;
+  }
+}
+export {
+  StreamingResponseAggregator
+};

package/dist/esm/utils/variant_utils.js

@@ -1,3 +1,5 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
 /**
  * @license
  * Copyright 2025 Google LLC

package/dist/esm/version.js

@@ -1,9 +1,11 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "0.6.1";
+const version = "1.1.0";
 export {
   version
 };

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

@@ -26,6 +26,7 @@ export declare class Context extends ReadonlyContext {
     readonly eventActions: EventActions;
     readonly functionCallId?: string;
     toolConfirmation?: ToolConfirmation;
+    readonly abortSignal?: AbortSignal;
     /**
      * @param options The configuration options for the Context.
      * @param options.invocationContext The invocation context.

package/dist/types/agents/invocation_context.d.ts

@@ -34,6 +34,7 @@ export interface InvocationContextParams {
     liveRequestQueue?: LiveRequestQueue;
     activeStreamingTools?: Record<string, ActiveStreamingTool>;
     pluginManager: PluginManager;
+    abortSignal?: AbortSignal;
 }
 /**
  * An invocation context represents the data of a single invocation of an agent.
@@ -135,6 +136,10 @@ export declare class InvocationContext {
      * The manager for keeping track of plugins in this invocation.
      */
     pluginManager: PluginManager;
+    /**
+     * The abort signal for the invocation.
+     */
+    readonly abortSignal?: AbortSignal;
     /**
      * @param params The parameters for creating an invocation context.
      */

package/dist/types/agents/processors/tool_filter_request_processor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../../events/event.js';
+import { LlmRequest } from '../../models/llm_request.js';
+import { InvocationContext } from '../invocation_context.js';
+import { BaseLlmRequestProcessor } from './base_llm_processor.js';
+export declare class ToolFilterRequestProcessor extends BaseLlmRequestProcessor {
+    /** Filters the set of tools on the request based on plugins. */
+    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, void>;
+}
+export declare const TOOL_FILTER_REQUEST_PROCESSOR: ToolFilterRequestProcessor;

package/dist/types/agents/routed_agent.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../events/event.js';
+import { BaseAgent, BaseAgentConfig } from './base_agent.js';
+import { InvocationContext } from './invocation_context.js';
+/**
+ * A unique symbol to identify ADK agent classes.
+ * Defined once and shared by all RoutedAgent instances.
+ */
+declare const ROUTED_AGENT_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of RoutedAgent.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of RoutedAgent, false otherwise.
+ */
+export declare function isRoutedAgent(obj: unknown): obj is RoutedAgent;
+/**
+ * Type definition for a function that selects an agent based on the invocation context.
+ */
+export type AgentRouter = (agents: Readonly<Record<string, BaseAgent>>, context: InvocationContext, errorContext?: {
+    failedKeys: ReadonlySet<string>;
+    lastError: unknown;
+}) => Promise<string | undefined> | string | undefined;
+/**
+ * Configuration for the RoutingAgent.
+ */
+export interface RoutedAgentConfig extends BaseAgentConfig {
+    /**
+     * The set of agents to route to. Can be an array of agents or a Record of keys to agents.
+     * If an array is provided, the agent names will be used as keys.
+     */
+    agents: Readonly<Record<string, BaseAgent>> | BaseAgent[];
+    /**
+     * The function to select which agent to run.
+     */
+    router: AgentRouter;
+}
+/**
+ * A BaseAgent implementation that delegates to one of multiple agents based on a router function.
+ * Routing is strictly limited to the agents passed in the config.
+ */
+export declare class RoutedAgent extends BaseAgent {
+    readonly [ROUTED_AGENT_SIGNATURE_SYMBOL] = true;
+    private readonly agents;
+    private readonly router;
+    constructor(config: RoutedAgentConfig);
+    /**
+     * Runs the selected agent via text-based conversation.
+     */
+    protected runAsyncImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
+    /**
+     * Runs the selected agent via video/audio-based conversation.
+     */
+    protected runLiveImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
+}
+export {};

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

@@ -24,6 +24,10 @@ export interface HttpAuth {
      */
     scheme: string;
     credentials: HttpCredentials;
+    /**
+     * Additional HTTP headers to include in the request.
+     */
+    additionalHeaders?: Record<string, string>;
 }
 /**
  * Represents credential value and its metadata for a OAuth2 credential.
@@ -36,7 +40,9 @@ export interface OAuth2Auth {
      * verify the state
      */
     authUri?: string;
+    nonce?: string;
     state?: string;
+    codeVerifier?: string;
     /**
      * tool or adk can decide the redirect_uri if they don't want client to decide
      */
@@ -45,8 +51,11 @@ export interface OAuth2Auth {
     authCode?: string;
     accessToken?: string;
     refreshToken?: string;
+    idToken?: string;
     expiresAt?: number;
     expiresIn?: number;
+    audience?: string;
+    tokenEndpointAuthMethod?: string;
 }
 /**
  * Represents Google Service Account configuration.
@@ -118,6 +127,14 @@ export interface ServiceAccount {
     serviceAccountCredential?: ServiceAccountCredential;
     scopes?: string[];
     useDefaultCredential?: boolean;
+    /**
+     * If true, get an ID token instead of an access token.
+     */
+    useIdToken?: boolean;
+    /**
+     * The audience for the ID token. Required if useIdToken is true.
+     */
+    audience?: string;
 }
 export declare enum AuthCredentialTypes {
     /**

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

@@ -15,6 +15,7 @@ export declare class AuthHandler {
     private readonly authConfig;
     constructor(authConfig: AuthConfig);
     getAuthResponse(state: State): AuthCredential | undefined;
+    parseAndStoreAuthResponse(state: State): Promise<void>;
     generateAuthRequest(): AuthConfig;
     /**
      * Generates an response containing the auth uri for user to sign in.

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

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InvocationContext } from '../agents/invocation_context.js';
+import { BaseLlmRequestProcessor } from '../agents/processors/base_llm_processor.js';
+import { Event } from '../events/event.js';
+export declare class AuthPreprocessor extends BaseLlmRequestProcessor {
+    runAsync(invocationContext: InvocationContext): AsyncGenerator<Event, void, void>;
+}
+export declare const AUTH_PREPROCESSOR: AuthPreprocessor;

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

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthScheme } from './auth_schemes.js';
+import { BaseAuthProvider } from './base_auth_provider.js';
+/**
+ * Registry for auth provider instances.
+ */
+export declare class AuthProviderRegistry {
+    private readonly providers;
+    /**
+     * Register a provider instance for an auth scheme type.
+     *
+     * @param authSchemeType The auth scheme type (e.g., 'oauth2', 'apiKey').
+     * @param providerInstance The provider instance to register.
+     */
+    register(authSchemeType: string, providerInstance: BaseAuthProvider): void;
+    /**
+     * Get the provider instance for an auth scheme.
+     *
+     * @param authScheme The auth scheme to get provider for.
+     * @returns The provider instance if registered, undefined otherwise.
+     */
+    getProvider(authScheme: AuthScheme): BaseAuthProvider | undefined;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthCredential } from './auth_credential.js';
+import { AuthConfig } from './auth_tool.js';
+/**
+ * Abstract base interface for custom authentication providers.
+ */
+export interface BaseAuthProvider {
+    /**
+     * Provide an AuthCredential asynchronously.
+     *
+     * @param authConfig The current authentication configuration.
+     * @param context The current callback context (placeholder).
+     * @returns The retrieved AuthCredential, or undefined if unavailable.
+     */
+    getAuthCredential(authConfig: AuthConfig, context?: unknown): Promise<AuthCredential | undefined>;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Context } from '../../agents/context.js';
+import { AuthCredential } from '../auth_credential.js';
+import { AuthConfig } from '../auth_tool.js';
+import { BaseCredentialService } from './base_credential_service.js';
+/**
+ * Class for implementation of credential service using session state as the store.
+ *
+ * Warning: Storing credentials in session state is insecure. Session state may be
+ * persisted in plaintext, logged, or accessible via XSS depending on the runner
+ * environment. Use a secure vault or encrypted storage for production applications.
+ */
+export declare class SessionStateCredentialService implements BaseCredentialService {
+    loadCredential(authConfig: AuthConfig, toolContext: Context): Promise<AuthCredential | undefined>;
+    saveCredential(authConfig: AuthConfig, toolContext: Context): Promise<void>;
+}

package/dist/types/auth/exchanger/base_credential_exchanger.d.ts

@@ -10,6 +10,13 @@ import { AuthScheme } from '../auth_schemes.js';
  */
 export declare class CredentialExchangeError extends Error {
 }
+/**
+ * Result of a credential exchange.
+ */
+export interface ExchangeResult {
+    credential: AuthCredential;
+    wasExchanged: boolean;
+}
 /**
  * Base interface for credential exchangers.
  *
@@ -20,13 +27,13 @@ export interface BaseCredentialExchanger {
     /**
      * Exchange credential if needed.
      *
-     * @param authCredential - The credential to exchange.
-     * @param authScheme - The authentication scheme (optional, some exchangers don't need it).
+     * @param params.authCredential - The credential to exchange.
+     * @param params.authScheme - The authentication scheme (optional, some exchangers don't need it).
      * @returns The exchanged credential.
      * @throws CredentialExchangeError: If credential exchange fails.
      */
-    exchange({ authCredential, authScheme, }: {
-        authCredential: AuthCredential;
+    exchange(params: {
         authScheme?: AuthScheme;
-    }): Promise<AuthCredential>;
+        authCredential: AuthCredential;
+    }): Promise<ExchangeResult>;
 }

package/dist/types/auth/oauth2/oauth2_credential_exchanger.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthCredential } from '../auth_credential.js';
+import { AuthScheme, OAuthGrantType } from '../auth_schemes.js';
+import { BaseCredentialExchanger, ExchangeResult } from '../exchanger/base_credential_exchanger.js';
+/**
+ * Exchanges OAuth2 credentials from authorization responses using standard fetch.
+ */
+export declare class OAuth2CredentialExchanger implements BaseCredentialExchanger {
+    exchange({ authCredential, authScheme, }: {
+        authCredential: AuthCredential;
+        authScheme?: AuthScheme;
+    }): Promise<ExchangeResult>;
+}
+export declare function determineGrantType(authScheme: AuthScheme): OAuthGrantType | undefined;
+export declare function exchangeClientCredentials({ authCredential, authScheme, }: {
+    authCredential: AuthCredential;
+    authScheme: AuthScheme;
+}): Promise<ExchangeResult>;
+export declare function exchangeAuthorizationCode({ authCredential, authScheme, }: {
+    authCredential: AuthCredential;
+    authScheme: AuthScheme;
+}): Promise<ExchangeResult>;

package/dist/types/auth/oauth2/oauth2_credential_refresher.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthCredential } from '../auth_credential.js';
+import { AuthScheme } from '../auth_schemes.js';
+import { BaseCredentialRefresher } from '../refresher/base_credential_refresher.js';
+/**
+ * Refreshes OAuth2 credentials using standard fetch.
+ */
+export declare class OAuth2CredentialRefresher implements BaseCredentialRefresher {
+    /**
+     * Check if the OAuth2 credential needs to be refreshed.
+     *
+     * @param authCredential The OAuth2 credential to check.
+     * @param authScheme The OAuth2 authentication scheme (optional).
+     * @returns True if the credential needs to be refreshed, False otherwise.
+     */
+    isRefreshNeeded(authCredential: AuthCredential): Promise<boolean>;
+    /**
+     * Refresh the OAuth2 credential.
+     *
+     * @param authCredential The OAuth2 credential to refresh.
+     * @param authScheme The OAuth2 authentication scheme.
+     * @returns The refreshed credential.
+     */
+    refresh(authCredential: AuthCredential, authScheme?: AuthScheme): Promise<AuthCredential>;
+}