@google/adk 0.6.1 → 1.1.0

package/dist/cjs/models/google_llm.js

@@ -32,6 +32,7 @@ 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_streaming_utils = require("../utils/streaming_utils.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");
@@ -81,80 +82,44 @@ class Gemini extends import_base_llm.BaseLlm {
    * @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;
+  async *generateContentAsync(llmRequest, stream = false, abortSignal) {
+    var _a, _b, _c;
     this.preprocessRequest(llmRequest);
     this.maybeAppendUserContent(llmRequest);
     import_logger.logger.info(
-      `Sending out request, model: ${llmRequest.model}, backend: ${this.apiBackend}, stream: ${stream}`
+      `Sending out request, model: ${(_a = llmRequest.model) != null ? _a : this.model}, backend: ${this.apiBackend}, stream: ${stream}`
     );
-    if ((_a = llmRequest.config) == null ? void 0 : _a.httpOptions) {
+    if (!llmRequest.config) {
+      llmRequest.config = {};
+    }
+    if (llmRequest.config.httpOptions) {
       llmRequest.config.httpOptions.headers = {
         ...llmRequest.config.httpOptions.headers,
         ...this.trackingHeaders
       };
     }
+    if (abortSignal) {
+      llmRequest.config.abortSignal = abortSignal;
+    }
     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;
+      const aggregator = new import_streaming_utils.StreamingResponseAggregator();
       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 = "";
+        for await (const llmResponse of aggregator.processResponse(response)) {
+          yield llmResponse;
         }
-        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
-        };
+      const finalResponse = aggregator.close();
+      if (finalResponse) {
+        yield finalResponse;
       }
     } else {
       const response = await this.apiClient.models.generateContent({
-        model: (_g = llmRequest.model) != null ? _g : this.model,
+        model: (_c = llmRequest.model) != null ? _c : this.model,
         contents: llmRequest.contents,
         config: llmRequest.config
       });

package/dist/cjs/models/routed_llm.js

@@ -0,0 +1,99 @@
+/**
+  * @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 __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 routed_llm_exports = {};
+__export(routed_llm_exports, {
+  RoutedLlm: () => RoutedLlm
+});
+module.exports = __toCommonJS(routed_llm_exports);
+var import_base_llm = require("./base_llm.js");
+var import_experimental = require("../utils/experimental.js");
+var import_failover_utils = require("../utils/failover_utils.js");
+var import_logger = require("../utils/logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let RoutedLlm = class extends import_base_llm.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]) => `${name} (${model.model})`
+    );
+    const computedName = `RoutedLlm[${modelNames.join(", ")}]`;
+    super({ model: modelName === "routed-llm" ? computedName : modelName });
+    this.models = modelsMap;
+    this.router = router;
+  }
+  /**
+   * Generates content by delegating to the selected model.
+   */
+  async *generateContentAsync(llmRequest, stream) {
+    import_logger.logger.info(`Routing request via ${this.model}`);
+    yield* (0, import_failover_utils.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 = (0, import_failover_utils.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([
+  import_experimental.experimental
+], RoutedLlm);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RoutedLlm
+});

package/dist/cjs/plugins/base_plugin.js

@@ -22,16 +22,31 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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 base_plugin_exports = {};
 __export(base_plugin_exports, {
-  BasePlugin: () => BasePlugin
+  BasePlugin: () => BasePlugin,
+  ContextCompactionTrigger: () => ContextCompactionTrigger
 });
 module.exports = __toCommonJS(base_plugin_exports);
+var import_experimental = require("../utils/experimental.js");
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var ContextCompactionTrigger = /* @__PURE__ */ ((ContextCompactionTrigger2) => {
+  ContextCompactionTrigger2["Manual"] = "Manual";
+  ContextCompactionTrigger2["Auto"] = "Auto";
+  return ContextCompactionTrigger2;
+})(ContextCompactionTrigger || {});
 class BasePlugin {
   /**
    * Initializes the plugin.
@@ -186,6 +201,18 @@ class BasePlugin {
   async onModelErrorCallback(params) {
     return;
   }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async beforeToolSelection(params) {
+    return;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async beforeContextCompaction(params) {
+    return;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async afterContextCompaction(params) {
+    return;
+  }
   /**
    * Callback executed before a tool is called.
    *
@@ -252,7 +279,17 @@ class BasePlugin {
     return;
   }
 }
+__decorateClass([
+  import_experimental.experimental
+], BasePlugin.prototype, "beforeToolSelection", 1);
+__decorateClass([
+  import_experimental.experimental
+], BasePlugin.prototype, "beforeContextCompaction", 1);
+__decorateClass([
+  import_experimental.experimental
+], BasePlugin.prototype, "afterContextCompaction", 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BasePlugin
+  BasePlugin,
+  ContextCompactionTrigger
 });

package/dist/cjs/plugins/plugin_manager.js

@@ -180,6 +180,45 @@ class PluginManager {
       "afterAgentCallback"
     );
   }
+  /**
+   * Runs the `beforeToolSelection` for all plugins.
+   */
+  async runBeforeToolSelection({
+    callbackContext,
+    tools
+  }) {
+    return await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.beforeToolSelection({ callbackContext, tools }),
+      "beforeToolSelection"
+    );
+  }
+  /**
+   * Runs the `beforeContextCompaction` for all plugins.
+   */
+  async runBeforeContextCompaction({
+    invocationContext,
+    trigger
+  }) {
+    await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.beforeContextCompaction({ invocationContext, trigger }),
+      "beforeContextCompaction"
+    );
+  }
+  /**
+   * Runs the `afterContextCompaction` for all plugins.
+   */
+  async runAfterContextCompaction({
+    invocationContext,
+    trigger
+  }) {
+    await this.runCallbacks(
+      this.plugins,
+      (plugin) => plugin.afterContextCompaction({ invocationContext, trigger }),
+      "afterContextCompaction"
+    );
+  }
   /**
    * Runs the `beforeToolCallback` for all plugins.
    */

package/dist/cjs/runner/runner.js

@@ -117,12 +117,15 @@ class Runner {
         ctx,
         this,
         async function* () {
-          var _a2;
+          var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
           const session = await this.sessionService.getSession({
             appName: this.appName,
             userId,
             sessionId
           });
+          if ((_a2 = params.abortSignal) == null ? void 0 : _a2.aborted) {
+            return;
+          }
           if (!session) {
             if (!this.appName) {
               throw new Error(
@@ -152,17 +155,21 @@ class Runner {
             session,
             userContent: newMessage,
             runConfig,
-            pluginManager: this.pluginManager
+            pluginManager: this.pluginManager,
+            abortSignal: params.abortSignal
           });
           const pluginUserMessage = await this.pluginManager.runOnUserMessageCallback({
             userMessage: newMessage,
             invocationContext
           });
+          if ((_b = params.abortSignal) == null ? void 0 : _b.aborted) {
+            return;
+          }
           if (pluginUserMessage) {
             newMessage = pluginUserMessage;
           }
           if (newMessage) {
-            if (!((_a2 = newMessage.parts) == null ? void 0 : _a2.length)) {
+            if (!((_c = newMessage.parts) == null ? void 0 : _c.length)) {
               throw new Error("No parts in the newMessage.");
             }
             if (runConfig.saveInputBlobsAsArtifacts) {
@@ -172,6 +179,9 @@ class Runner {
                 session.id,
                 newMessage
               );
+              if ((_d = params.abortSignal) == null ? void 0 : _d.aborted) {
+                return;
+              }
             }
             await this.sessionService.appendEvent({
               session,
@@ -182,6 +192,9 @@ class Runner {
                 content: newMessage
               })
             });
+            if ((_e = params.abortSignal) == null ? void 0 : _e.aborted) {
+              return;
+            }
           }
           invocationContext.agent = this.determineAgentForResumption(
             session,
@@ -191,6 +204,9 @@ class Runner {
             const beforeRunCallbackResponse = await this.pluginManager.runBeforeRunCallback({
               invocationContext
             });
+            if ((_f = params.abortSignal) == null ? void 0 : _f.aborted) {
+              return;
+            }
             if (beforeRunCallbackResponse) {
               const earlyExitEvent = (0, import_event.createEvent)({
                 invocationId: invocationContext.invocationId,
@@ -201,11 +217,17 @@ class Runner {
                 session,
                 event: earlyExitEvent
               });
+              if ((_g = params.abortSignal) == null ? void 0 : _g.aborted) {
+                return;
+              }
               yield earlyExitEvent;
             } else {
               for await (const event of invocationContext.agent.runAsync(
                 invocationContext
               )) {
+                if ((_h = params.abortSignal) == null ? void 0 : _h.aborted) {
+                  return;
+                }
                 if (!event.partial) {
                   await this.sessionService.appendEvent({ session, event });
                 }
@@ -213,6 +235,9 @@ class Runner {
                   invocationContext,
                   event
                 });
+                if ((_i = params.abortSignal) == null ? void 0 : _i.aborted) {
+                  return;
+                }
                 if (modifiedEvent) {
                   yield modifiedEvent;
                 } else {
@@ -220,6 +245,9 @@ class Runner {
                 }
               }
               await this.pluginManager.runAfterRunCallback({ invocationContext });
+              if ((_j = params.abortSignal) == null ? void 0 : _j.aborted) {
+                return;
+              }
             }
           }
         }

package/dist/cjs/sessions/db/operations.js

@@ -65,23 +65,16 @@ async function getConnectionOptionsFromUri(uri) {
   } else {
     throw new Error(`Unsupported database URI: ${uri}`);
   }
-  if (uri === "sqlite://:memory:") {
+  if (uri.startsWith("sqlite://")) {
     return {
       entities: import_schema.ENTITIES,
-      dbName: ":memory:",
+      dbName: uri === "sqlite://:memory:" ? ":memory:" : uri.substring("sqlite://".length),
       driver
     };
   }
-  const { host, port, username, password, pathname } = new URL(uri);
-  const hostName = host.split(":")[0];
-  const dbName = uri.startsWith("sqlite://") ? uri.substring("sqlite://".length) : pathname.slice(1);
   return {
     entities: import_schema.ENTITIES,
-    dbName,
-    host: hostName,
-    port: port ? parseInt(port) : void 0,
-    user: username,
-    password,
+    clientUrl: uri,
     driver
   };
 }