@google/adk 1.6.0 → 2.0.0

package/dist/cjs/environment/base_environment.js

@@ -0,0 +1,97 @@
+/**
+  * @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 __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_environment_exports = {};
+__export(base_environment_exports, {
+  BaseEnvironment: () => BaseEnvironment
+});
+module.exports = __toCommonJS(base_environment_exports);
+var import_experimental = require("../utils/experimental.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let BaseEnvironment = class {
+  constructor() {
+    /**
+     * Backing flag for {@link isInitialized}.
+     *
+     * Subclasses own this flag: set it in {@link initialize} and clear it in
+     * {@link close}.
+     */
+    this.initialized = false;
+  }
+  /** Whether the environment has been initialized. */
+  get isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Initializes the environment (e.g. creates the working directory).
+   *
+   * Called before first use. The default implementation is a no-op and leaves
+   * {@link isInitialized} `false`. Subclasses must be idempotent and must set
+   * {@link initialized}.
+   */
+  async initialize() {
+  }
+  /**
+   * Releases resources held by the environment.
+   *
+   * The default implementation is a no-op. Subclasses must be idempotent and
+   * must clear {@link initialized}.
+   */
+  async close() {
+  }
+  /**
+   * Throws if {@link initialize} has not been called.
+   *
+   * Implementations should call this at the start of every operation that needs
+   * a live working directory.
+   */
+  assertInitialized() {
+    if (!this.initialized) {
+      throw new Error(
+        "Environment is not initialized. Call initialize() first."
+      );
+    }
+  }
+};
+__name(BaseEnvironment, "BaseEnvironment");
+BaseEnvironment = __decorateClass([
+  import_experimental.experimental
+], BaseEnvironment);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseEnvironment
+});

package/dist/cjs/environment/local_environment.js

