@softactivate/adk 1.1.0

package/dist/cjs/utils/streaming_utils.js

@@ -0,0 +1,330 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var streaming_utils_exports = {};
+__export(streaming_utils_exports, {
+  StreamingResponseAggregator: () => StreamingResponseAggregator
+});
+module.exports = __toCommonJS(streaming_utils_exports);
+var import_genai = require("@google/genai");
+var import_jsonpath_plus = require("jsonpath-plus");
+var import_functions = require("../agents/functions.js");
+var import_feature_registry = require("../features/feature_registry.js");
+var import_llm_response = require("../models/llm_response.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class StreamingResponseAggregator {
+  constructor(isProgressiveMode = (0, import_feature_registry.isFeatureEnabled)(
+    import_feature_registry.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 = import_jsonpath_plus.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 = import_jsonpath_plus.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 : (0, import_functions.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 = (0, import_functions.generateClientFunctionCallId)();
+      }
+      if (part.thoughtSignature && !this.currentThoughtSignature) {
+        this.currentThoughtSignature = part.thoughtSignature;
+      }
+      this.processStreamingFunctionCall(fc);
+    } else {
+      if (fc.name) {
+        if (!fc.id) {
+          fc.id = (0, import_functions.generateClientFunctionCallId)();
+        }
+        this.flushTextBufferToSequence();
+        this.partsSequence.push(part);
+      }
+    }
+  }
+  async *processResponse(response) {
+    var _a, _b, _c;
+    this.response = response;
+    const llmResponse = (0, import_llm_response.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, _c, _d, _e, _f;
+    if (this.isProgressiveMode) {
+      this.flushTextBufferToSequence();
+      this.flushFunctionCallToSequence();
+      const finalParts = this.partsSequence;
+      if (finalParts.length === 0) {
+        return;
+      }
+      const candidate = (_b = (_a = this.response) == null ? void 0 : _a.candidates) == null ? void 0 : _b[0];
+      const finishReason = (_c = this.finishReason) != null ? _c : candidate == null ? void 0 : candidate.finishReason;
+      return {
+        content: {
+          role: "model",
+          parts: finalParts
+        },
+        groundingMetadata: this.groundingMetadata,
+        citationMetadata: this.citationMetadata,
+        errorCode: finishReason === import_genai.FinishReason.STOP ? void 0 : finishReason,
+        errorMessage: finishReason === import_genai.FinishReason.STOP ? void 0 : candidate == null ? void 0 : candidate.finishMessage,
+        usageMetadata: this.usageMetadata,
+        finishReason,
+        partial: false
+      };
+    }
+    if (this.text || this.thoughtText) {
+      const parts = [];
+      if (this.thoughtText) {
+        parts.push({ text: this.thoughtText, thought: true });
+      }
+      if (this.text) {
+        parts.push({ text: this.text });
+      }
+      const candidate = (_e = (_d = this.response) == null ? void 0 : _d.candidates) == null ? void 0 : _e[0];
+      const finishReason = (_f = this.finishReason) != null ? _f : candidate == null ? void 0 : candidate.finishReason;
+      return {
+        content: {
+          role: "model",
+          parts
+        },
+        groundingMetadata: this.groundingMetadata,
+        citationMetadata: this.citationMetadata,
+        errorCode: finishReason === import_genai.FinishReason.STOP ? void 0 : finishReason,
+        errorMessage: finishReason === import_genai.FinishReason.STOP ? void 0 : candidate == null ? void 0 : candidate.finishMessage,
+        usageMetadata: this.usageMetadata,
+        finishReason,
+        partial: false
+      };
+    }
+    return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StreamingResponseAggregator
+});

package/dist/cjs/utils/variant_utils.js

@@ -0,0 +1,49 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var variant_utils_exports = {};
+__export(variant_utils_exports, {
+  GoogleLLMVariant: () => GoogleLLMVariant,
+  getGoogleLlmVariant: () => getGoogleLlmVariant
+});
+module.exports = __toCommonJS(variant_utils_exports);
+var import_env_aware_utils = require("./env_aware_utils.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var GoogleLLMVariant = /* @__PURE__ */ ((GoogleLLMVariant2) => {
+  GoogleLLMVariant2["VERTEX_AI"] = "VERTEX_AI";
+  GoogleLLMVariant2["GEMINI_API"] = "GEMINI_API";
+  return GoogleLLMVariant2;
+})(GoogleLLMVariant || {});
+function getGoogleLlmVariant() {
+  return (0, import_env_aware_utils.getBooleanEnvVar)("GOOGLE_GENAI_USE_VERTEXAI") ? "VERTEX_AI" /* VERTEX_AI */ : "GEMINI_API" /* GEMINI_API */;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GoogleLLMVariant,
+  getGoogleLlmVariant
+});

package/dist/cjs/version.js

@@ -0,0 +1,39 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var version_exports = {};
+__export(version_exports, {
+  version: () => version
+});
+module.exports = __toCommonJS(version_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const version = "1.1.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  version
+});

package/dist/esm/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
+};