@hachej/boring-agent 0.1.0 → 0.1.5

package/dist/front/index.js

@@ -236,7 +236,7 @@ function useAgentChat(opts) {
   }, [sessionId, cacheKey, setMessages]);
   const messages = chat.messages;
   useEffect4(() => {
-    if (!hydrated || !cacheKey) return;
+    if (!hydrated || !cacheKey || messages.length === 0) return;
     try {
       globalThis.localStorage?.setItem(cacheKey, JSON.stringify(messages));
     } catch {

package/dist/server/index.js

@@ -180,8 +180,10 @@ function createDirectSandbox() {
 }
 
 // src/server/sandbox/bwrap/createBwrapSandbox.ts
+import { access } from "fs/promises";
+import { constants } from "fs";
 import { spawn as spawn2 } from "child_process";
-import { isAbsolute as isAbsolute2, relative, resolve, sep } from "path";
+import { dirname, isAbsolute as isAbsolute2, join as join2, relative, resolve, sep } from "path";
 
 // src/server/sandbox/bwrap/buildBwrapArgs.ts
 import { isAbsolute } from "path";
@@ -250,9 +252,12 @@ function buildBwrapArgs(workspaceRoot, options) {
     SANDBOX_HOME,
     "--setenv",
     "HOME",
-    SANDBOX_HOME,
-    "--"
+    SANDBOX_HOME
   );
+  if (options?.postWorkspaceArgs) {
+    args.push(...options.postWorkspaceArgs);
+  }
+  args.push("--");
   return args;
 }
 
@@ -347,6 +352,26 @@ async function assertBwrapAvailable() {
     });
   });
 }
