@google/adk 0.1.0

package/dist/cjs/models/google_llm.js

@@ -0,0 +1,321 @@
+/**
+  * @license
+  * Copyright 2025 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 google_llm_exports = {};
+__export(google_llm_exports, {
+  Gemini: () => Gemini
+});
+module.exports = __toCommonJS(google_llm_exports);
+var import_genai = require("@google/genai");
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
+var import_logger = require("../utils/logger.js");
+var import_variant_utils = require("../utils/variant_utils.js");
+var import_version = require("../version.js");
+var import_base_llm = require("./base_llm.js");
+var import_gemini_llm_connection = require("./gemini_llm_connection.js");
+var import_llm_response = require("./llm_response.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const AGENT_ENGINE_TELEMETRY_TAG = "remote_reasoning_engine";
+const AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME = "GOOGLE_CLOUD_AGENT_ENGINE_ID";
+class Gemini extends import_base_llm.BaseLlm {
+  /**
+   * @param params The parameters for creating a Gemini instance.
+   */
+  constructor({
+    model = "gemini-2.5-flash",
+    apiKey,
+    vertexai,
+    project,
+    location,
+    headers
+  } = {}) {
+    super(model);
+    this.project = project;
+    this.location = location;
+    this.apiKey = apiKey;
+    this.headers = headers;
+    const canReadEnv = typeof process === "object";
+    this.vertexai = !!vertexai;
+    if (!this.vertexai && canReadEnv) {
+      const vertexAIfromEnv = process.env["GOOGLE_GENAI_USE_VERTEXAI"];
+      if (vertexAIfromEnv) {
+        this.vertexai = vertexAIfromEnv.toLowerCase() === "true" || vertexAIfromEnv === "1";
+      }
+    }
+    if (this.vertexai) {
+      if (canReadEnv && !this.project) {
+        this.project = process.env["GOOGLE_CLOUD_PROJECT"];
+      }
+      if (canReadEnv && !this.location) {
+        this.location = process.env["GOOGLE_CLOUD_LOCATION"];
+      }
+      if (!this.project) {
+        throw new Error(
+          "VertexAI project must be provided via constructor or GOOGLE_CLOUD_PROJECT environment variable."
+        );
+      }
+      if (!this.location) {
+        throw new Error(
+          "VertexAI location must be provided via constructor or GOOGLE_CLOUD_LOCATION environment variable."
+        );
+      }
+    } else {
+      if (!this.apiKey && canReadEnv) {
+        this.apiKey = process.env["GOOGLE_GENAI_API_KEY"] || process.env["GEMINI_API_KEY"];
+      }
+      if (!this.apiKey) {
+        throw new Error(
+          "API key must be provided via constructor or GOOGLE_GENAI_API_KEY or GEMINI_API_KEY environment variable."
+        );
+      }
+    }
+  }
+  /**
+   * 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.
+   */
+  async *generateContentAsync(llmRequest, stream = false) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    this.preprocessRequest(llmRequest);
+    this.maybeAppendUserContent(llmRequest);
+    import_logger.logger.info(
+      `Sending out request, model: ${llmRequest.model}, backend: ${this.apiBackend}, stream: ${stream}`
+    );
+    if ((_a = llmRequest.config) == null ? void 0 : _a.httpOptions) {
+      llmRequest.config.httpOptions.headers = {
+        ...llmRequest.config.httpOptions.headers,
+        ...this.trackingHeaders
+      };
+    }
+    if (stream) {
+      const streamResult = await this.apiClient.models.generateContentStream({
+        model: (_b = llmRequest.model) != null ? _b : this.model,
+        contents: llmRequest.contents,
+        config: llmRequest.config
+      });
+      let thoughtText = "";
+      let text = "";
+      let usageMetadata;
+      let lastResponse;
+      for await (const response of streamResult) {
+        lastResponse = response;
+        const llmResponse = (0, import_llm_response.createLlmResponse)(response);
+        usageMetadata = llmResponse.usageMetadata;
+        const firstPart = (_d = (_c = llmResponse.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0];
+        if (firstPart == null ? void 0 : firstPart.text) {
+          if ("thought" in firstPart && firstPart.thought) {
+            thoughtText += firstPart.text;
+          } else {
+            text += firstPart.text;
+          }
+          llmResponse.partial = true;
+        } else if ((thoughtText || text) && (!firstPart || !firstPart.inlineData)) {
+          const parts = [];
+          if (thoughtText) {
+            parts.push({ text: thoughtText, thought: true });
+          }
+          if (text) {
+            parts.push((0, import_genai.createPartFromText)(text));
+          }
+          yield {
+            content: {
+              role: "model",
+              parts
+            },
+            usageMetadata: llmResponse.usageMetadata
+          };
+          thoughtText = "";
+          text = "";
+        }
+        yield llmResponse;
+      }
+      if ((text || thoughtText) && ((_f = (_e = lastResponse == null ? void 0 : lastResponse.candidates) == null ? void 0 : _e[0]) == null ? void 0 : _f.finishReason) === import_genai.FinishReason.STOP) {
+        const parts = [];
+        if (thoughtText) {
+          parts.push({ text: thoughtText, thought: true });
+        }
+        if (text) {
+          parts.push({ text });
+        }
+        yield {
+          content: {
+            role: "model",
+            parts
+          },
+          usageMetadata
+        };
+      }
+    } else {
+      const response = await this.apiClient.models.generateContent({
+        model: (_g = llmRequest.model) != null ? _g : this.model,
+        contents: llmRequest.contents,
+        config: llmRequest.config
+      });
+      yield (0, import_llm_response.createLlmResponse)(response);
+    }
+  }
+  get apiClient() {
+    if (this._apiClient) {
+      return this._apiClient;
+    }
+    const combinedHeaders = {
+      ...this.trackingHeaders,
+      ...this.headers
+    };
+    if (this.vertexai) {
+      this._apiClient = new import_genai.GoogleGenAI({
+        vertexai: this.vertexai,
+        project: this.project,
+        location: this.location,
+        httpOptions: { headers: combinedHeaders }
+      });
+    } else {
+      this._apiClient = new import_genai.GoogleGenAI({
+        apiKey: this.apiKey,
+        httpOptions: { headers: combinedHeaders }
+      });
+    }
+    return this._apiClient;
+  }
+  get apiBackend() {
+    if (!this._apiBackend) {
+      this._apiBackend = this.apiClient.vertexai ? import_variant_utils.GoogleLLMVariant.VERTEX_AI : import_variant_utils.GoogleLLMVariant.GEMINI_API;
+    }
+    return this._apiBackend;
+  }
+  get trackingHeaders() {
+    if (!this._trackingHeaders) {
+      let frameworkLabel = `google-adk/${import_version.version}`;
+      if (!(0, import_env_aware_utils.isBrowser)() && process.env[AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME]) {
+        frameworkLabel = `${frameworkLabel}+${AGENT_ENGINE_TELEMETRY_TAG}`;
+      }
+      const languageLabel = `gl-typescript/${(0, import_env_aware_utils.isBrowser)() ? window.navigator.userAgent : process.version}`;
+      const versionHeaderValue = `${frameworkLabel} ${languageLabel}`;
+      this._trackingHeaders = {
+        "x-goog-api-client": versionHeaderValue,
+        "user-agent": versionHeaderValue
+      };
+    }
+    return this._trackingHeaders;
+  }
+  get liveApiVersion() {
+    if (!this._liveApiVersion) {
+      this._liveApiVersion = this.apiBackend === import_variant_utils.GoogleLLMVariant.VERTEX_AI ? "v1beta1" : "v1alpha";
+    }
+    return this._liveApiVersion;
+  }
+  get liveApiClient() {
+    if (!this._liveApiClient) {
+      this._liveApiClient = new import_genai.GoogleGenAI({
+        apiKey: this.apiKey,
+        httpOptions: {
+          headers: this.trackingHeaders,
+          apiVersion: this.liveApiVersion
+        }
+      });
+    }
+    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: [(0, import_genai.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 import_gemini_llm_connection.GeminiLlmConnection(liveSession);
+  }
+  preprocessRequest(llmRequest) {
+    if (this.apiBackend === import_variant_utils.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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Gemini
+});

package/dist/cjs/models/llm_request.js

@@ -0,0 +1,82 @@
+/**
+  * @license
+  * Copyright 2025 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 llm_request_exports = {};
+__export(llm_request_exports, {
+  appendInstructions: () => appendInstructions,
+  appendTools: () => appendTools,
+  setOutputSchema: () => setOutputSchema
+});
+module.exports = __toCommonJS(llm_request_exports);
+/**
+ * @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";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendInstructions,
+  appendTools,
+  setOutputSchema
+});

package/dist/cjs/models/llm_response.js

@@ -0,0 +1,71 @@
+/**
+  * @license
+  * Copyright 2025 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 llm_response_exports = {};
+__export(llm_response_exports, {
+  createLlmResponse: () => createLlmResponse
+});
+module.exports = __toCommonJS(llm_response_exports);
+/**
+ * @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,
+        usageMetadata,
+        finishReason: candidate.finishReason
+      };
+    }
+    return {
+      errorCode: candidate.finishReason,
+      errorMessage: candidate.finishMessage,
+      usageMetadata,
+      finishReason: candidate.finishReason
+    };
+  }
+  if (response.promptFeedback) {
+    return {
+      errorCode: response.promptFeedback.blockReason,
+      errorMessage: response.promptFeedback.blockReasonMessage,
+      usageMetadata
+    };
+  }
+  return {
+    errorCode: "UNKNOWN_ERROR",
+    errorMessage: "Unknown error.",
+    usageMetadata
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLlmResponse
+});

package/dist/cjs/models/registry.js

@@ -0,0 +1,121 @@
+/**
+  * @license
+  * Copyright 2025 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 registry_exports = {};
+__export(registry_exports, {
+  LLMRegistry: () => LLMRegistry
+});
+module.exports = __toCommonJS(registry_exports);
+var import_logger = require("../utils/logger.js");
+var import_google_llm = require("./google_llm.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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)) {
+      import_logger.logger.info(
+        `Updating LLM class for ${modelNameRegex} from ${_LLMRegistry.llmRegistryDict.get(modelNameRegex)} to ${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(
+        `^${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 ${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(import_google_llm.Gemini);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LLMRegistry
+});

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}