@softactivate/adk 1.1.0

package/dist/cjs/agents/processors/request_confirmation_llm_request_processor.js

@@ -0,0 +1,165 @@
+/**
+  * @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 request_confirmation_llm_request_processor_exports = {};
+__export(request_confirmation_llm_request_processor_exports, {
+  REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR: () => REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
+  RequestConfirmationLlmRequestProcessor: () => RequestConfirmationLlmRequestProcessor
+});
+module.exports = __toCommonJS(request_confirmation_llm_request_processor_exports);
+var import_event = require("../../events/event.js");
+var import_tool_confirmation = require("../../tools/tool_confirmation.js");
+var import_functions = require("../functions.js");
+var import_llm_agent = require("../llm_agent.js");
+var import_readonly_context = require("../readonly_context.js");
+var import_base_llm_processor = require("./base_llm_processor.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class RequestConfirmationLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  /** Handles tool confirmation information to build the LLM request. */
+  async *runAsync(invocationContext) {
+    const agent = invocationContext.agent;
+    if (!(0, import_llm_agent.isLlmAgent)(agent)) {
+      return;
+    }
+    const events = invocationContext.session.events;
+    if (!events || events.length === 0) {
+      return;
+    }
+    const requestConfirmationFunctionResponses = {};
+    let confirmationEventIndex = -1;
+    for (let i = events.length - 1; i >= 0; i--) {
+      const event = events[i];
+      if (event.author !== "user") {
+        continue;
+      }
+      const responses = (0, import_event.getFunctionResponses)(event);
+      if (!responses) {
+        continue;
+      }
+      let foundConfirmation = false;
+      for (const functionResponse of responses) {
+        if (functionResponse.name !== import_functions.REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
+          continue;
+        }
+        foundConfirmation = true;
+        let toolConfirmation = null;
+        if (functionResponse.response && Object.keys(functionResponse.response).length === 1 && "response" in functionResponse.response) {
+          toolConfirmation = JSON.parse(
+            functionResponse.response["response"]
+          );
+        } else if (functionResponse.response) {
+          toolConfirmation = new import_tool_confirmation.ToolConfirmation({
+            hint: functionResponse.response["hint"],
+            payload: functionResponse.response["payload"],
+            confirmed: functionResponse.response["confirmed"]
+          });
+        }
+        if (functionResponse.id && toolConfirmation) {
+          requestConfirmationFunctionResponses[functionResponse.id] = toolConfirmation;
+        }
+      }
+      if (foundConfirmation) {
+        confirmationEventIndex = i;
+        break;
+      }
+    }
+    if (Object.keys(requestConfirmationFunctionResponses).length === 0) {
+      return;
+    }
+    for (let i = confirmationEventIndex - 1; i >= 0; i--) {
+      const event = events[i];
+      const functionCalls = (0, import_event.getFunctionCalls)(event);
+      if (!functionCalls) {
+        continue;
+      }
+      const toolsToResumeWithConfirmation = {};
+      const toolsToResumeWithArgs = {};
+      for (const functionCall of functionCalls) {
+        if (!functionCall.id || !(functionCall.id in requestConfirmationFunctionResponses)) {
+          continue;
+        }
+        const args = functionCall.args;
+        if (!args || !("originalFunctionCall" in args)) {
+          continue;
+        }
+        const originalFunctionCall = args["originalFunctionCall"];
+        if (originalFunctionCall.id) {
+          toolsToResumeWithConfirmation[originalFunctionCall.id] = requestConfirmationFunctionResponses[functionCall.id];
+          toolsToResumeWithArgs[originalFunctionCall.id] = originalFunctionCall;
+        }
+      }
+      if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+        continue;
+      }
+      for (let j = events.length - 1; j > confirmationEventIndex; j--) {
+        const eventToCheck = events[j];
+        const functionResponses = (0, import_event.getFunctionResponses)(eventToCheck);
+        if (!functionResponses) {
+          continue;
+        }
+        for (const fr of functionResponses) {
+          if (fr.id && fr.id in toolsToResumeWithConfirmation) {
+            delete toolsToResumeWithConfirmation[fr.id];
+            delete toolsToResumeWithArgs[fr.id];
+          }
+        }
+        if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+          break;
+        }
+      }
+      if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+        continue;
+      }
+      const toolsList = await agent.canonicalTools(
+        new import_readonly_context.ReadonlyContext(invocationContext)
+      );
+      const toolsDict = Object.fromEntries(
+        toolsList.map((tool) => [tool.name, tool])
+      );
+      const functionResponseEvent = await (0, import_functions.handleFunctionCallList)({
+        invocationContext,
+        functionCalls: Object.values(toolsToResumeWithArgs),
+        toolsDict,
+        beforeToolCallbacks: agent.canonicalBeforeToolCallbacks,
+        afterToolCallbacks: agent.canonicalAfterToolCallbacks,
+        filters: new Set(Object.keys(toolsToResumeWithConfirmation)),
+        toolConfirmationDict: toolsToResumeWithConfirmation
+      });
+      if (functionResponseEvent) {
+        yield functionResponseEvent;
+      }
+      return;
+    }
+  }
+}
+const REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR = new RequestConfirmationLlmRequestProcessor();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
+  RequestConfirmationLlmRequestProcessor
+});