@@ -0,0 +1,186 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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 local_environment_exports = {};
+__export(local_environment_exports, {
+  LocalEnvironment: () => LocalEnvironment
+});
+module.exports = __toCommonJS(local_environment_exports);
+var import_node_child_process = require("node:child_process");
+var fs = __toESM(require("node:fs/promises"), 1);
+var os = __toESM(require("node:os"), 1);
+var path = __toESM(require("node:path"), 1);
+var import_experimental = require("../utils/experimental.js");
+var import_logger = require("../utils/logger.js");
+var import_base_environment = require("./base_environment.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const TEMP_WORKSPACE_PREFIX = "adk_workspace_";
+function resolvePathInWorkingDir(workingDir, filePath) {
+  const base = path.resolve(workingDir);
+  const resolved = path.resolve(base, filePath);
+  const relative = path.relative(base, resolved);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || // `path.relative` returns an absolute path across Windows drives.
+  path.isAbsolute(relative)) {
+    throw new Error(`Path escapes working directory: ${filePath}`);
+  }
+  return resolved;
+}
+__name(resolvePathInWorkingDir, "resolvePathInWorkingDir");
+let LocalEnvironment = class extends import_base_environment.BaseEnvironment {
+  constructor(options = {}) {
+    super();
+    this.autoCreated = false;
+    this.currentWorkingDir = options.workingDir;
+    this.envVars = options.envVars;
+  }
+  get workingDir() {
+    if (this.currentWorkingDir === void 0) {
+      throw new Error("`workingDir` is not set. Call initialize() first.");
+    }
+    return this.currentWorkingDir;
+  }
+  async initialize() {
+    if (this.currentWorkingDir === void 0) {
+      this.currentWorkingDir = await fs.mkdtemp(
+        path.join(os.tmpdir(), TEMP_WORKSPACE_PREFIX)
+      );
+      this.autoCreated = true;
+      import_logger.logger.debug(`Created temporary workspace: ${this.currentWorkingDir}`);
+    } else {
+      await fs.mkdir(this.currentWorkingDir, { recursive: true });
+    }
+    this.initialized = true;
+  }
+  async close() {
+    if (this.autoCreated && this.currentWorkingDir !== void 0) {
+      await fs.rm(this.currentWorkingDir, { recursive: true, force: true });
+      import_logger.logger.debug(`Removed temporary workspace: ${this.currentWorkingDir}`);
+      this.currentWorkingDir = void 0;
+    }
+    this.initialized = false;
+  }
+  async execute(command, timeoutSeconds) {
+    this.assertInitialized();
+    const child = (0, import_node_child_process.spawn)(command, {
+      shell: true,
+      cwd: this.workingDir,
+      env: { ...process.env, ...this.envVars }
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+    child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+    let timedOut = false;
+    let timer;
+    if (timeoutSeconds !== void 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGKILL");
+        child.stdout.destroy();
+        child.stderr.destroy();
+      }, timeoutSeconds * 1e3);
+    }
+    try {
+      const exitCode = await new Promise((resolve, reject) => {
+        child.on("close", (code, signal) => {
+          resolve(
+            signal === null ? code != null ? code : 0 : -os.constants.signals[signal]
+          );
+        });
+        child.on("error", reject);
+      });
+      return {
+        exitCode,
+        // Decode once, so a multi-byte character split across two chunks is
+        // not corrupted. Invalid bytes become U+FFFD, matching Python's
+        // `errors='replace'`.
+        stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+        timedOut
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * Reads a file from the working directory.
+   *
+   * `filePath` is confined to the working directory by a lexical check on the
+   * resolved path, which is not a sandbox.
+   *
+   * @throws If the environment is not initialized, if the path escapes the
+   *   working directory, or — as `ENOENT` — if the file does not exist.
+   */
+  async readFile(filePath) {
+    this.assertInitialized();
+    return fs.readFile(resolvePathInWorkingDir(this.workingDir, filePath));
+  }
+  /**
+   * Writes a file in the working directory, creating parent directories.
+   *
+   * `filePath` is confined to the working directory by a lexical check on the
+   * resolved path, which is not a sandbox. No newline translation is applied,
+   * so explicit CRLF sequences are preserved.
+   *
+   * @throws If the environment is not initialized or the path escapes the
+   *   working directory.
+   */
+  async writeFile(filePath, content) {
+    this.assertInitialized();
+    const resolved = resolvePathInWorkingDir(this.workingDir, filePath);
+    await fs.mkdir(path.dirname(resolved), { recursive: true });
+    await fs.writeFile(resolved, content);
+  }
+};
+__name(LocalEnvironment, "LocalEnvironment");
+LocalEnvironment = __decorateClass([
+  import_experimental.experimental
+], LocalEnvironment);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalEnvironment
+});

package/dist/cjs/events/compacted_event.js

@@ -9,6 +9,7 @@ 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 });
@@ -38,9 +39,11 @@ var import_event = require("./event.js");
 function isCompactedEvent(event) {
   return "isCompacted" in event && event.isCompacted === true;
 }
+__name(isCompactedEvent, "isCompactedEvent");
 function isScratchpadEvent(event) {
   return isCompactedEvent(event) && event.isScratchpad === true;
 }