+async function dirAccessible(path4) {
+  try {
+    await access(path4, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function buildGlobalToolMounts(workspaceRoot) {
+  const globalRoot = dirname(workspaceRoot);
+  if (globalRoot === workspaceRoot) return [];
+  const args = [];
+  if (await dirAccessible(join2(globalRoot, ".boring-agent"))) {
+    args.push("--ro-bind", join2(globalRoot, ".boring-agent"), `${SANDBOX_HOME2}/.boring-agent`);
+  }
+  if (await dirAccessible(join2(globalRoot, ".venv"))) {
+    args.push("--ro-bind", join2(globalRoot, ".venv"), `${SANDBOX_HOME2}/.venv`);
+  }
+  return args;
+}
 function createBwrapSandbox() {
   let workspace = null;
   return {
@@ -367,7 +392,8 @@ function createBwrapSandbox() {
       const maxOutputBytes = opts?.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES2;
       const workspaceRoot = workspace.root;
       const sandboxCwd = computeSandboxCwd(workspaceRoot, opts?.cwd);
-      const baseArgs = buildBwrapArgs(workspaceRoot);
+      const postWorkspaceArgs = await buildGlobalToolMounts(workspaceRoot);
+      const baseArgs = buildBwrapArgs(workspaceRoot, { postWorkspaceArgs });
       const args = [
         ...withSandboxCwd(baseArgs, sandboxCwd),
         "bash",
@@ -1182,12 +1208,12 @@ async function prepareVercelDeploymentSnapshot(opts) {
 
 // src/server/workspace/createNodeWorkspace.ts
 import { lstat as lstat2, mkdir as mkdir3, readdir, readFile as readFile3, rename as rename3, rmdir, stat as stat2, unlink as unlink3, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname2, relative as relative3, sep as sep2 } from "path";
+import { dirname as dirname3, relative as relative3, sep as sep2 } from "path";
 import chokidar from "chokidar";
 
 // src/server/workspace/paths.ts
 import { lstat, realpath, stat } from "fs/promises";
-import { dirname, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve2 } from "path";
+import { dirname as dirname2, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve2 } from "path";
 function createPathValidationError(reason, requestedPath, message) {
   return Object.assign(new Error(message), {
     statusCode: 400,
@@ -1247,7 +1273,7 @@ async function ensureExistingWorkspacePath(workspaceRoot, relPath) {
 }
 async function ensureWritableWorkspacePath(workspaceRoot, relPath) {
   const absPath = validatePath(workspaceRoot, relPath);
-  const parentPath = dirname(absPath);
+  const parentPath = dirname2(absPath);
   await stat(parentPath);
   await assertRealPathWithinWorkspace(workspaceRoot, parentPath);
   try {
@@ -1419,7 +1445,7 @@ function createNodeWorkspace(root) {
         } catch (error) {
           const code = error.code;
           if (code !== "ENOENT") throw error;
-          const parent = dirname2(existingAncestor);
+          const parent = dirname3(existingAncestor);
           if (parent === existingAncestor) throw error;
           existingAncestor = parent;
         }
@@ -1438,9 +1464,9 @@ function createNodeWorkspace(root) {
 
 // src/server/workspace/provisionRuntime.ts
 import { createHash as createHash3 } from "crypto";
-import { constants } from "fs";
-import { access, chmod as chmod3, cp, mkdir as mkdir4, readdir as readdir2, readFile as readFile4, stat as stat3, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname3, join as join2, resolve as resolve3 } from "path";
+import { constants as constants2 } from "fs";
+import { access as access2, chmod as chmod3, cp, mkdir as mkdir4, readdir as readdir2, readFile as readFile4, stat as stat3, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4, join as join3, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -1451,7 +1477,7 @@ function toPath(value) {
 }
 async function exists(path4) {
   try {
-    await access(path4, constants.F_OK);
+    await access2(path4, constants2.F_OK);
     return true;
   } catch {
     return false;
@@ -1480,7 +1506,7 @@ async function hashPath(path4, hash) {
     for (const entry of entries) {
       hash.update(`dir:${entry}
 `);
-      await hashPath(join2(path4, entry), hash);
+      await hashPath(join3(path4, entry), hash);
     }
     return;
   }
@@ -1507,7 +1533,7 @@ async function fingerprint(contributions) {
 `);
       hash.update(JSON.stringify(spec.extraLibs ?? []));
       hash.update(JSON.stringify(Object.fromEntries(Object.entries(spec.env ?? {}).map(([k, v]) => [k, String(v)]))));
-      if (await exists(projectFile)) await hashPath(dirname3(projectFile), hash);
+      if (await exists(projectFile)) await hashPath(dirname4(projectFile), hash);
     }
   }
   return `sha256:${hash.digest("hex")}`;
@@ -1536,14 +1562,14 @@ async function seedTemplates(workspaceRoot, contributions) {
 }
 async function ensurePython(workspaceRoot, specs) {
   if (specs.length === 0) return;
-  const venvPython = join2(workspaceRoot, ".venv", "bin", "python");
+  const venvPython = join3(workspaceRoot, ".venv", "bin", "python");
   const uv = await commandExists("uv");
   if (!await exists(venvPython)) {
     if (uv) await run("uv", ["venv", ".venv"], workspaceRoot);
     else await run("/usr/bin/python3", ["-m", "venv", ".venv"], workspaceRoot);
   }
   for (const spec of specs) {
-    const projectDir = dirname3(toPath(spec.projectFile));
+    const projectDir = dirname4(toPath(spec.projectFile));
     if (uv) {
       await run("uv", ["pip", "install", "--python", venvPython, projectDir], workspaceRoot);
       if (spec.extraLibs?.length) {
@@ -1569,12 +1595,12 @@ function assertEnvKey(key) {
 }
 async function isRuntimeMaterialized(workspaceRoot, contributions) {
   const hasPython = contributions.some(({ provisioning }) => (provisioning.python ?? []).length > 0);
-  if (hasPython && !await exists(join2(workspaceRoot, ".venv", "bin", "python"))) return false;
+  if (hasPython && !await exists(join3(workspaceRoot, ".venv", "bin", "python"))) return false;
   return true;
 }
 async function writeShims(workspaceRoot, env) {
-  const shimDir = join2(workspaceRoot, ".boring-agent", "bin");
-  const venvBin = join2(workspaceRoot, ".venv", "bin");
+  const shimDir = join3(workspaceRoot, ".boring-agent", "bin");
+  const venvBin = join3(workspaceRoot, ".venv", "bin");
   await mkdir4(shimDir, { recursive: true });
   const exports = Object.entries(env).map(([key, value]) => {
     assertEnvKey(key);
@@ -1588,21 +1614,21 @@ export BORING_AGENT_WORKSPACE_ROOT="$WORKSPACE_ROOT"
 ${exports}
 VENV_BIN="$WORKSPACE_ROOT/.venv/bin"
 `;
-  await writeExecutable(join2(shimDir, "python"), `${base}exec "$VENV_BIN/python" "$@"
+  await writeExecutable(join3(shimDir, "python"), `${base}exec "$VENV_BIN/python" "$@"
 `);
-  await writeExecutable(join2(shimDir, "python3"), `${base}exec "$VENV_BIN/python" "$@"
+  await writeExecutable(join3(shimDir, "python3"), `${base}exec "$VENV_BIN/python" "$@"
 `);
-  await writeExecutable(join2(shimDir, "pip"), `${base}exec "$VENV_BIN/python" -m pip "$@"
+  await writeExecutable(join3(shimDir, "pip"), `${base}exec "$VENV_BIN/python" -m pip "$@"
 `);
-  await writeExecutable(join2(shimDir, "pip3"), `${base}exec "$VENV_BIN/python" -m pip "$@"
+  await writeExecutable(join3(shimDir, "pip3"), `${base}exec "$VENV_BIN/python" -m pip "$@"
 `);
   if (await exists(venvBin)) {
     for (const entry of await readdir2(venvBin)) {
       if (["python", "python3", "pip", "pip3"].includes(entry)) continue;
-      const full = join2(venvBin, entry);
+      const full = join3(venvBin, entry);
       const info = await stat3(full).catch(() => null);
       if (!info?.isFile()) continue;
-      await writeExecutable(join2(shimDir, entry), `${base}TARGET="$VENV_BIN"/${bashSingleQuote(entry)}
+      await writeExecutable(join3(shimDir, entry), `${base}TARGET="$VENV_BIN"/${bashSingleQuote(entry)}
 SHEBANG="$(head -n 1 "$TARGET" 2>/dev/null || true)"
 case "$SHEBANG" in
   *python*) exec "$VENV_BIN/python" "$TARGET" "$@" ;;
@@ -1625,8 +1651,8 @@ async function provisionRuntimeWorkspace({
   await mkdir4(workspaceRoot, { recursive: true });
   const env = collectEnv(active);
   const hash = await fingerprint(active);
-  const markerPath = join2(workspaceRoot, ".boring-agent", "provisioning.json");
-  const binDir = join2(workspaceRoot, ".boring-agent", "bin");
+  const markerPath = join3(workspaceRoot, ".boring-agent", "provisioning.json");
+  const binDir = join3(workspaceRoot, ".boring-agent", "bin");
   if (!force && await exists(markerPath)) {
     try {
       const marker = JSON.parse(await readFile4(markerPath, "utf8"));
@@ -1640,7 +1666,7 @@ async function provisionRuntimeWorkspace({
   await seedTemplates(workspaceRoot, active);
   await ensurePython(workspaceRoot, active.flatMap(({ provisioning }) => provisioning.python ?? []));
   const actualBinDir = await writeShims(workspaceRoot, env);
-  await mkdir4(dirname3(markerPath), { recursive: true });
+  await mkdir4(dirname4(markerPath), { recursive: true });
   await writeFile4(markerPath, JSON.stringify({ v: PROVISIONING_VERSION, fingerprint: hash }, null, 2), "utf8");
   return { fingerprint: hash, changed: true, env, binDir: actualBinDir };
 }
@@ -2011,7 +2037,7 @@ function createServerFileSearch(workspace, sandbox) {
 
 // src/server/workspace/provision.ts
 import { cp as cp2, mkdir as mkdir5, stat as stat4, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname4, join as join3 } from "path";
+import { dirname as dirname5, join as join4 } from "path";
 var PROVISION_MARKER_REL_PATH = ".boring-agent/provisioned";
 async function fileExists(targetPath) {
   try {
@@ -2026,7 +2052,7 @@ async function fileExists(targetPath) {
 }
 async function copyTemplate(templatePath, workspaceRoot) {
   if (!templatePath) return;
-  const markerPath = join3(workspaceRoot, PROVISION_MARKER_REL_PATH);
+  const markerPath = join4(workspaceRoot, PROVISION_MARKER_REL_PATH);
   if (await fileExists(markerPath)) return;
   try {
     await cp2(templatePath, workspaceRoot, {
@@ -2040,7 +2066,7 @@ async function copyTemplate(templatePath, workspaceRoot) {
       { cause: error }
     );
   }
-  await mkdir5(dirname4(markerPath), { recursive: true });
+  await mkdir5(dirname5(markerPath), { recursive: true });
   await writeFile5(markerPath, (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
 }
 
@@ -2792,7 +2818,7 @@ import {
   utimes
 } from "fs/promises";
 import { readFileSync, readdirSync } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { homedir as homedir3 } from "os";
 import {
   parseSessionEntries,
@@ -2801,7 +2827,7 @@ import {
 } from "@mariozechner/pi-coding-agent";
 function defaultSessionDir(cwd) {
   const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-  return join4(homedir3(), ".pi", "agent", "sessions", safePath);
+  return join5(homedir3(), ".pi", "agent", "sessions", safePath);
 }
 var SAFE_ID = /^[a-zA-Z0-9_-]+$/;
 var PiSessionStore = class {
@@ -2815,7 +2841,7 @@ var PiSessionStore = class {
     const files = await readdir4(this.sessionDir).catch(() => []);
     const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
     const summaries = await Promise.all(
-      jsonlFiles.map((f) => this.summarizeFile(join4(this.sessionDir, f)))
+      jsonlFiles.map((f) => this.summarizeFile(join5(this.sessionDir, f)))
     );
     return summaries.filter((s) => s !== null).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
   }
@@ -2841,7 +2867,7 @@ var PiSessionStore = class {
       };
       lines.push(JSON.stringify(infoEntry));
     }
-    const filepath = join4(this.sessionDir, `${id}.jsonl`);
+    const filepath = join5(this.sessionDir, `${id}.jsonl`);
     await writeFile6(filepath, lines.join("\n") + "\n", "utf-8");
     return {
       id,
@@ -2898,7 +2924,7 @@ var PiSessionStore = class {
   loadPiSessionFileSync(sessionId) {
     if (!SAFE_ID.test(sessionId)) return null;
     try {
-      const direct = join4(this.sessionDir, `${sessionId}.jsonl`);
+      const direct = join5(this.sessionDir, `${sessionId}.jsonl`);
       let content;
       try {
         content = readFileSync(direct, "utf-8");
@@ -2907,7 +2933,7 @@ var PiSessionStore = class {
           (f) => f.endsWith(`_${sessionId}.jsonl`) || f === `${sessionId}.jsonl`
         );
         if (files.length === 0) return null;
-        content = readFileSync(join4(this.sessionDir, files[0]), "utf-8");
+        content = readFileSync(join5(this.sessionDir, files[0]), "utf-8");
       }
       const entries = safeParseEntries(content);
       let piFilePath = null;
@@ -2975,7 +3001,7 @@ var PiSessionStore = class {
     if (!SAFE_ID.test(sessionId)) {
       throw new Error(`Session not found: ${sessionId}`);
     }
-    const direct = join4(this.sessionDir, `${sessionId}.jsonl`);
+    const direct = join5(this.sessionDir, `${sessionId}.jsonl`);
     try {
       await fsStat(direct);
       return direct;
@@ -2986,7 +3012,7 @@ var PiSessionStore = class {
       (f) => f.endsWith(`_${sessionId}.jsonl`) || f === `${sessionId}.jsonl`
     );
     if (!match) throw new Error(`Session not found: ${sessionId}`);
-    return join4(this.sessionDir, match);
+    return join5(this.sessionDir, match);
   }
   async summarizeFile(filepath) {
     try {
@@ -3913,11 +3939,11 @@ function createPiCodingAgentHarness(opts) {
 
 // src/server/harness/pi-coding-agent/pluginLoader.ts
 import { readdir as readdir5, stat as stat5, readFile as readFile7 } from "fs/promises";
-import { join as join5, extname, resolve as resolve4, sep as sep3 } from "path";
+import { join as join6, extname, resolve as resolve4, sep as sep3 } from "path";
 import { homedir as homedir4 } from "os";
 import { pathToFileURL } from "url";
 var VALID_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs"]);
-var GLOBAL_DIR = join5(homedir4(), ".pi", "agent", "extensions");
+var GLOBAL_DIR = join6(homedir4(), ".pi", "agent", "extensions");
 var LOCAL_DIR = ".pi/extensions";
 var EXTENSIONS_JSON = ".pi/extensions.json";
 async function dirExists(path4) {
@@ -3939,7 +3965,7 @@ async function fileExists2(path4) {
 async function discoverFromDir(dir, source) {
   if (!await dirExists(dir)) return [];
   const entries = await readdir5(dir);
-  return entries.filter((e) => VALID_EXTENSIONS.has(extname(e))).map((e) => ({ path: join5(dir, e), source }));
+  return entries.filter((e) => VALID_EXTENSIONS.has(extname(e))).map((e) => ({ path: join6(dir, e), source }));
 }
 function extractTools(mod) {
   const tools = [];
@@ -3969,17 +3995,17 @@ async function loadModule(filePath, importFn) {
   return extractTools(mod);
 }
 async function discoverNpmPlugins(cwd) {
-  const nodeModulesDir = join5(cwd, "node_modules");
+  const nodeModulesDir = join6(cwd, "node_modules");
   if (!await dirExists(nodeModulesDir)) return [];
   try {
     const entries = await readdir5(nodeModulesDir);
-    return entries.filter((e) => e.startsWith("pi-plugin-")).map((e) => join5(nodeModulesDir, e));
+    return entries.filter((e) => e.startsWith("pi-plugin-")).map((e) => join6(nodeModulesDir, e));
   } catch {
     return [];
   }
 }
 async function loadNpmPlugin(pkgDir, importFn) {
-  const pkgJsonPath = join5(pkgDir, "package.json");
+  const pkgJsonPath = join6(pkgDir, "package.json");
   if (!await fileExists2(pkgJsonPath)) return [];
   const pkgJson = JSON.parse(await readFile7(pkgJsonPath, "utf-8"));
   const main = pkgJson.main ?? "index.js";
@@ -3991,7 +4017,7 @@ async function loadNpmPlugin(pkgDir, importFn) {
   return loadModule(resolvedMain, importFn);
 }
 async function loadExtensionsJson(cwd) {
-  const configPath = join5(cwd, EXTENSIONS_JSON);
+  const configPath = join6(cwd, EXTENSIONS_JSON);
   if (!await fileExists2(configPath)) return null;
   try {
     const raw = await readFile7(configPath, "utf-8");
@@ -4009,7 +4035,7 @@ async function loadPlugins(options) {
     const globals = await discoverFromDir(GLOBAL_DIR, "global");
     candidates.push(...globals);
   }
-  const localDir = join5(options.cwd, LOCAL_DIR);
+  const localDir = join6(options.cwd, LOCAL_DIR);
   const locals = await discoverFromDir(localDir, "local");
   candidates.push(...locals);
   const npmDirs = await discoverNpmPlugins(options.cwd);
@@ -4019,7 +4045,7 @@ async function loadPlugins(options) {
   const config = await loadExtensionsJson(options.cwd);
   if (config?.npm) {
     for (const pkg of config.npm) {
-      const pkgDir = join5(options.cwd, "node_modules", pkg);
+      const pkgDir = join6(options.cwd, "node_modules", pkg);
       if (await dirExists(pkgDir)) {
         const already = candidates.some((c) => c.path === pkgDir);
         if (!already) {
@@ -4067,9 +4093,9 @@ import {
 } from "@mariozechner/pi-coding-agent";
 
 // src/server/tools/operations/bound.ts
-import { constants as constants2 } from "fs";
-import { access as access2, lstat as lstat3, mkdir as mkdir9, readFile as readFile8, readdir as readdir6, readlink, realpath as realpath2, stat as stat6, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve5 } from "path";
+import { constants as constants3 } from "fs";
+import { access as access3, lstat as lstat3, mkdir as mkdir9, readFile as readFile8, readdir as readdir6, readlink, realpath as realpath2, stat as stat6, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname6, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve5 } from "path";
 function toPosixPath(value) {
   return value.split("\\").join("/");
 }
@@ -4143,7 +4169,7 @@ async function findNearestExistingAncestor(absPath) {
       await stat6(current);
       return current;
     } catch {
-      const parent = dirname5(current);
+      const parent = dirname6(current);
       if (parent === current) return current;
       current = parent;
     }
@@ -4155,7 +4181,7 @@ async function assertWithinWorkspace(workspaceRoot, absPath) {
     const s = await lstat3(absPath);
     if (s.isSymbolicLink()) {
       const target = await readlink(absPath);
-      const resolvedTarget = resolve5(dirname5(absPath), target);
+      const resolvedTarget = resolve5(dirname6(absPath), target);
       const nearestAncestor = await findNearestExistingAncestor(resolvedTarget);
       const realAncestor = await realpath2(nearestAncestor);
       const rel2 = relative4(realRoot, realAncestor);
@@ -4177,7 +4203,7 @@ async function assertWithinWorkspace(workspaceRoot, absPath) {
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") {
-      const nearestAncestor = await findNearestExistingAncestor(dirname5(absPath));
+      const nearestAncestor = await findNearestExistingAncestor(dirname6(absPath));
       const realAncestor = await realpath2(nearestAncestor);
       const rel2 = relative4(realRoot, realAncestor);
       if (rel2.startsWith("..") || isAbsolute4(rel2)) {
@@ -4200,13 +4226,13 @@ function boundFs(workspaceRoot) {
     },
     async access(absolutePath) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
-      await access2(absolutePath, constants2.R_OK);
+      await access3(absolutePath, constants3.R_OK);
     }
   };
   const write = {
     async writeFile(absolutePath, content) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
-      await mkdir9(dirname5(absolutePath), { recursive: true });
+      await mkdir9(dirname6(absolutePath), { recursive: true });
       await writeFile7(absolutePath, content);
     },
     async mkdir(dir) {
@@ -4225,7 +4251,7 @@ function boundFs(workspaceRoot) {
     },
     async access(absolutePath) {
       await assertWithinWorkspace(workspaceRoot, absolutePath);
-      await access2(absolutePath, constants2.R_OK | constants2.W_OK);
+      await access3(absolutePath, constants3.R_OK | constants3.W_OK);
     }
   };
   const find = {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@hachej/boring-agent",
-  "version": "0.1.0",
+  "version": "0.1.5",
   "type": "module",
   "license": "MIT",
   "description": "Pane-embeddable coding agent. Ships direct/local/vercel-sandbox execution modes behind one interface.",
   "repository": {
     "type": "git",
-    "url": "https://github.com/hachej/boring-ui.git"
+    "url": "https://github.com/hachej/boring-ui"
   },
   "homepage": "https://github.com/hachej/boring-ui",
   "exports": {
@@ -74,7 +74,7 @@
     "use-stick-to-bottom": "^1.1.3",
     "yaml": "^2.8.3",
     "zod": "^3.25.76",
-    "@hachej/boring-ui-kit": "0.1.0"
+    "@hachej/boring-ui-kit": "0.1.5"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",