package/dist/cjs/agents/processors/tool_filter_request_processor.js

@@ -0,0 +1,73 @@
+/**
+  * @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 tool_filter_request_processor_exports = {};
+__export(tool_filter_request_processor_exports, {
+  TOOL_FILTER_REQUEST_PROCESSOR: () => TOOL_FILTER_REQUEST_PROCESSOR,
+  ToolFilterRequestProcessor: () => ToolFilterRequestProcessor
+});
+module.exports = __toCommonJS(tool_filter_request_processor_exports);
+var import_context = require("../context.js");
+var import_llm_agent = require("../llm_agent.js");
+var import_readonly_context = require("../readonly_context.js");
+var import_base_llm_processor = require("./base_llm_processor.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ToolFilterRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  /** Filters the set of tools on the request based on plugins. */
+  // eslint-disable-next-line require-yield
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    if (!(0, import_llm_agent.isLlmAgent)(agent)) {
+      return;
+    }
+    const toolsList = await agent.canonicalTools(
+      new import_readonly_context.ReadonlyContext(invocationContext)
+    );
+    if (toolsList.length === 0) {
+      return;
+    }
+    const toolsDict = {};
+    for (const tool of toolsList) {
+      toolsDict[tool.name] = tool;
+    }
+    const callbackContext = new import_context.Context({ invocationContext });
+    const filteredTools = await invocationContext.pluginManager.runBeforeToolSelection({
+      callbackContext,
+      tools: toolsDict
+    });
+    if (filteredTools !== void 0) {
+      llmRequest.allowedTools = Object.keys(filteredTools);
+    }
+  }
+}
+const TOOL_FILTER_REQUEST_PROCESSOR = new ToolFilterRequestProcessor();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TOOL_FILTER_REQUEST_PROCESSOR,
+  ToolFilterRequestProcessor
+});

package/dist/cjs/agents/readonly_context.js

@@ -0,0 +1,83 @@
+/**
+  * @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 readonly_context_exports = {};
+__export(readonly_context_exports, {
+  ReadonlyContext: () => ReadonlyContext
+});
+module.exports = __toCommonJS(readonly_context_exports);
+var import_state = require("../sessions/state.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ReadonlyContext {
+  constructor(invocationContext) {
+    this.invocationContext = invocationContext;
+  }
+  /**
+   * The user content that started this invocation.
+   */
+  get userContent() {
+    return this.invocationContext.userContent;
+  }
+  /**
+   * The current invocation id.
+   */
+  get invocationId() {
+    return this.invocationContext.invocationId;
+  }
+  /**
+   * The user ID of the current session.
+   */
+  get userId() {
+    return this.invocationContext.userId;
+  }
+  /**
+   * The ID of the current session.
+   */
+  get sessionId() {
+    return this.invocationContext.session.id;
+  }
+  /**
+   * The current agent name.
+   */
+  get agentName() {
+    return this.invocationContext.agent.name;
+  }
+  /**
+   * The state of the current session.
+   */
+  get state() {
+    return new import_state.State(
+      this.invocationContext.session.state,
+      {}
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReadonlyContext
+});

