@google/adk 2.0.0 → 2.2.0

package/dist/cjs/memory/vertex_ai_rag_api.js

@@ -0,0 +1,120 @@
+/**
+  * @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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 vertex_ai_rag_api_exports = {};
+__export(vertex_ai_rag_api_exports, {
+  VertexRagApiClient: () => VertexRagApiClient
+});
+module.exports = __toCommonJS(vertex_ai_rag_api_exports);
+var import_google_auth_library = require("google-auth-library");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
+const _VertexRagApiClient = class _VertexRagApiClient {
+  constructor(options) {
+    this.host = `https://${options.location}-aiplatform.googleapis.com`;
+    this.auth = new import_google_auth_library.GoogleAuth({ scopes: [CLOUD_PLATFORM_SCOPE] });
+  }
+  /** Lists one page of the files in a corpus. */
+  async listRagFiles(params) {
+    const query = new URLSearchParams({ pageSize: String(params.pageSize) });
+    if (params.pageToken) {
+      query.set("pageToken", params.pageToken);
+    }
+    const url = `${this.host}/v1/${params.ragCorpus}/ragFiles?${query.toString()}`;
+    return this.send(url, {
+      method: "GET",
+      headers: await this.authHeaders(url)
+    });
+  }
+  /** Uploads `content` into a corpus as one RAG file. */
+  async uploadRagFile(params) {
+    const url = `${this.host}/upload/v1/${params.ragCorpus}/ragFiles:upload`;
+    const metadata = JSON.stringify({
+      ragFile: { displayName: params.displayName },
+      // Empty message: the corpus default chunking applies. The reference SDK
+      // omits this key unless chunking is configured, so it is optional here.
+      uploadRagFileConfig: {}
+    });
+    const body = new FormData();
+    body.append(
+      "metadata",
+      new Blob([metadata], { type: "application/json; charset=UTF-8" })
+    );
+    body.append(
+      "file",
+      new Blob([params.content], { type: "text/plain; charset=UTF-8" }),
+      "content.txt"
+    );
+    const headers = await this.authHeaders(url);
+    headers.set("X-Goog-Upload-Protocol", "multipart");
+    const response = await this.send(url, {
+      method: "POST",
+      headers,
+      body
+    });
+    if (response.error) {
+      throw new Error(
+        `Vertex AI RAG file upload was rejected: ${JSON.stringify(response.error)}`
+      );
+    }
+  }
+  /** Runs a retrieval query over a corpus. */
+  async retrieveContexts(params) {
+    const url = `${this.host}/v1/${params.parent}:retrieveContexts`;
+    const headers = await this.authHeaders(url);
+    headers.set("Content-Type", "application/json");
+    return this.send(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        vertexRagStore: params.vertexRagStore,
+        query: params.query
+      })
+    });
+  }
+  async authHeaders(url) {
+    const client = await this.auth.getClient();
+    return client.getRequestHeaders(url);
+  }
+  async send(url, init) {
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      throw new Error(
+        `Vertex AI RAG request failed with status ${response.status}: ${await response.text()}`
+      );
+    }
+    return await response.json();
+  }
+};
+__name(_VertexRagApiClient, "VertexRagApiClient");
+let VertexRagApiClient = _VertexRagApiClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VertexRagApiClient
+});

package/dist/cjs/memory/vertex_ai_rag_memory_service.js

