@softactivate/adk 1.1.0

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

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Type definition for a function that selects an item based on the context.
+ */
+export type Router<T, C> = (items: Readonly<Record<string, T>>, context: C, errorContext?: {
+    failedKeys: ReadonlySet<string>;
+    lastError: unknown;
+}) => Promise<string | undefined> | string | undefined;
+/**
+ * Runs a core operation with selection and failover support.
+ * Internal helper to unify Promise and Generator logic.
+ */
+export declare function runWithRouting<T, C, TYield>(items: Readonly<Record<string, T>>, context: C, router: Router<T, C>, runFn: (item: T) => AsyncGenerator<TYield, void, void> | Promise<TYield>): AsyncGenerator<TYield, void, void>;

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

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CodeExecutionLanguage, FileContentEncoding } from '../code_executors/code_execution_utils.js';
+/**
+ * Gets the MIME type and file content encoding for a given file extension.
+ * @param ext The file extension (e.g., '.js', '.png').
+ * @returns An object containing the mimeType and encoding.
+ */
+export declare function getMimeTypeAndEncoding(ext: string): {
+    mimeType: string;
+    encoding: FileContentEncoding;
+};
+/**
+ * Gets the code execution language for a given file extension.
+ * @param ext The file extension (e.g., '.js', '.py').
+ * @returns The code execution language.
+ */
+export declare function getScriptLanguageByExtension(ext: string): CodeExecutionLanguage;

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

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { File } from '../code_executors/code_execution_utils.js';
+/**
+ * Creates files with the given paths in the current working directory.
+ * @param files The files to materialize.
+ */
+export declare function materializeFiles(files: File[], dir?: string): Promise<File[]>;

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

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Schema } from '@google/genai';
+import { z } from 'zod';
+declare const MCPToolSchemaObject: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type MCPToolSchema = z.infer<typeof MCPToolSchemaObject>;
+export declare function toGeminiSchema(mcpSchema?: MCPToolSchema): Schema | undefined;
+export {};

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