package/dist/cjs/agents/routed_agent.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 __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_agent_exports = {};
+__export(routed_agent_exports, {
+  RoutedAgent: () => RoutedAgent,
+  isRoutedAgent: () => isRoutedAgent
+});
+module.exports = __toCommonJS(routed_agent_exports);
+var import_base_agent = require("./base_agent.js");
+var import_experimental = require("../utils/experimental.js");
+var import_failover_utils = require("../utils/failover_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const ROUTED_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.routedAgent");
+function isRoutedAgent(obj) {
+  return typeof obj === "object" && obj !== null && ROUTED_AGENT_SIGNATURE_SYMBOL in obj && obj[ROUTED_AGENT_SIGNATURE_SYMBOL] === true;
+}
+let RoutedAgent = class extends (_b = import_base_agent.BaseAgent, _a = ROUTED_AGENT_SIGNATURE_SYMBOL, _b) {
+  constructor(config) {
+    const agentsArray = Array.isArray(config.agents) ? config.agents : Object.values(config.agents);
+    super({
+      ...config,
+      subAgents: agentsArray
+    });
+    this[_a] = true;
+    if (Array.isArray(config.agents)) {
+      this.agents = Object.fromEntries(config.agents.map((a) => [a.name, a]));
+    } else {
+      this.agents = config.agents;
+    }
+    this.router = config.router;
+  }
+  /**
+   * Runs the selected agent via text-based conversation.
+   */
+  async *runAsyncImpl(context) {
+    yield* (0, import_failover_utils.runWithRouting)(
+      this.agents,
+      context,
+      this.router,
+      (agent) => agent.runAsync(context)
+    );
+  }
+  /**
+   * Runs the selected agent via video/audio-based conversation.
+   */
+  async *runLiveImpl(context) {
+    yield* (0, import_failover_utils.runWithRouting)(
+      this.agents,
+      context,
+      this.router,
+      (agent) => agent.runLive(context)
+    );
+  }
+};
+RoutedAgent = __decorateClass([
+  import_experimental.experimental
+], RoutedAgent);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RoutedAgent,
+  isRoutedAgent
+});

package/dist/cjs/agents/run_config.js

@@ -0,0 +1,71 @@
+/**
+  * @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 run_config_exports = {};
+__export(run_config_exports, {
+  StreamingMode: () => StreamingMode,
+  createRunConfig: () => createRunConfig
+});
+module.exports = __toCommonJS(run_config_exports);
+var import_logger = require("../utils/logger.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var StreamingMode = /* @__PURE__ */ ((StreamingMode2) => {
+  StreamingMode2["NONE"] = "none";
+  StreamingMode2["SSE"] = "sse";
+  StreamingMode2["BIDI"] = "bidi";
+  return StreamingMode2;
+})(StreamingMode || {});
+function createRunConfig(params = {}) {
+  return {
+    saveInputBlobsAsArtifacts: false,
+    supportCfc: false,
+    enableAffectiveDialog: false,
+    streamingMode: "none" /* NONE */,
+    maxLlmCalls: validateMaxLlmCalls(params.maxLlmCalls || 500),
+    pauseOnToolCalls: false,
+    ...params
+  };
+}
+function validateMaxLlmCalls(value) {
+  if (value > Number.MAX_SAFE_INTEGER) {
+    throw new Error(
+      `maxLlmCalls should be less than ${Number.MAX_SAFE_INTEGER}.`
+    );
+  }
+  if (value <= 0) {
+    import_logger.logger.warn(
+      "maxLlmCalls is less than or equal to 0. This will result in no enforcement on total number of llm calls that will be made for a run. This may not be ideal, as this could result in a never ending communication between the model and the agent in certain cases."
+    );
+  }
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StreamingMode,
+  createRunConfig
+});