+__name(isScratchpadEvent, "isScratchpadEvent");
 function createCompactedEvent(params = {}) {
   return {
     ...(0, import_event.createEvent)(params),
@@ -51,6 +54,7 @@ function createCompactedEvent(params = {}) {
     isScratchpad: params.isScratchpad
   };
 }
+__name(createCompactedEvent, "createCompactedEvent");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createCompactedEvent,

package/dist/cjs/events/event.js

@@ -9,6 +9,7 @@ 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 });
@@ -33,6 +34,7 @@ __export(event_exports, {
   getFunctionResponses: () => getFunctionResponses,
   hasThoughts: () => hasThoughts,
   hasTrailingCodeExecutionResult: () => hasTrailingCodeExecutionResult,
+  isEvent: () => isEvent,
   isFinalResponse: () => isFinalResponse,
   populateClientFunctionCallId: () => populateClientFunctionCallId,
   pruneThoughts: () => pruneThoughts,
@@ -49,24 +51,28 @@ var import_event_actions = require("./event_actions.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+const EVENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.event");
 function createEvent(params = {}) {
   return {
     ...params,
+    [EVENT_SIGNATURE_SYMBOL]: true,
     id: params.id || createNewEventId(),
     invocationId: params.invocationId || "",
     author: params.author,
-    actions: params.actions || (0, import_event_actions.createEventActions)(),
+    actions: (0, import_event_actions.createEventActions)(params.actions),
     longRunningToolIds: params.longRunningToolIds || [],
     branch: params.branch,
     timestamp: params.timestamp || Date.now()
   };
 }
+__name(createEvent, "createEvent");
 function isFinalResponse(event) {
   if (event.actions.skipSummarization || event.longRunningToolIds && event.longRunningToolIds.length > 0 || event.actions.requestedAuthConfigs && Object.keys(event.actions.requestedAuthConfigs).length > 0) {
     return true;
   }
   return getFunctionCalls(event).length === 0 && getFunctionResponses(event).length === 0 && !event.partial && !hasTrailingCodeExecutionResult(event);
 }
+__name(isFinalResponse, "isFinalResponse");
 function getFunctionCalls(event) {
   const funcCalls = [];
   if (event.content && event.content.parts) {
@@ -78,10 +84,12 @@ function getFunctionCalls(event) {
   }
   return funcCalls;
 }
+__name(getFunctionCalls, "getFunctionCalls");
 const AF_FUNCTION_CALL_ID_PREFIX = "adk-";
 function generateClientFunctionCallId() {
   return `${AF_FUNCTION_CALL_ID_PREFIX}${(0, import_env_aware_utils.randomUUID)()}`;
 }
+__name(generateClientFunctionCallId, "generateClientFunctionCallId");
 function populateClientFunctionCallId(modelResponseEvent) {
   for (const functionCall of getFunctionCalls(modelResponseEvent)) {
     if (!functionCall.id) {
@@ -89,6 +97,7 @@ function populateClientFunctionCallId(modelResponseEvent) {
     }
   }
 }
+__name(populateClientFunctionCallId, "populateClientFunctionCallId");
 function getFunctionResponses(event) {
   const funcResponses = [];
   if (event.content && event.content.parts) {
@@ -100,6 +109,7 @@ function getFunctionResponses(event) {
   }
   return funcResponses;
 }
+__name(getFunctionResponses, "getFunctionResponses");
 function hasTrailingCodeExecutionResult(event) {
   var _a;
   if (event.content && ((_a = event.content.parts) == null ? void 0 : _a.length)) {
@@ -108,6 +118,7 @@ function hasTrailingCodeExecutionResult(event) {
   }
   return false;
 }
+__name(hasTrailingCodeExecutionResult, "hasTrailingCodeExecutionResult");
 function stringifyContent(event) {
   var _a;
   if (!((_a = event.content) == null ? void 0 : _a.parts)) {
@@ -118,6 +129,7 @@ function stringifyContent(event) {
     return (_a2 = part.text) != null ? _a2 : "";
   }).join("");
 }
+__name(stringifyContent, "stringifyContent");
 function getEventTokens(event) {
   var _a;
   if (((_a = event.usageMetadata) == null ? void 0 : _a.promptTokenCount) !== void 0) {
@@ -126,10 +138,12 @@ function getEventTokens(event) {
   const contentStr = stringifyContent(event);
   return Math.ceil(contentStr.length / 4);
 }
+__name(getEventTokens, "getEventTokens");
 function hasThoughts(event) {
   var _a, _b;
   return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some((part) => part.thought === true));
 }
+__name(hasThoughts, "hasThoughts");
 function pruneThoughts(event) {
   var _a;
   if (!((_a = event.content) == null ? void 0 : _a.parts)) {
@@ -146,7 +160,12 @@ function pruneThoughts(event) {
     }
   };
 }
+__name(pruneThoughts, "pruneThoughts");
 const ASCII_LETTERS_AND_NUMBERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+function isEvent(obj) {
+  return typeof obj === "object" && obj !== null && EVENT_SIGNATURE_SYMBOL in obj && obj[EVENT_SIGNATURE_SYMBOL] === true;
+}
+__name(isEvent, "isEvent");
 function createNewEventId() {
   let id = "";
   for (let i = 0; i < 8; i++) {
@@ -154,6 +173,7 @@ function createNewEventId() {
   }
   return id;
 }
+__name(createNewEventId, "createNewEventId");
 const PRESERVE_KEYS_CAMEL_CASE = [
   "actions.stateDelta",
   "actions.artifactDelta",
@@ -162,7 +182,14 @@ const PRESERVE_KEYS_CAMEL_CASE = [
   "actions.customMetadata",
   "customMetadata",
   "content.parts.functionCall.args",
-  "content.parts.functionResponse.response"
+  "content.parts.functionResponse.response",
+  // Workflow: arbitrary node output, emitted route(s), and checkpointed node
+  // state carry user-defined keys that must survive round-trips verbatim (a
+  // node's original input is stashed under `actions.agentState` for HITL
+  // resume, and rehydration reads `output`/`route`/`actions.agentState` back).
+  "output",
+  "route",
+  "actions.agentState"
 ];
 const PRESERVE_KEYS_SNAKE_CASE = [
   "actions.state_delta",
@@ -172,14 +199,21 @@ const PRESERVE_KEYS_SNAKE_CASE = [
   "actions.custom_metadata",
   "custom_metadata",
   "content.parts.function_call.args",
-  "content.parts.function_response.response"
+  "content.parts.function_response.response",
+  // Workflow: arbitrary node output, emitted route(s), and checkpointed node
+  // state (see the camelCase list above).
+  "output",
+  "route",
+  "actions.agent_state"
 ];
 function transformToCamelCaseEvent(event) {
   return (0, import_object_notation_utils.toCamelCase)(event, PRESERVE_KEYS_SNAKE_CASE);
 }
+__name(transformToCamelCaseEvent, "transformToCamelCaseEvent");
 function transformToSnakeCaseEvent(event) {
   return (0, import_object_notation_utils.toSnakeCase)(event, PRESERVE_KEYS_CAMEL_CASE);
 }
+__name(transformToSnakeCaseEvent, "transformToSnakeCaseEvent");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AF_FUNCTION_CALL_ID_PREFIX,
@@ -191,6 +225,7 @@ function transformToSnakeCaseEvent(event) {
   getFunctionResponses,
   hasThoughts,
   hasTrailingCodeExecutionResult,
+  isEvent,
   isFinalResponse,
   populateClientFunctionCallId,
   pruneThoughts,

package/dist/cjs/events/event_actions.js

@@ -9,6 +9,7 @@ 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 });
@@ -28,6 +29,7 @@ __export(event_actions_exports, {
   mergeEventActions: () => mergeEventActions
 });
 module.exports = __toCommonJS(event_actions_exports);
+var import_state_write_order = require("../sessions/state_write_order.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -42,6 +44,7 @@ function createEventActions(state = {}) {
     ...state
   };
 }
+__name(createEventActions, "createEventActions");
 function mergeEventActions(sources, target) {
   const result = createEventActions();
   if (target) {
@@ -51,6 +54,7 @@ function mergeEventActions(sources, target) {
     if (!source) continue;
     if (source.stateDelta) {
       Object.assign(result.stateDelta, source.stateDelta);
+      (0, import_state_write_order.carryDeltaStamps)(source.stateDelta, result.stateDelta);
     }
     if (source.artifactDelta) {
       Object.assign(result.artifactDelta, source.artifactDelta);
@@ -76,6 +80,7 @@ function mergeEventActions(sources, target) {
   }
   return result;
 }
+__name(mergeEventActions, "mergeEventActions");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createEventActions,

package/dist/cjs/events/structured_events.js

@@ -9,6 +9,7 @@ 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 });
@@ -98,6 +99,7 @@ function toStructuredEvents(event) {
   }
   return structuredEvents;
 }
+__name(toStructuredEvents, "toStructuredEvents");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EventType,

package/dist/cjs/examples/base_example_provider.js

@@ -9,6 +9,7 @@ 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 });
@@ -40,15 +41,18 @@ const BASE_EXAMPLE_PROVIDER_SIGNATURE_SYMBOL = Symbol.for(
 function isBaseExampleProvider(obj) {
   return typeof obj === "object" && obj !== null && BASE_EXAMPLE_PROVIDER_SIGNATURE_SYMBOL in obj && obj[BASE_EXAMPLE_PROVIDER_SIGNATURE_SYMBOL] === true;
 }
+__name(isBaseExampleProvider, "isBaseExampleProvider");
 _a = BASE_EXAMPLE_PROVIDER_SIGNATURE_SYMBOL;
-class BaseExampleProvider {
+const _BaseExampleProvider = class _BaseExampleProvider {
   constructor() {
     /**
      * A unique symbol to identify ADK example provider classes.
      */
     this[_a] = true;
   }
-}
+};
+__name(_BaseExampleProvider, "BaseExampleProvider");
+let BaseExampleProvider = _BaseExampleProvider;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseExampleProvider,

package/dist/cjs/examples/example_util.js

@@ -9,6 +9,7 @@ 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 });
@@ -91,6 +92,7 @@ function convertExamplesToText(examples, model) {
   }
   return `${EXAMPLES_INTRO}${examplesStr}${EXAMPLES_END}`;
 }
+__name(convertExamplesToText, "convertExamplesToText");
 function buildExampleSi(examples, query, model) {
   if (Array.isArray(examples)) {
     return convertExamplesToText(examples, model);
@@ -100,6 +102,7 @@ function buildExampleSi(examples, query, model) {
   }
   throw new Error("Invalid example configuration");
 }
+__name(buildExampleSi, "buildExampleSi");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildExampleSi,

package/dist/cjs/features/feature_registry.js

@@ -9,6 +9,7 @@ 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 });
@@ -61,9 +62,11 @@ const FEATURE_OVERRIDES = {};
 function getFeatureConfig(featureName) {
   return FEATURE_REGISTRY[featureName];
 }
+__name(getFeatureConfig, "getFeatureConfig");
 function registerFeature(featureName, config) {
   FEATURE_REGISTRY[featureName] = config;
 }
+__name(registerFeature, "registerFeature");
 function overrideFeatureEnabled(featureName, enabled) {
   const config = getFeatureConfig(featureName);
   if (!config) {
@@ -75,6 +78,7 @@ function overrideFeatureEnabled(featureName, enabled) {
     FEATURE_OVERRIDES[featureName] = enabled;
   }
 }
+__name(overrideFeatureEnabled, "overrideFeatureEnabled");
 function isFeatureEnabled(featureName) {
   const config = getFeatureConfig(featureName);
   if (!config) {
@@ -103,6 +107,7 @@ function isFeatureEnabled(featureName) {
   }
   return config.defaultOn;
 }
+__name(isFeatureEnabled, "isFeatureEnabled");
 function emitNonStableWarningOnce(featureName, featureStage) {
   if (!WARNED_FEATURES.has(featureName)) {
     WARNED_FEATURES.add(featureName);
@@ -111,6 +116,7 @@ function emitNonStableWarningOnce(featureName, featureStage) {
     );
   }
 }
+__name(emitNonStableWarningOnce, "emitNonStableWarningOnce");
 async function withTemporaryFeatureOverride(featureName, enabled, callback) {
   const config = getFeatureConfig(featureName);
   if (!config) {
@@ -129,6 +135,7 @@ async function withTemporaryFeatureOverride(featureName, enabled, callback) {
     }
   }
 }
+__name(withTemporaryFeatureOverride, "withTemporaryFeatureOverride");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FeatureName,