@softactivate/adk 1.1.0

package/dist/web/models/google_llm.js

@@ -0,0 +1,321 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  createPartFromText,
+  GoogleGenAI
+} from "@google/genai";
+import { getBooleanEnvVar, isBrowser } from "../utils/env_aware_utils.js";
+import { logger } from "../utils/logger.js";
+import { GoogleLLMVariant } from "../utils/variant_utils.js";
+import { StreamingResponseAggregator } from "../utils/streaming_utils.js";
+import { BaseLlm } from "./base_llm.js";
+import { GeminiLlmConnection } from "./gemini_llm_connection.js";
+import { createLlmResponse } from "./llm_response.js";
+class Gemini extends BaseLlm {
+  /**
+   * @param params The parameters for creating a Gemini instance.
+   */
+  constructor({
+    model,
+    apiKey,
+    vertexai,
+    project,
+    location,
+    headers
+  }) {
+    if (!model) {
+      model = "gemini-2.5-flash";
+    }
+    super({ model });
+    const params = geminiInitParams({
+      model,
+      vertexai,
+      project,
+      location,
+      apiKey
+    });
+    if (!params.vertexai && !params.apiKey) {
+      throw new Error(
+        "API key must be provided via constructor or GOOGLE_GENAI_API_KEY or GEMINI_API_KEY environment variable."
+      );
+    }
+    this.project = params.project;
+    this.location = params.location;
+    this.apiKey = params.apiKey;
+    this.headers = headers;
+    this.vertexai = !!params.vertexai;
+  }
+  /**
+   * Sends a request to the Gemini model.
+   *
+   * @param llmRequest LlmRequest, the request to send to the Gemini model.
+   * @param stream bool = false, whether to do streaming call.
+   * @yields LlmResponse: The model response.
+   */
+  generateContentAsync(llmRequest, stream = false, abortSignal) {
+    return __asyncGenerator(this, null, function* () {
+      var _a, _b, _c;
+      this.preprocessRequest(llmRequest);
+      this.maybeAppendUserContent(llmRequest);
+      logger.info(
+        "Sending out request, model: ".concat((_a = llmRequest.model) != null ? _a : this.model, ", backend: ").concat(this.apiBackend, ", stream: ").concat(stream)
+      );
+      if (!llmRequest.config) {
+        llmRequest.config = {};
+      }
+      if (llmRequest.config.httpOptions) {
+        llmRequest.config.httpOptions.headers = __spreadValues(__spreadValues({}, llmRequest.config.httpOptions.headers), this.trackingHeaders);
+      }
+      if (abortSignal) {
+        llmRequest.config.abortSignal = abortSignal;
+      }
+      if (stream) {
+        const streamResult = yield new __await(this.apiClient.models.generateContentStream({
+          model: (_b = llmRequest.model) != null ? _b : this.model,
+          contents: llmRequest.contents,
+          config: llmRequest.config
+        }));
+        const aggregator = new StreamingResponseAggregator();
+        try {
+          for (var iter2 = __forAwait(streamResult), more2, temp2, error2; more2 = !(temp2 = yield new __await(iter2.next())).done; more2 = false) {
+            const response = temp2.value;
+            try {
+              for (var iter = __forAwait(aggregator.processResponse(response)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+                const llmResponse = temp.value;
+                yield llmResponse;
+              }
+            } catch (temp) {
+              error = [temp];
+            } finally {
+              try {
+                more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+              } finally {
+                if (error)
+                  throw error[0];
+              }
+            }
+          }
+        } catch (temp2) {
+          error2 = [temp2];
+        } finally {
+          try {
+            more2 && (temp2 = iter2.return) && (yield new __await(temp2.call(iter2)));
+          } finally {
+            if (error2)
+              throw error2[0];
+          }
+        }
+        const finalResponse = aggregator.close();
+        if (finalResponse) {
+          yield finalResponse;
+        }
+      } else {
+        const response = yield new __await(this.apiClient.models.generateContent({
+          model: (_c = llmRequest.model) != null ? _c : this.model,
+          contents: llmRequest.contents,
+          config: llmRequest.config
+        }));
+        yield createLlmResponse(response);
+      }
+    });
+  }
+  getHttpOptions() {
+    return { headers: __spreadValues(__spreadValues({}, this.trackingHeaders), this.headers) };
+  }
+  get apiClient() {
+    if (this._apiClient) {
+      return this._apiClient;
+    }
+    if (this.vertexai) {
+      this._apiClient = new GoogleGenAI({
+        vertexai: this.vertexai,
+        project: this.project,
+        location: this.location,
+        httpOptions: this.getHttpOptions()
+      });
+    } else {
+      this._apiClient = new GoogleGenAI({
+        apiKey: this.apiKey,
+        httpOptions: this.getHttpOptions()
+      });
+    }
+    return this._apiClient;
+  }
+  get apiBackend() {
+    if (!this._apiBackend) {
+      this._apiBackend = this.apiClient.vertexai ? GoogleLLMVariant.VERTEX_AI : GoogleLLMVariant.GEMINI_API;
+    }
+    return this._apiBackend;
+  }
+  get liveApiVersion() {
+    if (!this._liveApiVersion) {
+      this._liveApiVersion = this.apiBackend === GoogleLLMVariant.VERTEX_AI ? "v1beta1" : "v1alpha";
+    }
+    return this._liveApiVersion;
+  }
+  getLiveHttpOptions() {
+    return {
+      headers: this.trackingHeaders,
+      apiVersion: this.liveApiVersion
+    };
+  }
+  get liveApiClient() {
+    if (!this._liveApiClient) {
+      this._liveApiClient = new GoogleGenAI({
+        apiKey: this.apiKey,
+        httpOptions: this.getLiveHttpOptions()
+      });
+    }
+    return this._liveApiClient;
+  }
+  /**
+   * Connects to the Gemini model and returns an llm connection.
+   *
+   * @param llmRequest LlmRequest, the request to send to the Gemini model.
+   * @returns BaseLlmConnection, the connection to the Gemini model.
+   */
+  async connect(llmRequest) {
+    var _a, _b, _c, _d;
+    if ((_a = llmRequest.liveConnectConfig) == null ? void 0 : _a.httpOptions) {
+      if (!llmRequest.liveConnectConfig.httpOptions.headers) {
+        llmRequest.liveConnectConfig.httpOptions.headers = {};
+      }
+      Object.assign(
+        llmRequest.liveConnectConfig.httpOptions.headers,
+        this.trackingHeaders
+      );
+      llmRequest.liveConnectConfig.httpOptions.apiVersion = this.liveApiVersion;
+    }
+    if ((_b = llmRequest.config) == null ? void 0 : _b.systemInstruction) {
+      llmRequest.liveConnectConfig.systemInstruction = {
+        role: "system",
+        // TODO - b/425992518: validate type casting works well.
+        parts: [
+          createPartFromText(llmRequest.config.systemInstruction)
+        ]
+      };
+    }
+    llmRequest.liveConnectConfig.tools = (_c = llmRequest.config) == null ? void 0 : _c.tools;
+    const liveSession = await this.liveApiClient.live.connect({
+      model: (_d = llmRequest.model) != null ? _d : this.model,
+      config: llmRequest.liveConnectConfig,
+      callbacks: {
+        // TODO - b/425992518: GenAI SDK inconsistent API, missing methods.
+        onmessage: () => {
+        }
+      }
+    });
+    return new GeminiLlmConnection(liveSession);
+  }
+  preprocessRequest(llmRequest) {
+    if (this.apiBackend === GoogleLLMVariant.GEMINI_API) {
+      if (llmRequest.config) {
+        llmRequest.config.labels = void 0;
+      }
+      if (llmRequest.contents) {
+        for (const content of llmRequest.contents) {
+          if (!content.parts) continue;
+          for (const part of content.parts) {
+            removeDisplayNameIfPresent(part.inlineData);
+            removeDisplayNameIfPresent(part.fileData);
+          }
+        }
+      }
+    }
+  }
+}
+/**
+ * A list of model name patterns that are supported by this LLM.
+ *
+ * @returns A list of supported models.
+ */
+Gemini.supportedModels = [
+  /gemini-.*/,
+  // fine-tuned vertex endpoint pattern
+  /projects\/.+\/locations\/.+\/endpoints\/.+/,
+  // vertex gemini long name
+  /projects\/.+\/locations\/.+\/publishers\/google\/models\/gemini.+/
+];
+function removeDisplayNameIfPresent(dataObj) {
+  if (dataObj && dataObj.displayName) {
+    dataObj.displayName = void 0;
+  }
+}
+function geminiInitParams({
+  model,
+  vertexai,
+  project,
+  location,
+  apiKey
+}) {
+  const params = { model, vertexai, project, location, apiKey };
+  params.vertexai = !!vertexai;
+  if (!params.vertexai && !isBrowser()) {
+    params.vertexai = getBooleanEnvVar("GOOGLE_GENAI_USE_VERTEXAI");
+  }
+  if (params.vertexai) {
+    if (!isBrowser() && !params.project) {
+      params.project = process.env["GOOGLE_CLOUD_PROJECT"];
+    }
+    if (!isBrowser() && !params.location) {
+      params.location = process.env["GOOGLE_CLOUD_LOCATION"];
+    }
+    if (!params.project) {
+      throw new Error(
+        "VertexAI project must be provided via constructor or GOOGLE_CLOUD_PROJECT environment variable."
+      );
+    }
+    if (!params.location) {
+      throw new Error(
+        "VertexAI location must be provided via constructor or GOOGLE_CLOUD_LOCATION environment variable."
+      );
+    }
+  } else {
+    if (!params.apiKey && !isBrowser()) {
+      params.apiKey = process.env["GOOGLE_GENAI_API_KEY"] || process.env["GEMINI_API_KEY"];
+    }
+  }
+  return params;
+}
+export {
+  Gemini,
+  geminiInitParams
+};

package/dist/web/models/llm_request.js

@@ -0,0 +1,52 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function appendInstructions(llmRequest, instructions) {
+  if (!llmRequest.config) {
+    llmRequest.config = {};
+  }
+  const newInstructions = instructions.join("\n\n");
+  if (llmRequest.config.systemInstruction) {
+    llmRequest.config.systemInstruction += "\n\n" + newInstructions;
+  } else {
+    llmRequest.config.systemInstruction = newInstructions;
+  }
+}
+function appendTools(llmRequest, tools) {
+  if (!(tools == null ? void 0 : tools.length)) {
+    return;
+  }
+  const functionDeclarations = [];
+  for (const tool of tools) {
+    const declaration = tool._getDeclaration();
+    if (declaration) {
+      functionDeclarations.push(declaration);
+      llmRequest.toolsDict[tool.name] = tool;
+    }
+  }
+  if (functionDeclarations.length) {
+    if (!llmRequest.config) {
+      llmRequest.config = {};
+    }
+    if (!llmRequest.config.tools) {
+      llmRequest.config.tools = [];
+    }
+    llmRequest.config.tools.push({ functionDeclarations });
+  }
+}
+function setOutputSchema(llmRequest, schema) {
+  if (!llmRequest.config) {
+    llmRequest.config = {};
+  }
+  llmRequest.config.responseSchema = schema;
+  llmRequest.config.responseMimeType = "application/json";
+}
+export {
+  appendInstructions,
+  appendTools,
+  setOutputSchema
+};

package/dist/web/models/llm_response.js

@@ -0,0 +1,45 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function createLlmResponse(response) {
+  var _a;
+  const usageMetadata = response.usageMetadata;
+  if (response.candidates && response.candidates.length > 0) {
+    const candidate = response.candidates[0];
+    if (((_a = candidate.content) == null ? void 0 : _a.parts) && candidate.content.parts.length > 0) {
+      return {
+        content: candidate.content,
+        groundingMetadata: candidate.groundingMetadata,
+        citationMetadata: candidate.citationMetadata,
+        usageMetadata,
+        finishReason: candidate.finishReason
+      };
+    }
+    return {
+      errorCode: candidate.finishReason,
+      errorMessage: candidate.finishMessage,
+      usageMetadata,
+      citationMetadata: candidate.citationMetadata,
+      finishReason: candidate.finishReason
+    };
+  }
+  if (response.promptFeedback) {
+    return {
+      errorCode: response.promptFeedback.blockReason,
+      errorMessage: response.promptFeedback.blockReasonMessage,
+      usageMetadata
+    };
+  }
+  return {
+    errorCode: "UNKNOWN_ERROR",
+    errorMessage: "Unknown error.",
+    usageMetadata
+  };
+}
+export {
+  createLlmResponse
+};

package/dist/web/models/registry.js

@@ -0,0 +1,95 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from "../utils/logger.js";
+import { ApigeeLlm } from "./apigee_llm.js";
+import { Gemini } from "./google_llm.js";
+class LRUCache {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const item = this.cache.get(key);
+    if (item) {
+      this.cache.delete(key);
+      this.cache.set(key, item);
+    }
+    return item;
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      const lruKey = this.cache.keys().next().value;
+      if (lruKey !== void 0) {
+        this.cache.delete(lruKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+}
+const _LLMRegistry = class _LLMRegistry {
+  /**
+   * Creates a new LLM instance.
+   * @param model The model name.
+   * @returns The LLM instance.
+   */
+  static newLlm(model) {
+    return new (_LLMRegistry.resolve(model))({ model });
+  }
+  static _register(modelNameRegex, llmCls) {
+    if (_LLMRegistry.llmRegistryDict.has(modelNameRegex)) {
+      logger.info(
+        "Updating LLM class for ".concat(modelNameRegex, " from ").concat(_LLMRegistry.llmRegistryDict.get(modelNameRegex), " to ").concat(llmCls)
+      );
+    }
+    _LLMRegistry.llmRegistryDict.set(modelNameRegex, llmCls);
+  }
+  /**
+   * Registers a new LLM class.
+   * @param llmCls The class that implements the model.
+   */
+  static register(llmCls) {
+    for (const regex of llmCls.supportedModels) {
+      _LLMRegistry._register(regex, llmCls);
+    }
+  }
+  /**
+   * Resolves the model to a BaseLlm subclass.
+   * @param model The model name.
+   * @returns The BaseLlm subclass.
+   * @throws If the model is not found.
+   */
+  static resolve(model) {
+    const cachedLlm = _LLMRegistry.resolveCache.get(model);
+    if (cachedLlm) {
+      return cachedLlm;
+    }
+    for (const [regex, llmClass] of _LLMRegistry.llmRegistryDict.entries()) {
+      const pattern = new RegExp(
+        "^".concat(regex instanceof RegExp ? regex.source : regex, "$"),
+        regex instanceof RegExp ? regex.flags : void 0
+      );
+      if (pattern.test(model)) {
+        _LLMRegistry.resolveCache.set(model, llmClass);
+        return llmClass;
+      }
+    }
+    throw new Error("Model ".concat(model, " not found."));
+  }
+};
+/**
+ * Key is the regex that matches the model name.
+ * Value is the class that implements the model.
+ */
+_LLMRegistry.llmRegistryDict = /* @__PURE__ */ new Map();
+_LLMRegistry.resolveCache = new LRUCache(32);
+let LLMRegistry = _LLMRegistry;
+LLMRegistry.register(Gemini);
+LLMRegistry.register(ApigeeLlm);
+export {
+  LLMRegistry
+};

package/dist/web/models/routed_llm.js

@@ -0,0 +1,122 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseLlm } from "./base_llm.js";
+import { experimental } from "../utils/experimental.js";
+import { runWithRouting } from "../utils/failover_utils.js";
+import { logger } from "../utils/logger.js";
+let RoutedLlm = class extends BaseLlm {
+  constructor({
+    models,
+    router,
+    modelName = "routed-llm"
+  }) {
+    const modelsMap = Array.isArray(models) ? Object.fromEntries(models.map((m) => [m.model, m])) : models;
+    const modelNames = Object.entries(modelsMap).map(
+      ([name, model]) => "".concat(name, " (").concat(model.model, ")")
+    );
+    const computedName = "RoutedLlm[".concat(modelNames.join(", "), "]");
+    super({ model: modelName === "routed-llm" ? computedName : modelName });
+    this.models = modelsMap;
+    this.router = router;
+  }
+  /**
+   * Generates content by delegating to the selected model.
+   */
+  generateContentAsync(llmRequest, stream) {
+    return __asyncGenerator(this, null, function* () {
+      logger.info("Routing request via ".concat(this.model));
+      yield* __yieldStar(runWithRouting(
+        this.models,
+        llmRequest,
+        this.router,
+        (model) => model.generateContentAsync(llmRequest, stream)
+      ));
+    });
+  }
+  /**
+   * Creates a live connection to the LLM by delegating to the selected model.
+   * This live connection cannot be switched mid-stream, it is tied to the model
+   * selected at the time of connection.
+   */
+  async connect(llmRequest) {
+    const generator = runWithRouting(
+      this.models,
+      llmRequest,
+      this.router,
+      (model) => model.connect(llmRequest)
+    );
+    const result = await generator.next();
+    if (result.done || result.value === void 0) {
+      throw new Error("Failed to establish connection: No connection yielded.");
+    }
+    return result.value;
+  }
+};
+RoutedLlm = __decorateClass([
+  experimental
+], RoutedLlm);
+export {
+  RoutedLlm
+};