package/dist/cjs/agents/sequential_agent.js

@@ -0,0 +1,106 @@
+/**
+  * @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 sequential_agent_exports = {};
+__export(sequential_agent_exports, {
+  SequentialAgent: () => SequentialAgent,
+  isSequentialAgent: () => isSequentialAgent
+});
+module.exports = __toCommonJS(sequential_agent_exports);
+var import_function_tool = require("../tools/function_tool.js");
+var import_base_agent = require("./base_agent.js");
+var import_llm_agent = require("./llm_agent.js");
+var import_readonly_context = require("./readonly_context.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const TASK_COMPLETED_TOOL_NAME = "task_completed";
+const SEQUENTIAL_AGENT_SIGNATURE_SYMBOL = Symbol.for(
+  "google.adk.sequentialAgent"
+);
+function isSequentialAgent(obj) {
+  return typeof obj === "object" && obj !== null && SEQUENTIAL_AGENT_SIGNATURE_SYMBOL in obj && obj[SEQUENTIAL_AGENT_SIGNATURE_SYMBOL] === true;
+}
+class SequentialAgent extends (_b = import_base_agent.BaseAgent, _a = SEQUENTIAL_AGENT_SIGNATURE_SYMBOL, _b) {
+  constructor() {
+    super(...arguments);
+    /**
+     * A unique symbol to identify ADK sequential agent class.
+     */
+    this[_a] = true;
+  }
+  async *runAsyncImpl(context) {
+    for (const subAgent of this.subAgents) {
+      for await (const event of subAgent.runAsync(context)) {
+        yield event;
+      }
+    }
+  }
+  /**
+   * Implementation for live SequentialAgent.
+   *
+   * Compared to the non-live case, live agents process a continuous stream of
+   * audio or video, so there is no way to tell if it's finished and should pass
+   * to the next agent or not. So we introduce a task_completed() function so
+   * the model can call this function to signal that it's finished the task and
+   * we can move on to the next agent.
+   *
+   * @param context The invocation context of the agent.
+   */
+  async *runLiveImpl(context) {
+    for (const subAgent of this.subAgents) {
+      if ((0, import_llm_agent.isLlmAgent)(subAgent)) {
+        const agentTools = await subAgent.canonicalTools(
+          new import_readonly_context.ReadonlyContext(context)
+        );
+        const taskCompletedToolAlreadyAdded = agentTools.some(
+          (tool) => tool.name === TASK_COMPLETED_TOOL_NAME
+        );
+        if (!taskCompletedToolAlreadyAdded) {
+          subAgent.tools.push(
+            new import_function_tool.FunctionTool({
+              name: TASK_COMPLETED_TOOL_NAME,
+              description: `Signals that the model has successfully completed the user's question or task.`,
+              execute: () => "Task completion signaled."
+            })
+          );
+          subAgent.instruction += `If you finished the user's request according to its description, call the ${TASK_COMPLETED_TOOL_NAME} function to exit so the next agents can take over. When calling this function, do not generate any text other than the function call.`;
+        }
+      }
+    }
+    for (const subAgent of this.subAgents) {
+      for await (const event of subAgent.runLive(context)) {
+        yield event;
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SequentialAgent,
+  isSequentialAgent
+});

package/dist/cjs/agents/transcription_entry.js

@@ -0,0 +1,27 @@
+/**
+  * @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 __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 transcription_entry_exports = {};
+module.exports = __toCommonJS(transcription_entry_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/cjs/artifacts/base_artifact_service.js

@@ -0,0 +1,27 @@
+/**
+  * @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 __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 base_artifact_service_exports = {};
+module.exports = __toCommonJS(base_artifact_service_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */