@google/adk 2.0.0 → 2.2.0

package/dist/esm/models/chrome_prompt_llm.js

@@ -0,0 +1,302 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { generateClientFunctionCallId } from "../events/event.js";
+import { genaiSchemaToJsonSchema } from "../utils/genai_schema_to_json.js";
+import { BaseLlm } from "./base_llm.js";
+import {
+  buildToolChoiceSchema,
+  collectFunctionDeclarations,
+  contentsToMessages,
+  errorResponse,
+  extractSystemInstruction,
+  finalText,
+  isAbortError,
+  isRecord,
+  looksLikeEnvelope,
+  renderToolInstructions,
+  salvageFinalText,
+  TRUNCATED_REPLY
+} from "./chrome_prompt_utils.js";
+import { stripAdkIdentityPreamble } from "./chrome_prompt_utils.js";
+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 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 = collectFunctionDeclarations(llmRequest);
+    const useTools = declarations.length > 0;
+    const rawSystem = extractSystemInstruction(llmRequest);
+    const systemParts = [
+      this.params.normalizeSystemPrompt ? this.params.normalizeSystemPrompt(rawSystem) : rawSystem
+    ];
+    if (useTools) systemParts.push(renderToolInstructions(declarations));
+    const systemPrompt = systemParts.filter(Boolean).join("\n\n");
+    this.maybeAppendUserContent(llmRequest);
+    const messages = 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 = buildToolChoiceSchema(declarations);
+      } else if (isRecord(responseJsonSchema)) {
+        responseConstraint = responseJsonSchema;
+      } else if (responseSchema) {
+        responseConstraint = 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) : finalText(raw);
+    } catch (error) {
+      if (isAbortError(error)) throw error;
+      yield 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 (!isRecord(parsed)) {
+      const salvaged = salvageFinalText(raw);
+      if (salvaged !== void 0) {
+        this.diagnostic({
+          phase: "parse-fallback",
+          note: "truncated envelope; recovered the text"
+        });
+        return finalText(salvaged);
+      }
+      this.diagnostic({
+        phase: "parse-fallback",
+        note: "unparseable JSON; treated as text"
+      });
+      return finalText(looksLikeEnvelope(raw) ? TRUNCATED_REPLY : raw);
+    }
+    if (parsed["kind"] === "tool" && typeof parsed["name"] === "string") {
+      const name = parsed["name"];
+      if (!declarations.some((declaration) => declaration.name === name)) {
+        return finalText(`The model requested an unknown tool "${name}".`);
+      }
+      const args = isRecord(parsed["args"]) ? parsed["args"] : {};
+      return {
+        content: {
+          role: "model",
+          parts: [
+            { functionCall: { id: generateClientFunctionCallId(), name, args } }
+          ]
+        },
+        turnComplete: true
+      };
+    }
+    if (typeof parsed["text"] === "string") return finalText(parsed["text"]);
+    if (parsed["text"] !== void 0) return finalText(String(parsed["text"]));
+    this.diagnostic({
+      phase: "parse-fallback",
+      note: "envelope carried no text"
+    });
+    return finalText(looksLikeEnvelope(raw) ? 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;
+export {
+  ChromeBuiltInLlm,
+  ChromeModelUnavailableError,
+  stripAdkIdentityPreamble
+};

package/dist/esm/models/chrome_prompt_utils.js

@@ -0,0 +1,241 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { genaiSchemaToJsonSchema } from "../utils/genai_schema_to_json.js";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function argumentSchema(declaration) {
+  if (isRecord(declaration.parametersJsonSchema)) {
+    return declaration.parametersJsonSchema;
+  }
+  if (declaration.parameters) {
+    return genaiSchemaToJsonSchema(declaration.parameters);
+  }
+  return { type: "object", properties: {} };
+}
+__name(argumentSchema, "argumentSchema");
+function collectFunctionDeclarations(llmRequest) {
+  var _a, _b;
+  const declarations = [];
+  for (const tool of (_b = (_a = llmRequest.config) == null ? void 0 : _a.tools) != null ? _b : []) {
+    if (isRecord(tool) && Array.isArray(tool["functionDeclarations"])) {
+      declarations.push(
+        ...tool["functionDeclarations"]
+      );
+    }
+  }
+  return declarations;
+}
+__name(collectFunctionDeclarations, "collectFunctionDeclarations");
+function buildToolChoiceSchema(declarations) {
+  const branches = [
+    {
+      type: "object",
+      properties: {
+        kind: { type: "string", enum: ["final"] },
+        text: { type: "string" }
+      },
+      required: ["kind", "text"],
+      additionalProperties: false
+    }
+  ];
+  for (const declaration of declarations) {
+    if (!declaration.name) continue;
+    branches.push({
+      type: "object",
+      properties: {
+        kind: { type: "string", enum: ["tool"] },
+        name: { type: "string", enum: [declaration.name] },
+        args: argumentSchema(declaration)
+      },
+      required: ["kind", "name", "args"],
+      additionalProperties: false
+    });
+  }
+  return branches.length === 1 ? branches[0] : { anyOf: branches };
+}
+__name(buildToolChoiceSchema, "buildToolChoiceSchema");
+function renderToolInstructions(declarations) {
+  if (!declarations.length) return "";
+  const lines = declarations.map(
+    (declaration) => {
+      var _a;
+      return `- ${declaration.name}: ${(_a = declaration.description) != null ? _a : ""}
+  arguments: ${JSON.stringify(argumentSchema(declaration))}`;
+    }
+  );
+  return [
+    "You can call these tools:",
+    ...lines,
+    "",
+    'Reply with JSON only. To call a tool use {"kind":"tool","name":<tool>,"args":{...}}.',
+    'When you have the answer use {"kind":"final","text":<answer>}.'
+  ].join("\n");
+}
+__name(renderToolInstructions, "renderToolInstructions");
+function renderToolResult(response) {
+  if (response == null) return "{}";
+  let value = response;
+  if (isRecord(value) && Object.keys(value).length === 1 && "result" in value) {
+    value = value["result"];
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        return JSON.stringify(JSON.parse(trimmed));
+      } catch {
+        return trimmed;
+      }
+    }
+    return trimmed;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+__name(renderToolResult, "renderToolResult");
+function contentsToMessages(contents) {
+  var _a, _b;
+  const messages = [];
+  for (const content of contents != null ? contents : []) {
+    const role = content.role === "model" ? "assistant" : "user";
+    const chunks = [];
+    for (const part of (_a = content.parts) != null ? _a : []) {
+      if (part.text) chunks.push(part.text);
+      if (part.functionCall) {
+        const args = JSON.stringify((_b = part.functionCall.args) != null ? _b : {});
+        chunks.push(`[tool_call] ${part.functionCall.name}(${args})`);
+      }
+      if (part.functionResponse) {
+        const rendered = renderToolResult(part.functionResponse.response);
+        chunks.push(
+          `[tool_result] ${part.functionResponse.name} -> ${rendered}`
+        );
+      }
+    }
+    if (chunks.length) {
+      messages.push({ role, content: chunks.join("\n") });
+    }
+  }
+  return messages;
+}
+__name(contentsToMessages, "contentsToMessages");
+function extractSystemInstruction(llmRequest) {
+  var _a;
+  const instruction = (_a = llmRequest.config) == null ? void 0 : _a.systemInstruction;
+  if (!instruction) return "";
+  if (typeof instruction === "string") return instruction;
+  if (Array.isArray(instruction)) {
+    return instruction.map(
+      (entry) => {
+        var _a2;
+        return typeof entry === "string" ? entry : (_a2 = entry == null ? void 0 : entry.text) != null ? _a2 : "";
+      }
+    ).filter(Boolean).join("\n");
+  }
+  if (isRecord(instruction) && Array.isArray(instruction["parts"])) {
+    return instruction["parts"].map((part) => {
+      var _a2;
+      return (_a2 = part.text) != null ? _a2 : "";
+    }).filter(Boolean).join("\n");
+  }
+  return String(instruction);
+}
+__name(extractSystemInstruction, "extractSystemInstruction");
+function stripAdkIdentityPreamble(systemPrompt) {
+  return systemPrompt.replace(/^You are an agent\. Your internal name is "[^"]*"\.\s*/m, "").replace(/^The description about you is "[^"]*"\s*/m, "").trimStart();
+}
+__name(stripAdkIdentityPreamble, "stripAdkIdentityPreamble");
+function isAbortError(error) {
+  return isRecord(error) && error["name"] === "AbortError";
+}
+__name(isAbortError, "isAbortError");
+function finalText(text) {
+  return { content: { role: "model", parts: [{ text }] }, turnComplete: true };
+}
+__name(finalText, "finalText");
+function errorResponse(error) {
+  const details = isRecord(error) ? error : {};
+  const name = typeof details["name"] === "string" ? details["name"] : "UnknownError";
+  const message = typeof details["message"] === "string" ? details["message"] : String(error);
+  if (name === "QuotaExceededError") {
+    return {
+      errorCode: name,
+      errorMessage: `Prompt exceeded the context window (requested ${details["requested"]} of ${details["quota"]} tokens).`,
+      turnComplete: true
+    };
+  }
+  return { errorCode: name, errorMessage: message, turnComplete: true };
+}
+__name(errorResponse, "errorResponse");
+const TRUNCATED_REPLY = "The model started an answer and did not finish it. Ask again.";
+function looksLikeEnvelope(raw) {
+  return /^\s*[[{]/.test(raw) || /"kind"\s*:/.test(raw);
+}
+__name(looksLikeEnvelope, "looksLikeEnvelope");
+function salvageFinalText(raw) {
+  var _a;
+  const key = raw.match(/"text"\s*:\s*"/);
+  if ((key == null ? void 0 : key.index) === void 0) return void 0;
+  const escapes = {
+    n: "\n",
+    t: "	",
+    r: "\r",
+    b: "\b",
+    f: "\f",
+    '"': '"',
+    "\\": "\\",
+    "/": "/"
+  };
+  let out = "";
+  for (let i = key.index + key[0].length; i < raw.length; i++) {
+    const char = raw[i];
+    if (char === '"') break;
+    if (char !== "\\") {
+      out += char;
+      continue;
+    }
+    const next = raw[i + 1];
+    if (next === void 0) break;
+    if (next === "u") {
+      const hex = raw.slice(i + 2, i + 6);
+      if (/^[0-9a-fA-F]{4}$/.test(hex)) {
+        out += String.fromCharCode(parseInt(hex, 16));
+        i += 5;
+        continue;
+      }
+    }
+    out += (_a = escapes[next]) != null ? _a : next;
+    i++;
+  }
+  const text = out.trim();
+  return text.length ? text : void 0;
+}
+__name(salvageFinalText, "salvageFinalText");
+export {
+  TRUNCATED_REPLY,
+  buildToolChoiceSchema,
+  collectFunctionDeclarations,
+  contentsToMessages,
+  errorResponse,
+  extractSystemInstruction,
+  finalText,
+  isAbortError,
+  isRecord,
+  looksLikeEnvelope,
+  renderToolInstructions,
+  renderToolResult,
+  salvageFinalText,
+  stripAdkIdentityPreamble
+};

package/dist/esm/models/gemini_llm_connection.js

@@ -9,7 +9,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import { LiveResponseAggregator } from "../utils/live_connection_utils.js";
 import { logger } from "../utils/logger.js";
-import { isGemini3xFlashLive } from "../utils/model_name.js";
+import { isGemini35LiveTranslate, isGemini3xLive } from "../utils/model_name.js";
 const _GeminiLlmConnection = class _GeminiLlmConnection {
   constructor(geminiSession, modelVersion, messageQueue) {
     this.geminiSession = geminiSession;
@@ -33,7 +33,7 @@ const _GeminiLlmConnection = class _GeminiLlmConnection {
       }
     );
     if (contents.length > 0) {
-      const isGemini3x = isGemini3xFlashLive(this.modelVersion);
+      const isGemini3x = isGemini3xLive(this.modelVersion);
       this.geminiSession.sendClientContent({
         turns: contents,
         turnComplete: isGemini3x ? true : contents[contents.length - 1].role === "user"
@@ -63,7 +63,7 @@ const _GeminiLlmConnection = class _GeminiLlmConnection {
       });
     } else {
       logger.debug("Sending LLM new content", content);
-      const isGemini3x = isGemini3xFlashLive(this.modelVersion);
+      const isGemini3x = isGemini3xLive(this.modelVersion);
       if (isGemini3x && content.parts.length === 1 && content.parts[0].text) {
         logger.debug("Using sendRealtimeInput for Gemini 3.x text input");
         this.geminiSession.sendRealtimeInput({ text: content.parts[0].text });
@@ -83,9 +83,10 @@ const _GeminiLlmConnection = class _GeminiLlmConnection {
   async sendRealtime(blob) {
     var _a, _b, _c;
     logger.debug("Sending LLM Blob:", blob);
-    const isGemini3x = isGemini3xFlashLive(this.modelVersion);
+    const isGemini3x = isGemini3xLive(this.modelVersion);
     const isNativeAudio = (_a = this.modelVersion) == null ? void 0 : _a.includes("native-audio");
-    if (isGemini3x || isNativeAudio) {
+    const isLiveTranslate = isGemini35LiveTranslate(this.modelVersion);
+    if (isGemini3x || isNativeAudio || isLiveTranslate) {
       if ((_b = blob.mimeType) == null ? void 0 : _b.startsWith("audio/")) {
         this.geminiSession.sendRealtimeInput({ audio: blob });
       } else if ((_c = blob.mimeType) == null ? void 0 : _c.startsWith("image/")) {

package/dist/esm/models/google_llm.js

@@ -21,7 +21,7 @@ import { BaseLlm } from "./base_llm.js";
 import { GeminiLlmConnection } from "./gemini_llm_connection.js";
 import { generateContentViaInteractions } from "./interactions_utils.js";
 import { createLlmResponse } from "./llm_response.js";
-const GEMINI_MODEL_SYMBOL = Symbol.for("google.adk.geminiModel");
+const GEMINI_MODEL_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.geminiModel");
 function isGemini(obj) {
   return typeof obj === "object" && obj !== null && GEMINI_MODEL_SYMBOL in obj && obj[GEMINI_MODEL_SYMBOL] === true;
 }
@@ -66,9 +66,14 @@ const _Gemini = class _Gemini extends (_b = BaseLlm, _a = GEMINI_MODEL_SYMBOL, _
   /**
    * 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.
+   * @param llmRequest The request to send to the Gemini model.
+   * @param stream Whether to make a streaming call. Defaults to `false`.
+   * @yields Each {@link LlmResponse} produced by the model. A non-streaming
+   *     call yields exactly one; a streaming call yields the partial responses
+   *     as they arrive, then a final aggregated response whenever the stream
+   *     carried either content or usage/grounding/citation metadata. A
+   *     metadata-only stream therefore still ends with one, holding the
+   *     metadata and no `content`; only a stream with neither ends silently.
    */
   async *generateContentAsync(llmRequest, stream = false, abortSignal) {
     var _a2, _b2, _c;

package/dist/esm/models/interactions_utils.js

@@ -662,13 +662,12 @@ async function* generateContentViaInteractions(apiClient, llmRequest, stream) {
     });
     const aggregatedParts = [];
     for await (const event of responses) {
-      const sseEvent = event;
-      const interactionId = extractStreamInteractionId(sseEvent);
+      const interactionId = extractStreamInteractionId(event);
       if (interactionId) {
         currentInteractionId = interactionId;
       }
       const llmResponse = convertInteractionEventToLlmResponse(
-        sseEvent,
+        event,
         aggregatedParts,
         currentInteractionId
       );

package/dist/esm/models/registry.js

@@ -9,6 +9,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import { logger } from "../utils/logger.js";
 import { ApigeeLlm } from "./apigee_llm.js";
+import { ChromeBuiltInLlm } from "./chrome_prompt_llm.js";
 import { Gemini } from "./google_llm.js";
 const _LRUCache = class _LRUCache {
   constructor(maxSize) {
@@ -95,6 +96,7 @@ _LLMRegistry.resolveCache = new LRUCache(32);
 let LLMRegistry = _LLMRegistry;
 LLMRegistry.register(Gemini);
 LLMRegistry.register(ApigeeLlm);
+LLMRegistry.register(ChromeBuiltInLlm);
 export {
   LLMRegistry
 };

package/dist/esm/planners/base_planner.js

@@ -0,0 +1,28 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+const BASE_PLANNER_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.basePlanner");
+function isBasePlanner(obj) {
+  return typeof obj === "object" && obj !== null && BASE_PLANNER_SIGNATURE_SYMBOL in obj && obj[BASE_PLANNER_SIGNATURE_SYMBOL] === true;
+}
+__name(isBasePlanner, "isBasePlanner");
+_a = BASE_PLANNER_SIGNATURE_SYMBOL;
+const _BasePlanner = class _BasePlanner {
+  constructor() {
+    /** A unique symbol to identify ADK base planner class. */
+    this[_a] = true;
+  }
+};
+__name(_BasePlanner, "BasePlanner");
+let BasePlanner = _BasePlanner;
+export {
+  BasePlanner,
+  isBasePlanner
+};