@@ -0,0 +1,38 @@
+/** Log levels for the logger. */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+/**
+ * Logger interface for ADK.
+ */
+export interface Logger {
+    log(level: LogLevel, ...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    setLogLevel(level: LogLevel): void;
+}
+/**
+ * Sets a custom logger for ADK, or null to disable logging.
+ */
+export declare function setLogger(customLogger: Logger | null): void;
+/**
+ * Gets the current logger instance.
+ */
+export declare function getLogger(): Logger;
+/**
+ * Resets the logger to the default SimpleLogger.
+ */
+export declare function resetLogger(): void;
+/**
+ * Sets the log level for the logger.
+ */
+export declare function setLogLevel(level: LogLevel): void;
+/**
+ * The logger instance for ADK.
+ */
+export declare const logger: Logger;

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

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Extract the actual model name from either simple or path-based format.
+ *
+ * @param modelString Either a simple model name like "gemini-2.5-pro" or
+ *     a path-based model name like "projects/.../models/gemini-2.0-flash-001"
+ * @return The extracted model name (e.g., "gemini-2.5-pro")
+ */
+export declare function extractModelName(modelString: string): string;
+/**
+ * Check if the model is a Gemini model using regex patterns.
+ *
+ * @param modelString Either a simple model name or path - based model name
+ * @return true if it's a Gemini model, false otherwise.
+ */
+export declare function isGeminiModel(modelString: string): boolean;
+/**
+ * Check if the model is a Gemini 1.x model using regex patterns.
+ *
+ * @param modelString Either a simple model name or path - based model name
+ * @return true if it's a Gemini 1.x model, false otherwise.
+ */
+export declare function isGemini1Model(modelString: string): boolean;
+/**
+ * Check if the model is a Gemini 2.x model using regex patterns.
+ *
+ * @param modelString Either a simple model name or path - based model name
+ * @return true if it's a Gemini 2.x model, false otherwise.
+ */
+export declare function isGemini2OrAbove(modelString: string): boolean;
+/**
+ * Returns True when Gemini model-id validation should be bypassed.
+ */
+export declare function isGeminiModelIdCheckDisabled(): boolean;

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

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Converts an object with snake_case keys to camelCase keys.
+ *
+ * @param obj The object to convert.
+ * @param preserveKeys Keys to preserve in their original form.
+ * @returns The object with camelCase keys.
+ */
+export declare function toCamelCase(obj: unknown, preserveKeys?: string[]): unknown;
+/**
+ * Converts an object with camelCase keys to snake_case keys.
+ *
+ * @param obj The object to convert.
+ * @param preserveKeys Keys to preserve in their original form.
+ * @returns The object with snake_case keys.
+ */
+export declare function toSnakeCase(obj: unknown, preserveKeys?: string[]): unknown;

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

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Schema } from '@google/genai';
+import { z as z3 } from 'zod/v3';
+import { z as z4 } from 'zod/v4';
+/**
+ * Returns true if the given object is a ZodObject (supports both Zod v3 and v4).
+ */
+export declare function isZodObject(obj: unknown): obj is z3.ZodObject<z3.ZodRawShape> | z4.ZodObject<z4.ZodRawShape>;
+export declare function zodObjectToSchema(schema: z3.ZodObject<z3.ZodRawShape> | z4.ZodObject<z4.ZodRawShape>): Schema;

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

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GenerateContentResponse } from '@google/genai';
+import { LlmResponse } from '../models/llm_response.js';
+/**
+ * Aggregates partial streaming responses.
+ *
+ * It aggregates content from partial responses, and generates LlmResponses for
+ * individual (partial) model responses, as well as for aggregated content.
+ */
+export declare class StreamingResponseAggregator {
+    private readonly isProgressiveMode;
+    private usageMetadata?;
+    private groundingMetadata?;
+    private citationMetadata?;
+    private response?;
+    private text;
+    private thoughtText;
+    private partsSequence;
+    private currentTextBuffer;
+    private currentTextIsThought?;
+    private finishReason?;
+    private currentFcName?;
+    private currentFcArgs;
+    private currentFcId?;
+    private currentThoughtSignature?;
+    private lastThoughtSignature?;
+    constructor(isProgressiveMode?: boolean);
+    private flushTextBufferToSequence;
+    private getValueFromPartialArg;
+    private setValueByJsonPath;
+    private flushFunctionCallToSequence;
+    private processStreamingFunctionCall;
+    private processFunctionCallPart;
+    processResponse(response: GenerateContentResponse): AsyncGenerator<LlmResponse, void, void>;
+    close(): LlmResponse | undefined;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The Google LLM variant to use.
+ * see
+ * https://google.github.io/adk-docs/get-started/quickstart/#set-up-the-model
+ */
+export declare enum GoogleLLMVariant {
+    /**
+     * For using credentials from Google Vertex AI
+     */
+    VERTEX_AI = "VERTEX_AI",
+    /**
+     * For using API Key from Google AI Studio
+     */
+    GEMINI_API = "GEMINI_API"
+}
+/**
+ * Gets the Google LLM variant to use.
+ */
+export declare function getGoogleLlmVariant(): GoogleLLMVariant;

package/dist/types/version.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const version = "1.1.0";

package/dist/web/a2a/a2a_event.js

@@ -0,0 +1,271 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { randomUUID } from "../utils/env_aware_utils.js";
+var MessageRole = /* @__PURE__ */ ((MessageRole2) => {
+  MessageRole2["USER"] = "user";
+  MessageRole2["AGENT"] = "agent";
+  return MessageRole2;
+})(MessageRole || {});
+var TaskState = /* @__PURE__ */ ((TaskState2) => {
+  TaskState2["SUBMITTED"] = "submitted";
+  TaskState2["WORKING"] = "working";
+  TaskState2["COMPLETED"] = "completed";
+  TaskState2["FAILED"] = "failed";
+  TaskState2["CANCELED"] = "canceled";
+  TaskState2["REJECTED"] = "rejected";
+  TaskState2["INPUT_REQUIRED"] = "input-required";
+  return TaskState2;
+})(TaskState || {});
+function isTaskStatusUpdateEvent(event) {
+  return (event == null ? void 0 : event.kind) === "status-update";
+}
+function isTaskArtifactUpdateEvent(event) {
+  return (event == null ? void 0 : event.kind) === "artifact-update";
+}
+function isMessage(event) {
+  return (event == null ? void 0 : event.kind) === "message";
+}
+function isTask(event) {
+  return (event == null ? void 0 : event.kind) === "task";
+}
+function getEventMetadata(event) {
+  if (isTaskArtifactUpdateEvent(event)) {
+    return event.artifact.metadata || {};
+  }
+  if (isTaskStatusUpdateEvent(event) || isTask(event) || isMessage(event)) {
+    return event.metadata || {};
+  }
+  return {};
+}
+function isFailedTaskStatusUpdateEvent(event) {
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && event.status.state === "failed" /* FAILED */;
+}
+function isTerminalTaskStatusUpdateEvent(event) {
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && [
+    "completed" /* COMPLETED */,
+    "failed" /* FAILED */,
+    "canceled" /* CANCELED */,
+    "rejected" /* REJECTED */
+  ].includes(event.status.state);
+}
+function isInputRequiredTaskStatusUpdateEvent(event) {
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && event.status.state === "input-required" /* INPUT_REQUIRED */;
+}
+function getFailedTaskStatusUpdateEventError(event) {
+  var _a;
+  if (!isFailedTaskStatusUpdateEvent(event)) {
+    return void 0;
+  }
+  const parts = ((_a = event.status.message) == null ? void 0 : _a.parts) || [];
+  if (parts.length === 0) {
+    return void 0;
+  }
+  if (parts[0].kind !== "text") {
+    return void 0;
+  }
+  return parts[0].text;
+}
+function createTaskSubmittedEvent({
+  taskId,
+  contextId,
+  message,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: false,
+    status: {
+      state: "submitted" /* SUBMITTED */,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createTask({
+  contextId,
+  message,
+  taskId,
+  metadata
+}) {
+  return {
+    kind: "task",
+    id: taskId || randomUUID(),
+    contextId,
+    history: [message],
+    status: {
+      state: "submitted" /* SUBMITTED */,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createTaskWorkingEvent({
+  taskId,
+  contextId,
+  message,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: false,
+    status: {
+      state: "working" /* WORKING */,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createTaskCompletedEvent({
+  taskId,
+  contextId,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "completed" /* COMPLETED */,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createTaskArtifactUpdateEvent({
+  taskId,
+  contextId,
+  artifactId,
+  parts = [],
+  metadata,
+  append,
+  lastChunk
+}) {
+  return {
+    kind: "artifact-update",
+    taskId,
+    contextId,
+    append,
+    lastChunk,
+    artifact: {
+      artifactId: artifactId || randomUUID(),
+      parts
+    },
+    metadata
+  };
+}
+function createTaskFailedEvent({
+  taskId,
+  contextId,
+  error,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "failed" /* FAILED */,
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "agent",
+        taskId,
+        contextId,
+        parts: [
+          {
+            kind: "text",
+            text: error.message
+          }
+        ]
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createTaskInputRequiredEvent({
+  taskId,
+  contextId,
+  parts,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "input-required" /* INPUT_REQUIRED */,
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "agent",
+        taskId,
+        contextId,
+        parts
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createInputMissingErrorEvent({
+  taskId,
+  contextId,
+  parts,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "input-required" /* INPUT_REQUIRED */,
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "agent",
+        taskId,
+        contextId,
+        parts
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+export {
+  MessageRole,
+  TaskState,
+  createInputMissingErrorEvent,
+  createTask,
+  createTaskArtifactUpdateEvent,
+  createTaskCompletedEvent,
+  createTaskFailedEvent,
+  createTaskInputRequiredEvent,
+  createTaskSubmittedEvent,
+  createTaskWorkingEvent,
+  getEventMetadata,
+  getFailedTaskStatusUpdateEventError,
+  isFailedTaskStatusUpdateEvent,
+  isInputRequiredTaskStatusUpdateEvent,
+  isMessage,
+  isTask,
+  isTaskArtifactUpdateEvent,
+  isTaskStatusUpdateEvent,
+  isTerminalTaskStatusUpdateEvent
+};