@@ -0,0 +1,228 @@
+/**
+  * @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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 vertex_ai_rag_memory_service_exports = {};
+__export(vertex_ai_rag_memory_service_exports, {
+  VertexAiRagMemoryService: () => VertexAiRagMemoryService
+});
+module.exports = __toCommonJS(vertex_ai_rag_memory_service_exports);
+var import_error_utils = require("../utils/error_utils.js");
+var import_logger = require("../utils/logger.js");
+var import_rag_memory_transcript = require("./rag_memory_transcript.js");
+var import_vertex_ai_rag_api = require("./vertex_ai_rag_api.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const RAG_FILE_PAGE_SIZE = 100;
+const MAX_RAG_FILE_PAGES = 10;
+const DEFAULT_VECTOR_DISTANCE_THRESHOLD = 10;
+function resolveRagCorpus(options) {
+  var _a, _b, _c;
+  const ragCorpus = (_a = options.ragCorpus) == null ? void 0 : _a.trim();
+  if (!ragCorpus) {
+    throw new Error("ragCorpus is required for VertexAiRagMemoryService.");
+  }
+  const segments = ragCorpus.split("/");
+  const isResourceName = segments.length >= 4 && segments[0] === "projects" && segments[2] === "locations";
+  const projectId = (_b = options.projectId) != null ? _b : isResourceName ? segments[1] : process.env["GOOGLE_CLOUD_PROJECT"];
+  const location = (_c = options.location) != null ? _c : isResourceName ? segments[3] : process.env["GOOGLE_CLOUD_LOCATION"];
+  if (!projectId) {
+    throw new Error(
+      "projectId is required for VertexAiRagMemoryService: pass projectId, set GOOGLE_CLOUD_PROJECT, or give ragCorpus as a full resource name."
+    );
+  }
+  if (!location) {
+    throw new Error(
+      "location is required for VertexAiRagMemoryService: pass location, set GOOGLE_CLOUD_LOCATION, or give ragCorpus as a full resource name."
+    );
+  }
+  return {
+    projectId,
+    location,
+    ragCorpus: isResourceName ? ragCorpus : `projects/${projectId}/locations/${location}/ragCorpora/${ragCorpus}`
+  };
+}
+__name(resolveRagCorpus, "resolveRagCorpus");
+function tenantSource(displayName, appName, userId) {
+  if (!displayName) {
+    return void 0;
+  }
+  const source = (0, import_rag_memory_transcript.parseSourceDisplayName)(displayName);
+  if (!source || source.appName !== appName || source.userId !== userId) {
+    return void 0;
+  }
+  return source;
+}
+__name(tenantSource, "tenantSource");
+function toMemoryEntries(contexts, request) {
+  var _a;
+  const eventsBySession = /* @__PURE__ */ new Map();
+  for (const context of contexts) {
+    const source = tenantSource(
+      context.sourceDisplayName,
+      request.appName,
+      request.userId
+    );
+    if (!source) {
+      continue;
+    }
+    let events = eventsBySession.get(source.sessionId);
+    if (!events) {
+      events = /* @__PURE__ */ new Map();
+      eventsBySession.set(source.sessionId, events);
+    }
+    for (const event of (0, import_rag_memory_transcript.parseTranscriptEvents)((_a = context.text) != null ? _a : "")) {
+      if (!events.has(event.timestamp)) {
+        events.set(event.timestamp, event);
+      }
+    }
+  }
+  const memories = [];
+  for (const events of eventsBySession.values()) {
+    const sorted = [...events.values()].sort(
+      (a, b) => a.timestamp - b.timestamp
+    );
+    for (const event of sorted) {
+      memories.push({
+        author: event.author,
+        content: { parts: [{ text: event.text }] },
+        timestamp: new Date(event.timestamp).toISOString()
+      });
+    }
+  }
+  return memories;
+}
+__name(toMemoryEntries, "toMemoryEntries");
+const _VertexAiRagMemoryService = class _VertexAiRagMemoryService {
+  /**
+   * @param ragApiClient An internal seam for tests to substitute a fake REST
+   *     client. Production callers omit it and get a client for the resolved
+   *     location.
+   * @internal
+   */
+  constructor(options, ragApiClient) {
+    var _a;
+    const resolved = resolveRagCorpus(options);
+    this.ragCorpus = resolved.ragCorpus;
+    this.projectId = resolved.projectId;
+    this.location = resolved.location;
+    this.similarityTopK = options.similarityTopK;
+    this.vectorDistanceThreshold = (_a = options.vectorDistanceThreshold) != null ? _a : DEFAULT_VECTOR_DISTANCE_THRESHOLD;
+    this.ragApiClient = ragApiClient != null ? ragApiClient : new import_vertex_ai_rag_api.VertexRagApiClient({ location: this.location });
+  }
+  /** Uploads the session's transcript into the corpus as one RAG file. */
+  async addSessionToMemory(session) {
+    return this.ragApiClient.uploadRagFile({
+      ragCorpus: this.ragCorpus,
+      displayName: (0, import_rag_memory_transcript.buildSourceDisplayName)(
+        session.appName,
+        session.userId,
+        session.id
+      ),
+      content: (0, import_rag_memory_transcript.serializeSessionTranscript)(session)
+    });
+  }
+  async searchMemory(request) {
+    var _a, _b;
+    const ragFileIds = await this.listTenantRagFileIds(request);
+    if ((ragFileIds == null ? void 0 : ragFileIds.length) === 0) {
+      return { memories: [] };
+    }
+    const response = await this.ragApiClient.retrieveContexts({
+      parent: `projects/${this.projectId}/locations/${this.location}`,
+      vertexRagStore: {
+        ragResources: [{ ragCorpus: this.ragCorpus, ragFileIds }]
+      },
+      query: {
+        text: request.query,
+        // Top-k belongs on the query: retrieveContexts ignores
+        // VertexRagStore.similarityTopK.
+        ragRetrievalConfig: {
+          topK: this.similarityTopK,
+          filter: { vectorDistanceThreshold: this.vectorDistanceThreshold }
+        }
+      }
+    });
+    return {
+      memories: toMemoryEntries((_b = (_a = response.contexts) == null ? void 0 : _a.contexts) != null ? _b : [], request)
+    };
+  }
+  /**
+   * Returns the ids of the corpus files owned by the requesting app and user,
+   * or `undefined` when the corpus could not be listed within the page budget.
+   *
+   * An `undefined` result retrieves over the whole corpus. Narrowing only
+   * improves ranking and transfer size, and every returned context is filtered
+   * by tenant anyway. Scoping to a partial listing would instead hide the
+   * caller's own memories.
+   */
+  async listTenantRagFileIds(request) {
+    var _a;
+    const ragFileIds = [];
+    let pageToken;
+    try {
+      for (let page = 0; page < MAX_RAG_FILE_PAGES; page++) {
+        const response = await this.ragApiClient.listRagFiles({
+          ragCorpus: this.ragCorpus,
+          pageSize: RAG_FILE_PAGE_SIZE,
+          pageToken
+        });
+        for (const ragFile of (_a = response.ragFiles) != null ? _a : []) {
+          const source = tenantSource(
+            ragFile.displayName,
+            request.appName,
+            request.userId
+          );
+          if (source && ragFile.name) {
+            ragFileIds.push(
+              ragFile.name.slice(ragFile.name.lastIndexOf("/") + 1)
+            );
+          }
+        }
+        pageToken = response.nextPageToken;
+        if (!pageToken) {
+          return ragFileIds;
+        }
+      }
+    } catch (e) {
+      import_logger.logger.warn(
+        `Listing the corpus failed, so retrieval is not scoped to the requesting app and user: ${(0, import_error_utils.formatError)(e)}`
+      );
+      return void 0;
+    }
+    import_logger.logger.warn(
+      `Listing ${this.ragCorpus} did not finish within ${MAX_RAG_FILE_PAGES} pages, so retrieval is not scoped to the requesting app and user.`
+    );
+    return void 0;
+  }
+};
+__name(_VertexAiRagMemoryService, "VertexAiRagMemoryService");
+let VertexAiRagMemoryService = _VertexAiRagMemoryService;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VertexAiRagMemoryService
+});

package/dist/cjs/models/apigee_llm.js

@@ -160,7 +160,7 @@ function validateModel(model) {
   if (modelPart.length === 0) {
     return false;
   }
-  const components = modelPart.split("/", -1);
+  const components = modelPart.split("/");
   if (components[components.length - 1].length === 0) {
     return false;
   }

package/dist/cjs/models/base_llm.js

@@ -36,7 +36,7 @@ var import_client_labels = require("../utils/client_labels.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a;
-const BASE_MODEL_SYMBOL = Symbol.for("google.adk.baseModel");
+const BASE_MODEL_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.baseModel");
 function isBaseLlm(obj) {
   return typeof obj === "object" && obj !== null && BASE_MODEL_SYMBOL in obj && obj[BASE_MODEL_SYMBOL] === true;
 }
@@ -57,12 +57,7 @@ const _BaseLlm = class _BaseLlm {
     this.model = model;
   }
   get trackingHeaders() {
-    const labels = (0, import_client_labels.getClientLabels)();
-    const headerValue = labels.join(" ");
-    return {
-      "x-goog-api-client": headerValue,
-      "user-agent": headerValue
-    };
+    return (0, import_client_labels.getTrackingHeaders)();
   }
   /**
    * Appends a user content, so that model can continue to output.

package/dist/cjs/models/chrome_prompt_llm.js

@@ -0,0 +1,318 @@
+/**
+  * @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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 chrome_prompt_llm_exports = {};
+__export(chrome_prompt_llm_exports, {
+  ChromeBuiltInLlm: () => ChromeBuiltInLlm,
+  ChromeModelUnavailableError: () => ChromeModelUnavailableError,
+  stripAdkIdentityPreamble: () => import_chrome_prompt_utils2.stripAdkIdentityPreamble
+});
+module.exports = __toCommonJS(chrome_prompt_llm_exports);
+var import_event = require("../events/event.js");
+var import_genai_schema_to_json = require("../utils/genai_schema_to_json.js");
+var import_base_llm = require("./base_llm.js");
+var import_chrome_prompt_utils = require("./chrome_prompt_utils.js");
+var import_chrome_prompt_utils2 = require("./chrome_prompt_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const _ChromeModelUnavailableError = class _ChromeModelUnavailableError extends Error {
+  constructor(availability) {
+    super(
+      availability === "missing-api" ? "This browser does not expose the Prompt API (globalThis.LanguageModel is undefined)." : `Chrome's built-in model is not available (availability: "${availability}").`
+    );
+    this.availability = availability;
+    this.name = "ChromeModelUnavailableError";
+  }
+};
+__name(_ChromeModelUnavailableError, "ChromeModelUnavailableError");
+let ChromeModelUnavailableError = _ChromeModelUnavailableError;
+const _ChromeBuiltInLlm = class _ChromeBuiltInLlm extends import_base_llm.BaseLlm {
+  constructor(params = {}) {
+    var _a;
+    super({ model: (_a = params.model) != null ? _a : "chrome-on-device" });
+    this.params = params;
+  }
+  get api() {
+    var _a;
+    const api = (_a = this.params.languageModel) != null ? _a : globalThis.LanguageModel;
+    if (!api) throw new ChromeModelUnavailableError("missing-api");
+    return api;
+  }
+  /** Reports whether this browser can actually run the model. */
+  async availability() {
+    try {
+      return await this.api.availability({
+        expectedInputs: this.params.expectedInputs,
+        expectedOutputs: this.params.expectedOutputs
+      });
+    } catch {
+      return "unavailable";
+    }
+  }
+  diagnostic(diagnostic) {
+    var _a, _b;
+    (_b = (_a = this.params).onDiagnostic) == null ? void 0 : _b.call(_a, diagnostic);
+  }
+  /**
+   * Returns a session cloned from a warm base carrying `systemPrompt`, and
+   * rebuilds that base only when the system prompt or sampling changes.
+   */
+  async acquireSession(systemPrompt, signal) {
+    var _a, _b;
+    const key = JSON.stringify([
+      systemPrompt,
+      this.params.temperature,
+      this.params.topK,
+      this.params.expectedInputs
+    ]);
+    if (this.baseSessionKey !== key || !this.baseSessionPromise) {
+      (_b = (_a = this.baseSession) == null ? void 0 : _a.destroy) == null ? void 0 : _b.call(_a);
+      this.baseSession = void 0;
+      this.baseSessionKey = key;
+      this.baseSessionPromise = this.createBaseSession(systemPrompt);
+    }
+    let base;
+    try {
+      base = await this.baseSessionPromise;
+    } catch (error) {
+      this.baseSessionPromise = void 0;
+      this.baseSessionKey = void 0;
+      throw error;
+    }
+    return base.clone({ signal });
+  }
+  async createBaseSession(systemPrompt) {
+    var _a, _b;
+    const availability = await this.availability();
+    if (availability === "unavailable") {
+      throw new ChromeModelUnavailableError(availability);
+    }
+    const createOptions = {};
+    if (this.params.onDownloadProgress) {
+      createOptions.monitor = (monitor) => {
+        monitor.addEventListener("downloadprogress", (event) => {
+          this.params.onDownloadProgress(event.loaded);
+        });
+      };
+    }
+    if (systemPrompt) {
+      createOptions.initialPrompts = [{ role: "system", content: systemPrompt }];
+    }
+    if (this.params.expectedInputs) {
+      createOptions.expectedInputs = this.params.expectedInputs;
+    }
+    if (this.params.expectedOutputs) {
+      createOptions.expectedOutputs = this.params.expectedOutputs;
+    }
+    if (this.params.temperature !== void 0) {
+      createOptions.temperature = this.params.temperature;
+      createOptions.topK = (_a = this.params.topK) != null ? _a : 3;
+    }
+    const startedAt = performance.now();
+    let session;
+    try {
+      session = await this.api.create(createOptions);
+    } catch (error) {
+      if (this.params.temperature === void 0) throw error;
+      delete createOptions.temperature;
+      delete createOptions.topK;
+      session = await this.api.create(createOptions);
+    }
+    this.diagnostic({ phase: "create", ms: performance.now() - startedAt });
+    (_b = session.addEventListener) == null ? void 0 : _b.call(session, "contextoverflow", () => {
+      this.diagnostic({
+        phase: "context-overflow",
+        note: "history truncated by the browser",
+        contextUsage: session.contextUsage,
+        contextWindow: session.contextWindow
+      });
+    });
+    this.baseSession = session;
+    return session;
+  }
+  async *generateContentAsync(llmRequest, stream = false, abortSignal) {
+    var _a, _b, _c, _d;
+    const declarations = (0, import_chrome_prompt_utils.collectFunctionDeclarations)(llmRequest);
+    const useTools = declarations.length > 0;
+    const rawSystem = (0, import_chrome_prompt_utils.extractSystemInstruction)(llmRequest);
+    const systemParts = [
+      this.params.normalizeSystemPrompt ? this.params.normalizeSystemPrompt(rawSystem) : rawSystem
+    ];
+    if (useTools) systemParts.push((0, import_chrome_prompt_utils.renderToolInstructions)(declarations));
+    const systemPrompt = systemParts.filter(Boolean).join("\n\n");
+    this.maybeAppendUserContent(llmRequest);
+    const messages = (0, import_chrome_prompt_utils.contentsToMessages)((_a = llmRequest.contents) != null ? _a : []);
+    let session;
+    try {
+      session = await this.acquireSession(systemPrompt, abortSignal);
+      const responseJsonSchema = (_b = llmRequest.config) == null ? void 0 : _b.responseJsonSchema;
+      const responseSchema = (_c = llmRequest.config) == null ? void 0 : _c.responseSchema;
+      let responseConstraint;
+      if (useTools) {
+        responseConstraint = (0, import_chrome_prompt_utils.buildToolChoiceSchema)(declarations);
+      } else if ((0, import_chrome_prompt_utils.isRecord)(responseJsonSchema)) {
+        responseConstraint = responseJsonSchema;
+      } else if (responseSchema) {
+        responseConstraint = (0, import_genai_schema_to_json.genaiSchemaToJsonSchema)(responseSchema);
+      }
+      if (stream && !responseConstraint) {
+        yield* this.streamText(session, messages, abortSignal);
+        return;
+      }
+      const raw = await this.promptOnce(
+        session,
+        messages,
+        responseConstraint,
+        abortSignal
+      );
+      yield useTools ? this.parseToolChoice(raw, declarations) : (0, import_chrome_prompt_utils.finalText)(raw);
+    } catch (error) {
+      if ((0, import_chrome_prompt_utils.isAbortError)(error)) throw error;
+      yield (0, import_chrome_prompt_utils.errorResponse)(error);
+    } finally {
+      if (session && session !== this.baseSession) (_d = session.destroy) == null ? void 0 : _d.call(session);
+    }
+  }
+  async promptOnce(session, messages, responseConstraint, signal) {
+    const startedAt = performance.now();
+    const output = await session.prompt(messages, {
+      signal,
+      ...responseConstraint ? { responseConstraint, omitResponseConstraintInput: true } : {}
+    });
+    this.diagnostic({
+      phase: "prompt",
+      ms: performance.now() - startedAt,
+      contextUsage: session.contextUsage,
+      contextWindow: session.contextWindow
+    });
+    return output;
+  }
+  async *streamText(session, messages, signal) {
+    const reader = session.promptStreaming(messages, { signal }).getReader();
+    let accumulated = "";
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        accumulated += value;
+        yield {
+          content: { role: "model", parts: [{ text: value }] },
+          partial: true
+        };
+      }
+    } finally {
+      await reader.cancel();
+      reader.releaseLock();
+    }
+    yield {
+      content: { role: "model", parts: [{ text: accumulated }] },
+      turnComplete: true
+    };
+  }
+  /** Turns the constrained JSON reply into an ADK response. */
+  parseToolChoice(raw, declarations) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      const match = raw.match(/\{[\s\S]*\}/);
+      if (match) {
+        try {
+          parsed = JSON.parse(match[0]);
+        } catch {
+        }
+      }
+    }
+    if (!(0, import_chrome_prompt_utils.isRecord)(parsed)) {
+      const salvaged = (0, import_chrome_prompt_utils.salvageFinalText)(raw);
+      if (salvaged !== void 0) {
+        this.diagnostic({
+          phase: "parse-fallback",
+          note: "truncated envelope; recovered the text"
+        });
+        return (0, import_chrome_prompt_utils.finalText)(salvaged);
+      }
+      this.diagnostic({
+        phase: "parse-fallback",
+        note: "unparseable JSON; treated as text"
+      });
+      return (0, import_chrome_prompt_utils.finalText)((0, import_chrome_prompt_utils.looksLikeEnvelope)(raw) ? import_chrome_prompt_utils.TRUNCATED_REPLY : raw);
+    }
+    if (parsed["kind"] === "tool" && typeof parsed["name"] === "string") {
+      const name = parsed["name"];
+      if (!declarations.some((declaration) => declaration.name === name)) {
+        return (0, import_chrome_prompt_utils.finalText)(`The model requested an unknown tool "${name}".`);
+      }
+      const args = (0, import_chrome_prompt_utils.isRecord)(parsed["args"]) ? parsed["args"] : {};
+      return {
+        content: {
+          role: "model",
+          parts: [
+            { functionCall: { id: (0, import_event.generateClientFunctionCallId)(), name, args } }
+          ]
+        },
+        turnComplete: true
+      };
+    }
+    if (typeof parsed["text"] === "string") return (0, import_chrome_prompt_utils.finalText)(parsed["text"]);
+    if (parsed["text"] !== void 0) return (0, import_chrome_prompt_utils.finalText)(String(parsed["text"]));
+    this.diagnostic({
+      phase: "parse-fallback",
+      note: "envelope carried no text"
+    });
+    return (0, import_chrome_prompt_utils.finalText)((0, import_chrome_prompt_utils.looksLikeEnvelope)(raw) ? import_chrome_prompt_utils.TRUNCATED_REPLY : raw);
+  }
+  async connect(_llmRequest) {
+    throw new Error(
+      "Chrome's Prompt API has no bidirectional live mode, so connect() is not supported by ChromeBuiltInLlm."
+    );
+  }
+  /** Releases the warm base session. */
+  destroy() {
+    var _a, _b;
+    (_b = (_a = this.baseSession) == null ? void 0 : _a.destroy) == null ? void 0 : _b.call(_a);
+    this.baseSession = void 0;
+    this.baseSessionPromise = void 0;
+    this.baseSessionKey = void 0;
+  }
+};
+__name(_ChromeBuiltInLlm, "ChromeBuiltInLlm");
+// Left unanchored on purpose: LLMRegistry.resolve wraps each pattern in
+// `^...$` before matching, so anchoring here would double-anchor and never
+// match.
+_ChromeBuiltInLlm.supportedModels = [
+  /chrome-on-device/,
+  /chrome\/.*/
+];
+let ChromeBuiltInLlm = _ChromeBuiltInLlm;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChromeBuiltInLlm,
+  ChromeModelUnavailableError,
+  stripAdkIdentityPreamble
+});