@google/adk 1.5.0 → 2.0.0

package/dist/web/workflow/workflow.js

@@ -0,0 +1,529 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+import { context, trace } from "@opentelemetry/api";
+import { tracer, traceWorkflowInvocation } from "../telemetry/tracing.js";
+import { experimental } from "../utils/experimental.js";
+import { BaseNode } from "./base_node.js";
+import { commonPrefixOf } from "./branch_path.js";
+import { DynamicNodeScheduler } from "./dynamic_node_scheduler.js";
+import { isInvocationAbortedError } from "./errors.js";
+import {
+  createGraphFromEdgeItems
+} from "./graph.js";
+import {
+  claimNodeErrorReport,
+  createNodeErrorEvent
+} from "./node_error_event.js";
+import { executeChildNode } from "./node_runner.js";
+import { createNodeState } from "./node_state.js";
+import { NodeStatus } from "./node_status.js";
+import { DynamicNodeState } from "./schedule_dynamic_node.js";
+import {
+  eventsForCurrentRun,
+  isFastForwardable,
+  makeFastForwardResult,
+  reconstructNodeRuns,
+  resolvedInterruptResponses
+} from "./utils/rehydration_utils.js";
+const WORKFLOW_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.workflow");
+const _LoopState = class _LoopState {
+  constructor() {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.nodeOutputs = /* @__PURE__ */ new Map();
+    this.nodeBranches = /* @__PURE__ */ new Map();
+    this.triggerBuffer = /* @__PURE__ */ new Map();
+    this.pending = /* @__PURE__ */ new Map();
+    this.interruptIds = /* @__PURE__ */ new Set();
+    /** Per-node state reconstructed from prior session events (resume). */
+    this.rehydrated = /* @__PURE__ */ new Map();
+    /** Nodes already activated in this turn, so a repeat activation is visible. */
+    this.activated = /* @__PURE__ */ new Set();
+    this.errorShutDown = false;
+  }
+};
+__name(_LoopState, "LoopState");
+let LoopState = _LoopState;
+let Workflow = class extends (_b = BaseNode, _a = WORKFLOW_SIGNATURE_SYMBOL, _b) {
+  constructor(config) {
+    var _a2;
+    super(__spreadProps(__spreadValues({}, config), { rerunOnResume: (_a2 = config.rerunOnResume) != null ? _a2 : true }));
+    /** Brand identifying this object as a {@link Workflow} (see `isWorkflow`). */
+    this[_a] = true;
+    const hasEdges = !!config.edges && config.edges.length > 0;
+    if (hasEdges && config.dynamicEntry) {
+      throw new Error(
+        'Workflow "'.concat(this.name, '": "edges" and "dynamicEntry" are mutually exclusive.')
+      );
+    }
+    if (!hasEdges && !config.dynamicEntry) {
+      throw new Error(
+        'Workflow "'.concat(this.name, '" requires either "edges" or "dynamicEntry".')
+      );
+    }
+    if (config.maxConcurrency !== void 0 && (!Number.isInteger(config.maxConcurrency) || config.maxConcurrency < 1)) {
+      throw new Error(
+        'Workflow "'.concat(this.name, '": "maxConcurrency" must be a positive integer ') + "(got ".concat(config.maxConcurrency, ").")
+      );
+    }
+    this.maxConcurrency = config.maxConcurrency;
+    this.dynamicEntry = config.dynamicEntry;
+    if (config.edges && config.edges.length > 0) {
+      this.graph = createGraphFromEdgeItems(config.edges);
+    }
+  }
+  // eslint-disable-next-line require-yield -- child events stream out via ctx.channel/ctx.runNode; this orchestration generator itself yields nothing
+  runImpl(ctx, nodeInput) {
+    return __asyncGenerator(this, null, function* () {
+      const dynamicState = new DynamicNodeState();
+      const abort = createWorkflowAbort(ctx.invocationContext.abortSignal);
+      ctx.scheduler = new DynamicNodeScheduler(
+        dynamicState,
+        abort.controller.signal
+      );
+      const span = tracer.startSpan("invoke_workflow ".concat(this.name));
+      try {
+        yield new __await(context.with(trace.setSpan(context.active(), span), () => {
+          traceWorkflowInvocation({
+            workflowName: this.name,
+            nodePath: ctx.nodePath,
+            sessionId: ctx.invocationContext.session.id
+          });
+          return this.orchestrate(ctx, nodeInput, dynamicState, abort.controller);
+        }));
+      } finally {
+        abort.dispose();
+        span.end();
+      }
+    });
+  }
+  /**
+   * The orchestration body, wrapped by {@link runImpl} so its workflow-scoped
+   * abort controller is always disposed.
+   */
+  async orchestrate(ctx, nodeInput, dynamicState, abortController) {
+    var _a2, _b2;
+    const runEvents = eventsForCurrentRun(
+      (_b2 = (_a2 = ctx.session) == null ? void 0 : _a2.events) != null ? _b2 : [],
+      ctx.invocationId
+    );
+    const rehydrated = reconstructNodeRuns(
+      runEvents,
+      ctx.nodePath || void 0
+    );
+    this.applyResumeInputs(ctx, runEvents);
+    if (this.dynamicEntry) {
+      await this.runDynamicEntry(ctx, nodeInput, dynamicState);
+      return;
+    }
+    const loop = new LoopState();
+    loop.rehydrated = rehydrated;
+    loop.abortSignal = abortController.signal;
+    this.seedStartTriggers(loop, nodeInput);
+    await this.runLoop(loop, ctx, abortController);
+    if (loop.errorShutDown) {
+      return;
+    }
+    this.collectRemainingInterrupts(loop);
+    for (const id of dynamicState.interruptIds) {
+      loop.interruptIds.add(id);
+    }
+    this.finalize(loop, ctx);
+  }
+  /**
+   * Runs an imperative `dynamicEntry` workflow. The entry drives execution via
+   * `ctx.runNode(...)` (routed through the scheduler) and returns the output.
+   */
+  async runDynamicEntry(ctx, nodeInput, dynamicState) {
+    const output = await this.dynamicEntry(ctx, nodeInput);
+    if (dynamicState.interruptIds.size > 0) {
+      ctx.interruptIds = [...dynamicState.interruptIds];
+      return;
+    }
+    if (output !== void 0) {
+      ctx.output = output;
+    }
+  }
+  /**
+   * Merges resolved interrupt responses from prior session events into
+   * `ctx.resumeInputs`, so waiting nodes (which read `ctx.resumeInputs[id]`)
+   * resume with the user's response. Shared by child contexts via propagation.
+   *
+   * Taken from the events rather than from `rehydrated`, because that view is
+   * scoped to this workflow's direct children: an interrupt raised deeper — by
+   * a `ctx.runNode` child, or inside a nested workflow — is keyed out of it,
+   * and its answer would never reach the node waiting on it.
+   */
+  applyResumeInputs(ctx, runEvents) {
+    for (const [interruptId, response] of resolvedInterruptResponses(
+      runEvents
+    )) {
+      ctx.resumeInputs[interruptId] = response;
+    }
+  }
+  // --- SETUP ---
+  seedStartTriggers(loop, nodeInput) {
+    const startEdges = this.graph.edges.filter(
+      (e) => e.fromNode.name === "__START__"
+    );
+    const useSubBranch = startEdges.length > 1;
+    for (const edge of startEdges) {
+      this.pushTrigger(loop, edge.toNode.name, {
+        input: nodeInput,
+        useSubBranch
+      });
+    }
+  }
+  // --- LOOP ---
+  async runLoop(loop, ctx, abortController) {
+    for (; ; ) {
+      this.scheduleReadyNodes(loop, ctx);
+      if (loop.pending.size === 0) {
+        break;
+      }
+      const result = await Promise.race(loop.pending.values());
+      loop.pending.delete(result.name);
+      if (result.error) {
+        const nodeState = loop.nodes.get(result.name);
+        if (nodeState) {
+          nodeState.status = NodeStatus.FAILED;
+        }
+        this.reportNodeError(loop, ctx, result.name, result.error);
+        loop.errorShutDown = true;
+        await this.cleanupPending(loop, abortController);
+        throw result.error;
+      }
+      await this.handleCompletion(loop, result.name, result.childCtx);
+    }
+  }
+  reportNodeError(loop, ctx, nodeName, error) {
+    var _a2, _b2, _c;
+    if (isInvocationAbortedError(error) || ((_a2 = loop.abortSignal) == null ? void 0 : _a2.aborted)) {
+      return;
+    }
+    if (!claimNodeErrorReport(error, ctx.invocationId)) {
+      return;
+    }
+    ctx.emit(
+      createNodeErrorEvent({
+        error,
+        attemptCount: (_c = (_b2 = loop.nodes.get(nodeName)) == null ? void 0 : _b2.attemptCount) != null ? _c : 1,
+        author: nodeName,
+        invocationId: ctx.invocationId,
+        nodeInfo: {
+          path: ctx.nodePath ? "".concat(ctx.nodePath, ".").concat(nodeName) : nodeName
+        },
+        branch: ctx.branch,
+        isolationScope: ctx.isolationScope
+      })
+    );
+  }
+  // --- Scheduling ---
+  scheduleReadyNodes(loop, ctx) {
+    for (const nodeName of [...loop.triggerBuffer.keys()]) {
+      if (loop.pending.has(nodeName)) {
+        continue;
+      }
+      const state = loop.nodes.get(nodeName);
+      if (state) {
+        if (state.status === NodeStatus.RUNNING) {
+          continue;
+        }
+        if (state.status === NodeStatus.WAITING && state.interrupts.length > 0) {
+          continue;
+        }
+      }
+      if (this.atConcurrencyLimit(loop)) {
+        break;
+      }
+      const trigger = this.popTrigger(loop, nodeName);
+      if (!trigger) {
+        continue;
+      }
+      this.prepareNodeStateForStarting(loop, nodeName, trigger);
+      this.startNodeTask(loop, ctx, nodeName, trigger);
+    }
+  }
+  atConcurrencyLimit(loop) {
+    return this.maxConcurrency !== void 0 && loop.pending.size >= this.maxConcurrency;
+  }
+  prepareNodeStateForStarting(loop, nodeName, trigger) {
+    var _a2;
+    const existing = loop.nodes.get(nodeName);
+    const state = createNodeState({
+      runCounter: (_a2 = existing == null ? void 0 : existing.runCounter) != null ? _a2 : 0
+    });
+    state.input = trigger.input;
+    state.status = NodeStatus.RUNNING;
+    loop.nodes.set(nodeName, state);
+  }
+  startNodeTask(loop, ctx, nodeName, trigger) {
+    var _a2, _b2;
+    const node = this.getStaticNode(nodeName);
+    const nodeState = loop.nodes.get(nodeName);
+    const repeatActivation = loop.activated.has(nodeName);
+    loop.activated.add(nodeName);
+    const prior = (_a2 = loop.rehydrated.get(nodeName)) == null ? void 0 : _a2.shift();
+    if (prior && isFastForwardable(prior)) {
+      loop.pending.set(
+        nodeName,
+        Promise.resolve({
+          name: nodeName,
+          childCtx: makeFastForwardResult(ctx, prior)
+        })
+      );
+      return;
+    }
+    if (prior && !node.rerunOnResume && prior.output === void 0 && prior.interruptIds.size > 0) {
+      const values = [...prior.interruptIds].map((id) => ctx.resumeInputs[id]);
+      if (values.every((v) => v !== void 0)) {
+        const output = values.length === 1 ? values[0] : values;
+        const resumeResult = {
+          output,
+          route: void 0,
+          branch: (_b2 = prior.branch) != null ? _b2 : ctx.branch,
+          interruptIds: []
+        };
+        loop.pending.set(
+          nodeName,
+          Promise.resolve({ name: nodeName, childCtx: resumeResult })
+        );
+        return;
+      }
+    }
+    let runId = nodeState.runId;
+    if (!runId) {
+      nodeState.runCounter += 1;
+      runId = String(nodeState.runCounter);
+      nodeState.runId = runId;
+    }
+    const resuming = prior !== void 0 && prior.interruptIds.size > 0 && prior.input !== void 0;
+    const nodeInput = resuming ? prior.input : trigger.input;
+    const task = executeChildNode({
+      parent: ctx,
+      node,
+      input: nodeInput,
+      abortSignal: loop.abortSignal,
+      nodeState,
+      resumeInputs: repeatActivation ? {} : void 0,
+      options: {
+        runId,
+        useSubBranch: trigger.useSubBranch,
+        overrideBranch: trigger.branch,
+        overrideIsolationScope: trigger.isolationScope
+      }
+    }).then(
+      (childCtx) => ({ name: nodeName, childCtx }),
+      (error) => ({ name: nodeName, error })
+    );
+    loop.pending.set(nodeName, task);
+  }
+  // --- Completion handling ---
+  async handleCompletion(loop, nodeName, childCtx) {
+    var _a2;
+    const nodeState = loop.nodes.get(nodeName);
+    const node = this.getStaticNode(nodeName);
+    if (childCtx.interruptIds.length > 0) {
+      nodeState.status = NodeStatus.WAITING;
+      nodeState.interrupts = [...childCtx.interruptIds];
+      childCtx.interruptIds.forEach((id) => loop.interruptIds.add(id));
+      return;
+    }
+    if (node.waitForOutput && childCtx.output === void 0 && childCtx.route === void 0) {
+      nodeState.status = NodeStatus.WAITING;
+      return;
+    }
+    nodeState.status = NodeStatus.COMPLETED;
+    if (childCtx.output !== void 0) {
+      loop.nodeOutputs.set(nodeName, childCtx.output);
+    }
+    loop.nodeBranches.set(nodeName, (_a2 = childCtx.branch) != null ? _a2 : "");
+    this.bufferDownstreamTriggers(
+      loop,
+      nodeName,
+      childCtx.output,
+      childCtx.route,
+      childCtx.branch
+    );
+  }
+  bufferDownstreamTriggers(loop, nodeName, output, route, branch) {
+    const nextNodes = this.graph.getNextPendingNodes(nodeName, route != null ? route : null);
+    const useSubBranch = nextNodes.length > 1;
+    for (const targetName of nextNodes) {
+      const targetNode = this.getStaticNode(targetName);
+      if (targetNode.requiresAllPredecessors) {
+        const predecessors = new Set(
+          this.graph.edges.filter((e) => e.toNode.name === targetName).map(
+            (e) => e.fromNode.name
+          )
+        );
+        const allCompleted = [...predecessors].every(
+          (p) => {
+            var _a2;
+            return ((_a2 = loop.nodes.get(p)) == null ? void 0 : _a2.status) === NodeStatus.COMPLETED;
+          }
+        );
+        if (allCompleted) {
+          const outputs = {};
+          for (const p of predecessors) {
+            outputs[p] = loop.nodeOutputs.get(p);
+          }
+          const branches = [...predecessors].map(
+            (p) => {
+              var _a2;
+              return (_a2 = loop.nodeBranches.get(p)) != null ? _a2 : "";
+            }
+          );
+          const commonBranch = commonPrefixOf(branches);
+          this.pushTrigger(loop, targetName, {
+            input: outputs,
+            useSubBranch: false,
+            branch: commonBranch || void 0
+          });
+        }
+      } else {
+        this.pushTrigger(loop, targetName, {
+          input: output,
+          useSubBranch,
+          branch
+        });
+      }
+    }
+  }
+  collectRemainingInterrupts(loop) {
+    for (const nodeState of loop.nodes.values()) {
+      if (nodeState.status === NodeStatus.WAITING && nodeState.interrupts.length > 0) {
+        nodeState.interrupts.forEach((id) => loop.interruptIds.add(id));
+      }
+    }
+  }
+  // --- FINALIZE ---
+  finalize(loop, ctx) {
+    if (loop.interruptIds.size > 0) {
+      ctx.interruptIds = [...loop.interruptIds];
+      return;
+    }
+    const terminalOutputs = [...this.graph.terminalNodeNames].filter((name) => loop.nodeOutputs.has(name)).map((name) => loop.nodeOutputs.get(name));
+    if (terminalOutputs.length === 1) {
+      ctx.output = terminalOutputs[0];
+    } else if (terminalOutputs.length > 1) {
+      throw new Error(
+        "Workflow ".concat(this.name, ": multiple terminal nodes produced output ") + "(".concat(terminalOutputs.length, "). A workflow must have at most one terminal output.")
+      );
+    }
+  }
+  // --- Utilities ---
+  pushTrigger(loop, nodeName, trigger) {
+    const buffer = loop.triggerBuffer.get(nodeName);
+    if (buffer) {
+      buffer.push(trigger);
+    } else {
+      loop.triggerBuffer.set(nodeName, [trigger]);
+    }
+  }
+  popTrigger(loop, nodeName) {
+    const buffer = loop.triggerBuffer.get(nodeName);
+    if (!buffer || buffer.length === 0) {
+      return void 0;
+    }
+    const trigger = buffer.shift();
+    if (buffer.length === 0) {
+      loop.triggerBuffer.delete(nodeName);
+    }
+    return trigger;
+  }
+  getStaticNode(name) {
+    const node = this.graph.nodes.find((n) => n.name === name);
+    if (!node) {
+      throw new Error("Node ".concat(name, " not found in graph."));
+    }
+    return node;
+  }
+  async cleanupPending(loop, abortController) {
+    abortController.abort();
+    const outstanding = [...loop.pending.values()];
+    loop.pending.clear();
+    await Promise.allSettled(outstanding);
+  }
+};
+__name(Workflow, "Workflow");
+Workflow = __decorateClass([
+  experimental
+], Workflow);
+function isWorkflow(value) {
+  return typeof value === "object" && value !== null && WORKFLOW_SIGNATURE_SYMBOL in value && value[WORKFLOW_SIGNATURE_SYMBOL] === true;
+}
+__name(isWorkflow, "isWorkflow");
+function createWorkflowAbort(parentSignal) {
+  const controller = new AbortController();
+  if (!parentSignal) {
+    return { controller, dispose: /* @__PURE__ */ __name(() => {
+    }, "dispose") };
+  }
+  if (parentSignal.aborted) {
+    controller.abort();
+    return { controller, dispose: /* @__PURE__ */ __name(() => {
+    }, "dispose") };
+  }
+  const onParentAbort = /* @__PURE__ */ __name(() => controller.abort(), "onParentAbort");
+  parentSignal.addEventListener("abort", onParentAbort, { once: true });
+  return {
+    controller,
+    dispose: /* @__PURE__ */ __name(() => parentSignal.removeEventListener("abort", onParentAbort), "dispose")
+  };
+}
+__name(createWorkflowAbort, "createWorkflowAbort");
+export {
+  Workflow,
+  isWorkflow
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@google/adk",
-  "version": "1.5.0",
+  "version": "2.0.0",
   "description": "Google ADK JS",
   "author": "Google",
   "license": "Apache-2.0",
@@ -22,10 +22,46 @@
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
+      "browser": "./dist/web/index_web.js",
       "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.js",
       "default": "./dist/esm/index.js"
-    }
+    },
+    "./dist/web/*": {
+      "types": "./dist/types/*",
+      "default": "./dist/web/*"
+    },
+    "./a2a": {
+      "types": "./dist/types/a2a/index.d.ts",
+      "import": "./dist/esm/a2a/index.js",
+      "require": "./dist/cjs/a2a/index.js",
+      "default": "./dist/esm/a2a/index.js"
+    },
+    "./artifacts/gcs": {
+      "types": "./dist/types/artifacts/gcs_artifact_service.d.ts",
+      "import": "./dist/esm/artifacts/gcs_artifact_service.js",
+      "require": "./dist/cjs/artifacts/gcs_artifact_service.js",
+      "default": "./dist/esm/artifacts/gcs_artifact_service.js"
+    },
+    "./sessions/database": {
+      "types": "./dist/types/sessions/database_session_service.d.ts",
+      "import": "./dist/esm/sessions/database_session_service.js",
+      "require": "./dist/cjs/sessions/database_session_service.js",
+      "default": "./dist/esm/sessions/database_session_service.js"
+    },
+    "./telemetry/gcp": {
+      "types": "./dist/types/telemetry/google_cloud.d.ts",
+      "import": "./dist/esm/telemetry/google_cloud.js",
+      "require": "./dist/cjs/telemetry/google_cloud.js",
+      "default": "./dist/esm/telemetry/google_cloud.js"
+    },
+    "./tools/mcp": {
+      "types": "./dist/types/tools/mcp/index.d.ts",
+      "import": "./dist/esm/tools/mcp/index.js",
+      "require": "./dist/cjs/tools/mcp/index.js",
+      "default": "./dist/esm/tools/mcp/index.js"
+    },
+    "./package.json": "./package.json"
   },
   "scripts": {
     "clean": "rm -rf dist",
@@ -41,14 +77,10 @@
   },
   "dependencies": {
     "@a2a-js/sdk": "^0.3.10",
-    "@google-cloud/opentelemetry-cloud-monitoring-exporter": "^0.21.0",
-    "@google-cloud/opentelemetry-cloud-trace-exporter": "^3.0.0",
-    "@google-cloud/storage": "^7.17.1",
     "@google-cloud/vertexai": "^1.12.0",
     "@google/genai": "^2.9.0",
     "@mikro-orm/core": "^6.6.10",
     "@mikro-orm/reflection": "^6.6.6",
-    "@modelcontextprotocol/sdk": "^1.26.0",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/api-logs": "^0.205.0",
     "@opentelemetry/exporter-logs-otlp-http": "^0.205.0",
@@ -61,7 +93,6 @@
     "@opentelemetry/sdk-trace-base": "^2.1.0",
     "@opentelemetry/sdk-trace-node": "^2.1.0",
     "adm-zip": "^0.5.17",
-    "express": "^4.22.1",
     "google-auth-library": "^10.3.0",
     "js-yaml": "^4.1.1",
     "jsonpath-plus": "^10.4.0",
@@ -71,17 +102,60 @@
     "zod-to-json-schema": "^3.25.1"
   },
   "devDependencies": {
+    "@google-cloud/opentelemetry-cloud-monitoring-exporter": "^0.21.0",
+    "@google-cloud/opentelemetry-cloud-trace-exporter": "^3.0.0",
+    "@google-cloud/storage": "^7.17.1",
     "@mikro-orm/sqlite": "^6.6.6",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@opentelemetry/context-async-hooks": "^2.1.0",
     "@types/adm-zip": "^0.5.8",
     "@types/express": "^4.17.25",
     "@types/lodash-es": "^4.17.12",
+    "express": "^4.22.1",
     "openapi-types": "^12.1.3"
   },
   "peerDependencies": {
+    "@google-cloud/opentelemetry-cloud-monitoring-exporter": "^0.21.0",
+    "@google-cloud/opentelemetry-cloud-trace-exporter": "^3.0.0",
+    "@google-cloud/storage": "^7.17.1",
     "@mikro-orm/mariadb": "^6.6.6",
     "@mikro-orm/mssql": "^6.6.6",
     "@mikro-orm/mysql": "^6.6.6",
     "@mikro-orm/postgresql": "^6.6.6",
-    "@mikro-orm/sqlite": "^6.6.6"
+    "@mikro-orm/sqlite": "^6.6.6",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "express": "^4.22.1 || ^5.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@google-cloud/opentelemetry-cloud-monitoring-exporter": {
+      "optional": true
+    },
+    "@google-cloud/opentelemetry-cloud-trace-exporter": {
+      "optional": true
+    },
+    "@google-cloud/storage": {
+      "optional": true
+    },
+    "@mikro-orm/mariadb": {
+      "optional": true
+    },
+    "@mikro-orm/mssql": {
+      "optional": true
+    },
+    "@mikro-orm/mysql": {
+      "optional": true
+    },
+    "@mikro-orm/postgresql": {
+      "optional": true
+    },
+    "@mikro-orm/sqlite": {
+      "optional": true
+    },
+    "@modelcontextprotocol/sdk": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    }
   }
 }