@softactivate/adk 1.1.0

package/dist/web/features/feature_registry.js

@@ -0,0 +1,107 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getBooleanEnvVar } from "../utils/env_aware_utils.js";
+import { logger } from "../utils/logger.js";
+var FeatureName = /* @__PURE__ */ ((FeatureName2) => {
+  FeatureName2["PROGRESSIVE_SSE_STREAMING"] = "PROGRESSIVE_SSE_STREAMING";
+  return FeatureName2;
+})(FeatureName || {});
+var FeatureStage = /* @__PURE__ */ ((FeatureStage2) => {
+  FeatureStage2["WIP"] = "wip";
+  FeatureStage2["EXPERIMENTAL"] = "experimental";
+  FeatureStage2["STABLE"] = "stable";
+  return FeatureStage2;
+})(FeatureStage || {});
+const FEATURE_REGISTRY = {
+  ["PROGRESSIVE_SSE_STREAMING" /* PROGRESSIVE_SSE_STREAMING */]: {
+    stage: "experimental" /* EXPERIMENTAL */,
+    defaultOn: false
+  }
+};
+const WARNED_FEATURES = /* @__PURE__ */ new Set();
+const FEATURE_OVERRIDES = {};
+function getFeatureConfig(featureName) {
+  return FEATURE_REGISTRY[featureName];
+}
+function registerFeature(featureName, config) {
+  FEATURE_REGISTRY[featureName] = config;
+}
+function overrideFeatureEnabled(featureName, enabled) {
+  const config = getFeatureConfig(featureName);
+  if (!config) {
+    throw new Error("Feature ".concat(featureName, " is not registered."));
+  }
+  if (enabled === void 0) {
+    delete FEATURE_OVERRIDES[featureName];
+  } else {
+    FEATURE_OVERRIDES[featureName] = enabled;
+  }
+}
+function isFeatureEnabled(featureName) {
+  const config = getFeatureConfig(featureName);
+  if (!config) {
+    throw new Error("Feature ".concat(featureName, " is not registered."));
+  }
+  if (featureName in FEATURE_OVERRIDES) {
+    const enabled = FEATURE_OVERRIDES[featureName];
+    if (enabled && config.stage !== "stable" /* STABLE */) {
+      emitNonStableWarningOnce(featureName, config.stage);
+    }
+    return enabled;
+  }
+  const enableVar = "ADK_ENABLE_".concat(featureName);
+  const disableVar = "ADK_DISABLE_".concat(featureName);
+  if (getBooleanEnvVar(enableVar)) {
+    if (config.stage !== "stable" /* STABLE */) {
+      emitNonStableWarningOnce(featureName, config.stage);
+    }
+    return true;
+  }
+  if (getBooleanEnvVar(disableVar)) {
+    return false;
+  }
+  if (config.stage !== "stable" /* STABLE */ && config.defaultOn) {
+    emitNonStableWarningOnce(featureName, config.stage);
+  }
+  return config.defaultOn;
+}
+function emitNonStableWarningOnce(featureName, featureStage) {
+  if (!WARNED_FEATURES.has(featureName)) {
+    WARNED_FEATURES.add(featureName);
+    logger.warn(
+      "[".concat(featureStage.toUpperCase(), "] feature ").concat(featureName, " is enabled.")
+    );
+  }
+}
+async function withTemporaryFeatureOverride(featureName, enabled, callback) {
+  const config = getFeatureConfig(featureName);
+  if (!config) {
+    throw new Error("Feature ".concat(featureName, " is not registered."));
+  }
+  const hadOverride = featureName in FEATURE_OVERRIDES;
+  const originalValue = FEATURE_OVERRIDES[featureName];
+  FEATURE_OVERRIDES[featureName] = enabled;
+  try {
+    return await callback();
+  } finally {
+    if (hadOverride) {
+      FEATURE_OVERRIDES[featureName] = originalValue;
+    } else {
+      delete FEATURE_OVERRIDES[featureName];
+    }
+  }
+}
+export {
+  FeatureName,
+  FeatureStage,
+  getFeatureConfig,
+  isFeatureEnabled,
+  overrideFeatureEnabled,
+  registerFeature,
+  withTemporaryFeatureOverride
+};

package/dist/web/index.js

@@ -0,0 +1,50 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AGENT_CARD_PATH, RemoteA2AAgent } from "./a2a/a2a_remote_agent.js";
+import { getA2AAgentCard } from "./a2a/agent_card.js";
+import { A2AAgentExecutor } from "./a2a/agent_executor.js";
+import { toA2a } from "./a2a/agent_to_a2a.js";
+import { FileArtifactService } from "./artifacts/file_artifact_service.js";
+import { GcsArtifactService } from "./artifacts/gcs_artifact_service.js";
+import { getArtifactServiceFromUri } from "./artifacts/registry.js";
+import {
+  UnsafeLocalCodeExecutor
+} from "./code_executors/unsafe_local_code_executor.js";
+export * from "./common.js";
+import { DatabaseSessionService } from "./sessions/database_session_service.js";
+import { getSessionServiceFromUri } from "./sessions/registry.js";
+import {
+  loadAllSkillsInDir,
+  loadSkillFromDir,
+  validateSkillDir
+} from "./skills/loader.js";
+import { RunSkillInlineScriptTool } from "./tools/skill/run_skill_inline_script_tool.js";
+import { RunSkillScriptTool } from "./tools/skill/run_skill_script_tool.js";
+export * from "./telemetry/google_cloud.js";
+export * from "./telemetry/setup.js";
+export * from "./tools/mcp/mcp_session_manager.js";
+export * from "./tools/mcp/mcp_tool.js";
+export * from "./tools/mcp/mcp_toolset.js";
+export {
+  A2AAgentExecutor,
+  AGENT_CARD_PATH,
+  DatabaseSessionService,
+  FileArtifactService,
+  GcsArtifactService,
+  RemoteA2AAgent,
+  RunSkillInlineScriptTool,
+  RunSkillScriptTool,
+  UnsafeLocalCodeExecutor,
+  getA2AAgentCard,
+  getArtifactServiceFromUri,
+  getSessionServiceFromUri,
+  loadAllSkillsInDir,
+  loadSkillFromDir,
+  toA2a,
+  validateSkillDir
+};

package/dist/web/index_web.js

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

package/dist/web/memory/base_memory_service.js

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

package/dist/web/memory/in_memory_memory_service.js

@@ -0,0 +1,71 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class InMemoryMemoryService {
+  constructor() {
+    this.memories = [];
+    this.sessionEvents = {};
+  }
+  async addSessionToMemory(session) {
+    const userKey = getUserKey(session.appName, session.userId);
+    if (!this.sessionEvents[userKey]) {
+      this.sessionEvents[userKey] = {};
+    }
+    this.sessionEvents[userKey][session.id] = session.events.filter(
+      (event) => {
+        var _a, _b, _c;
+        return ((_c = (_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length) != null ? _c : 0) > 0;
+      }
+    );
+  }
+  async searchMemory(req) {
+    var _a, _b;
+    const userKey = getUserKey(req.appName, req.userId);
+    if (!this.sessionEvents[userKey]) {
+      return Promise.resolve({ memories: [] });
+    }
+    const wordsInQuery = req.query.toLowerCase().split(/\s+/);
+    const response = { memories: [] };
+    for (const sessionEvents of Object.values(this.sessionEvents[userKey])) {
+      for (const event of sessionEvents) {
+        if (!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length)) {
+          continue;
+        }
+        const joinedText = event.content.parts.map((part) => part.text).filter((text) => !!text).join(" ");
+        const wordsInEvent = extractWordsLower(joinedText);
+        if (!wordsInEvent.size) {
+          continue;
+        }
+        const matchQuery = wordsInQuery.some(
+          (queryWord) => wordsInEvent.has(queryWord)
+        );
+        if (matchQuery) {
+          response.memories.push({
+            content: event.content,
+            author: event.author,
+            timestamp: formatTimestamp(event.timestamp)
+          });
+        }
+      }
+    }
+    return response;
+  }
+}
+function getUserKey(appName, userId) {
+  return "".concat(appName, "/").concat(userId);
+}
+function extractWordsLower(text) {
+  return new Set(
+    [...text.matchAll(/[A-Za-z]+/g)].map((match) => match[0].toLowerCase())
+  );
+}
+function formatTimestamp(timestamp) {
+  return new Date(timestamp).toISOString();
+}
+export {
+  InMemoryMemoryService
+};

package/dist/web/memory/memory_entry.js

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

package/dist/web/models/apigee_llm.js

@@ -0,0 +1,221 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 { isBrowser } from "../utils/env_aware_utils.js";
+import { logger } from "../utils/logger.js";
+import { Gemini, geminiInitParams } from "./google_llm.js";
+const APIGEE_PROXY_URL_ENV_VARIABLE_NAME = "APIGEE_PROXY_URL";
+class ApigeeLlm extends Gemini {
+  constructor({
+    model,
+    proxyUrl,
+    apiKey,
+    vertexai,
+    location,
+    project,
+    headers
+  }) {
+    var _a;
+    if (!validateModel(model)) {
+      throw new Error(
+        "Model ".concat(model, " is not a valid Apigee model, expected apigee/[<provider>/][<version>/]<model_id>")
+      );
+    }
+    super(__spreadProps(__spreadValues({}, apigeeToGeminiInitParams({ model, vertexai, project, location, apiKey })), {
+      headers
+    }));
+    this.proxyUrl = proxyUrl != null ? proxyUrl : "";
+    if (!isBrowser() && !this.proxyUrl) {
+      this.proxyUrl = (_a = process.env[APIGEE_PROXY_URL_ENV_VARIABLE_NAME]) != null ? _a : "";
+    }
+    if (!this.proxyUrl) {
+      throw new Error(
+        "Proxy URL must be provided via the constructor or ".concat(APIGEE_PROXY_URL_ENV_VARIABLE_NAME, " environment variable.")
+      );
+    }
+  }
+  getHttpOptions() {
+    const opts = super.getHttpOptions();
+    opts.baseUrl = this.proxyUrl;
+    return opts;
+  }
+  getLiveHttpOptions() {
+    const opts = super.getLiveHttpOptions();
+    opts.baseUrl = this.proxyUrl;
+    return opts;
+  }
+  identifyApiVersion() {
+    const modelTrimmed = this.model.startsWith("apigee/") ? this.model.substring("apigee/".length) : this.model;
+    const components = modelTrimmed.split("/");
+    if (components.length === 3) {
+      return components[1];
+    }
+    if (components.length === 2) {
+      if (components[0] != "vertex_ai" && components[0] != "gemini" && components[0].startsWith("v")) {
+        return components[0];
+      }
+    }
+    return this.vertexai ? "v1beta1" : "v1alpha";
+  }
+  get liveApiVersion() {
+    if (!this._apigeeLiveApiVersion) {
+      this._apigeeLiveApiVersion = this.identifyApiVersion();
+    }
+    return this._apigeeLiveApiVersion;
+  }
+  generateContentAsync(llmRequest, stream = false, abortSignal) {
+    return __asyncGenerator(this, null, function* () {
+      var _a;
+      const modelToUse = (_a = llmRequest.model) != null ? _a : this.model;
+      llmRequest.model = getModelId(modelToUse);
+      yield* __yieldStar(super.generateContentAsync(llmRequest, stream, abortSignal));
+    });
+  }
+  async connect(llmRequest) {
+    var _a;
+    const modelToUse = (_a = llmRequest.model) != null ? _a : this.model;
+    llmRequest.model = getModelId(modelToUse);
+    return super.connect(llmRequest);
+  }
+}
+/**
+ * A list of model name patterns that are supported by this LLM.
+ *
+ * @returns A list of supported models.
+ */
+ApigeeLlm.supportedModels = [
+  /apigee\/.*/
+];
+function apigeeToGeminiInitParams({
+  model,
+  vertexai,
+  project,
+  location,
+  apiKey
+}) {
+  var _a;
+  const params = geminiInitParams({ model, vertexai, project, location, apiKey });
+  params.vertexai = params.vertexai || ((_a = params.model) == null ? void 0 : _a.startsWith("apigee/vertex_ai/"));
+  if (params.vertexai) {
+    return params;
+  }
+  if (!params.apiKey) {
+    logger.warn(
+      'No API key provided when using a Gemini model, using a fake key "-".'
+    );
+    params.apiKey = "-";
+  }
+  return params;
+}
+function getModelId(model) {
+  if (!validateModel(model)) {
+    throw new Error(
+      "Model ".concat(model, " is not a valid Apigee model, expected apigee/[<provider>/][<version>/]<model_id>")
+    );
+  }
+  const components = model.split("/");
+  return components[components.length - 1];
+}
+function validateModel(model) {
+  const validProviders = ["vertex_ai", "gemini"];
+  if (!model.startsWith("apigee/")) {
+    return false;
+  }
+  const modelPart = model.substring("apigee/".length);
+  if (modelPart.length === 0) {
+    return false;
+  }
+  const components = modelPart.split("/", -1);
+  if (components[components.length - 1].length === 0) {
+    return false;
+  }
+  if (components.length == 1) {
+    return true;
+  }
+  if (components.length == 2) {
+    if (validProviders.includes(components[0])) {
+      return true;
+    }
+    return components[0].startsWith("v");
+  }
+  if (components.length == 3) {
+    if (!validProviders.includes(components[0])) {
+      return false;
+    }
+    return components[1].startsWith("v");
+  }
+  return false;
+}
+export {
+  ApigeeLlm
+};

package/dist/web/models/base_llm.js

@@ -0,0 +1,73 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+import { getClientLabels } from "../utils/client_labels.js";
+const BASE_MODEL_SYMBOL = Symbol.for("google.adk.baseModel");
+function isBaseLlm(obj) {
+  return typeof obj === "object" && obj !== null && BASE_MODEL_SYMBOL in obj && obj[BASE_MODEL_SYMBOL] === true;
+}
+_a = BASE_MODEL_SYMBOL;
+class BaseLlm {
+  /**
+   * Creates an instance of BaseLLM.
+   * @param params The parameters for creating a BaseLlm instance.
+   * @param params.model The name of the LLM, e.g. gemini-1.5-flash or
+   *     gemini-1.5-flash-001.
+   */
+  constructor({ model }) {
+    /**
+     * A unique symbol to identify BaseLlm classes.
+     */
+    this[_a] = true;
+    this.model = model;
+  }
+  get trackingHeaders() {
+    const labels = getClientLabels();
+    const headerValue = labels.join(" ");
+    return {
+      "x-goog-api-client": headerValue,
+      "user-agent": headerValue
+    };
+  }
+  /**
+   * Appends a user content, so that model can continue to output.
+   *
+   * @param llmRequest LlmRequest, the request to send to the LLM.
+   */
+  maybeAppendUserContent(llmRequest) {
+    var _a2;
+    if (llmRequest.contents.length === 0) {
+      llmRequest.contents.push({
+        role: "user",
+        parts: [
+          {
+            text: "Handle the requests as specified in the System Instruction."
+          }
+        ]
+      });
+    }
+    if (((_a2 = llmRequest.contents[llmRequest.contents.length - 1]) == null ? void 0 : _a2.role) !== "user") {
+      llmRequest.contents.push({
+        role: "user",
+        parts: [
+          {
+            text: "Continue processing previous requests as instructed. Exit or provide a summary if no more outputs are needed."
+          }
+        ]
+      });
+    }
+  }
+}
+/**
+ * List of supported models in regex for LlmRegistry.
+ */
+BaseLlm.supportedModels = [];
+export {
+  BaseLlm,
+  isBaseLlm
+};

package/dist/web/models/base_llm_connection.js

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

package/dist/web/models/gemini_llm_connection.js

@@ -0,0 +1,123 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+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;
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from "../utils/logger.js";
+class GeminiLlmConnection {
+  constructor(geminiSession) {
+    this.geminiSession = geminiSession;
+  }
+  /**
+   * Sends the conversation history to the gemini model.
+   *
+   * You call this method right after setting up the model connection.
+   * The model will respond if the last content is from user, otherwise it will
+   * wait for new user input before responding.
+   *
+   * @param history The conversation history to send to the model.
+   */
+  async sendHistory(history) {
+    const contents = history.filter(
+      (content) => {
+        var _a;
+        return content.parts && ((_a = content.parts[0]) == null ? void 0 : _a.text);
+      }
+    );
+    if (contents.length > 0) {
+      this.geminiSession.sendClientContent({
+        turns: contents,
+        turnComplete: contents[contents.length - 1].role === "user"
+      });
+    } else {
+      logger.info("no content is sent");
+    }
+  }
+  /**
+   * Sends a user content to the gemini model.
+   *
+   * The model will respond immediately upon receiving the content.
+   * If you send function responses, all parts in the content should be function
+   * responses.
+   *
+   * @param content The content to send to the model.
+   */
+  async sendContent(content) {
+    if (!content.parts) {
+      throw new Error("Content must have parts.");
+    }
+    if (content.parts[0].functionResponse) {
+      const functionResponses = content.parts.map((part) => part.functionResponse).filter((fr) => !!fr);
+      logger.debug("Sending LLM function response:", functionResponses);
+      this.geminiSession.sendToolResponse({
+        functionResponses
+      });
+    } else {
+      logger.debug("Sending LLM new content", content);
+      this.geminiSession.sendClientContent({
+        turns: [content],
+        turnComplete: true
+      });
+    }
+  }
+  /**
+   * Sends a chunk of audio or a frame of video to the model in realtime.
+   *
+   * @param blob The blob to send to the model.
+   */
+  async sendRealtime(blob) {
+    logger.debug("Sending LLM Blob:", blob);
+    this.geminiSession.sendRealtimeInput({ media: blob });
+  }
+  /**
+   * Builds a full text response.
+   *
+   * The text should not be partial and the returned LlmResponse is not be
+   * partial.
+   *
+   * @param text The text to be included in the response.
+   * @returns An LlmResponse containing the full text.
+   */
+  buildFullTextResponse(text) {
+    return {
+      content: {
+        role: "model",
+        parts: [{ text }]
+      }
+    };
+  }
+  // TODO(b/425992518): GenAI SDK inconsistent API, missing methods.
+  // eslint-disable-next-line require-yield
+  receive() {
+    return __asyncGenerator(this, null, function* () {
+      throw new Error("Not Implemented.");
+    });
+  }
+  /**
+   * Closes the llm server connection.
+   */
+  async close() {
+    this.geminiSession.close();
+  }
+}
+export {
+  GeminiLlmConnection
+};