@easynet/agent-tool 1.0.23 → 1.0.25

package/dist/index.cjs

@@ -1,14 +1,23 @@
 'use strict';
 
-var chunkFWIMPZC2_cjs = require('./chunk-FWIMPZC2.cjs');
-var chunkAT3N7SQK_cjs = require('./chunk-AT3N7SQK.cjs');
-var chunkAH4NI4GN_cjs = require('./chunk-AH4NI4GN.cjs');
+var chunkNA2YBWZJ_cjs = require('./chunk-NA2YBWZJ.cjs');
+var chunk5CDN24FP_cjs = require('./chunk-5CDN24FP.cjs');
+var chunkAOEZBP6L_cjs = require('./chunk-AOEZBP6L.cjs');
 var chunkTOSPHMYU_cjs = require('./chunk-TOSPHMYU.cjs');
 require('./chunk-4KTWJQ32.cjs');
 var chunkDYDNPIV2_cjs = require('./chunk-DYDNPIV2.cjs');
 var promises = require('dns/promises');
-var path = require('path');
+var path6 = require('path');
 var promises$1 = require('fs/promises');
+var async_hooks = require('async_hooks');
+var url = require('url');
+var fs = require('fs');
+var yaml = require('js-yaml');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path6__default = /*#__PURE__*/_interopDefault(path6);
+var yaml__default = /*#__PURE__*/_interopDefault(yaml);
 
 async function validateUrl(url, options) {
   let parsed;
@@ -187,25 +196,25 @@ function expandIpv6(ip) {
 async function resolveSandboxedPath(inputPath, sandboxRoot) {
   let normalizedRoot;
   try {
-    normalizedRoot = await promises$1.realpath(path.resolve(sandboxRoot));
+    normalizedRoot = await promises$1.realpath(path6.resolve(sandboxRoot));
   } catch {
-    normalizedRoot = path.normalize(path.resolve(sandboxRoot));
+    normalizedRoot = path6.normalize(path6.resolve(sandboxRoot));
   }
-  const resolved = path.resolve(normalizedRoot, inputPath);
+  const resolved = path6.resolve(normalizedRoot, inputPath);
   let real;
   try {
     await promises$1.access(resolved);
     real = await promises$1.realpath(resolved);
   } catch {
-    const parentDir = path.dirname(resolved);
+    const parentDir = path6.dirname(resolved);
     let realParent;
     try {
       await promises$1.access(parentDir);
       realParent = await promises$1.realpath(parentDir);
     } catch {
-      realParent = path.normalize(parentDir);
+      realParent = path6.normalize(parentDir);
     }
-    real = path.resolve(realParent, path.basename(resolved));
+    real = path6.resolve(realParent, path6.basename(resolved));
   }
   if (!isWithinRoot(real, normalizedRoot)) {
     throw chunkTOSPHMYU_cjs.createTaggedError(
@@ -216,11 +225,264 @@ async function resolveSandboxedPath(inputPath, sandboxRoot) {
   }
   return real;
 }
-function isWithinRoot(path$1, root) {
-  const normalizedPath = path.normalize(path$1);
-  const normalizedRoot = path.normalize(root);
+function isWithinRoot(path7, root) {
+  const normalizedPath = path6.normalize(path7);
+  const normalizedRoot = path6.normalize(root);
   return normalizedPath === normalizedRoot || normalizedPath.startsWith(normalizedRoot + "/");
 }
+function createContextRunner() {
+  const storage = new async_hooks.AsyncLocalStorage();
+  return {
+    runWith(ctx, fn) {
+      return storage.run(ctx, fn);
+    },
+    getContext() {
+      const ctx = storage.getStore();
+      if (ctx === void 0) {
+        throw new Error("Extension context not set; invoke only through the extension adapter.");
+      }
+      return ctx;
+    }
+  };
+}
+function createDynamicImportAdapter(options) {
+  const { kind, packageRoot, getExtensionContext, contextRunner } = options;
+  return {
+    kind,
+    async invoke(spec, args, execCtx) {
+      const meta = spec._meta;
+      const sourcePath = meta?.sourcePath;
+      const exportName = meta?.exportName;
+      if (!sourcePath || !exportName) {
+        throw new Error(`Extension tool ${spec.name} missing _meta.sourcePath or _meta.exportName`);
+      }
+      const defaultArgs = meta?.defaultArgs ?? {};
+      const mergedArgs = Object.keys(defaultArgs).length === 0 ? args : { ...defaultArgs, ...args };
+      const modulePath = path6__default.default.join(packageRoot, `${sourcePath}.js`);
+      const mod = await import(url.pathToFileURL(modulePath).href);
+      const handler = mod[exportName];
+      if (typeof handler !== "function") {
+        throw new Error(
+          `Extension tool ${spec.name}: export "${exportName}" from ${sourcePath} is not a function`
+        );
+      }
+      const ctx = getExtensionContext(execCtx, spec);
+      const output = await contextRunner.runWith(ctx, () => handler(mergedArgs));
+      return { result: output.result, raw: { evidence: output.evidence } };
+    }
+  };
+}
+function loadToolYaml(packageRoot, sourcePath) {
+  const dir = path6__default.default.dirname(sourcePath);
+  const base = path6__default.default.basename(sourcePath);
+  const yamlPath = path6__default.default.join(packageRoot, dir, `${base}.tool.yaml`);
+  if (!fs.existsSync(yamlPath)) return void 0;
+  try {
+    const raw = fs.readFileSync(yamlPath, "utf-8");
+    const data = yaml__default.default.load(raw);
+    if (data == null || typeof data !== "object" || Array.isArray(data)) return void 0;
+    const obj = data;
+    const list = obj?.tool;
+    const arr = list?.list;
+    if (!Array.isArray(arr)) return void 0;
+    const item = arr.find(
+      (e) => e != null && typeof e === "object" && e.name === base
+    );
+    if (!item || typeof item !== "object") return void 0;
+    const { name: _n, ...rest } = item;
+    if (Object.keys(rest).length === 0) return void 0;
+    return rest;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/api/extension/registerFromManifest.ts
+function loadExtensionManifest(manifestPathOrDir) {
+  const p = path6__default.default.resolve(manifestPathOrDir);
+  let manifestPath;
+  if (fs.existsSync(p) && fs.statSync(p).isFile()) {
+    manifestPath = p;
+  } else {
+    const inDir = path6__default.default.join(p, "core-tools-manifest.json");
+    const inDist = path6__default.default.join(p, "dist", "core-tools-manifest.json");
+    manifestPath = fs.existsSync(inDir) ? inDir : inDist;
+  }
+  const raw = fs.readFileSync(manifestPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (Array.isArray(parsed)) {
+    return { entries: parsed };
+  }
+  return { kind: parsed.kind, entries: parsed.tools ?? [] };
+}
+function registerToolsFromManifest(registry, options) {
+  const { manifestPathOrDir, kind: kindOpt, only, namePrefixes, packageRoot } = options;
+  const loaded = loadExtensionManifest(manifestPathOrDir);
+  const kind = kindOpt ?? loaded.kind ?? "extension";
+  const entries = loaded.entries;
+  const onlySet = only?.length ? new Set(only) : null;
+  const registered = [];
+  for (const entry of entries) {
+    let spec = chunkDYDNPIV2_cjs.createToolSpec({
+      name: entry.coreName,
+      kind,
+      description: entry.description,
+      inputSchema: entry.inputSchema,
+      outputSchema: entry.outputSchema,
+      capabilities: [],
+      sideEffect: entry.sideEffect
+    });
+    if (onlySet && !onlySet.has(spec.name)) continue;
+    if (namePrefixes?.length && !namePrefixes.some((prefix) => spec.name.startsWith(prefix))) {
+      continue;
+    }
+    const defaultArgs = packageRoot != null ? loadToolYaml(packageRoot, entry.sourcePath) : void 0;
+    spec = {
+      ...spec,
+      _meta: {
+        ...spec._meta,
+        sourcePath: entry.sourcePath,
+        exportName: entry.exportName,
+        ...defaultArgs != null && Object.keys(defaultArgs).length > 0 && { defaultArgs }
+      }
+    };
+    registry.register(spec);
+    registered.push(spec);
+  }
+  return registered;
+}
+function resolveExtensionPackageRoot(metaUrlOrPath) {
+  const dir = metaUrlOrPath.startsWith("file:") ? path6__default.default.dirname(url.fileURLToPath(metaUrlOrPath)) : path6__default.default.resolve(metaUrlOrPath);
+  const dist = path6__default.default.join(dir, "dist");
+  return fs.existsSync(dist) ? dist : dir;
+}
+
+// src/api/extension/registerExtension.ts
+function registerExtension(registry, options) {
+  const { packagePath, kind: kindOpt, config, getContextRunner, only, namePrefixes } = options;
+  const packageRoot = resolveExtensionPackageRoot(packagePath);
+  const contextRunner = getContextRunner();
+  const loaded = loadExtensionManifest(packagePath);
+  const kind = kindOpt ?? loaded.kind ?? "extension";
+  registerToolsFromManifest(registry, {
+    manifestPathOrDir: packagePath,
+    kind,
+    only,
+    namePrefixes,
+    packageRoot
+  });
+  const adapter = createDynamicImportAdapter({
+    kind,
+    packageRoot,
+    getExtensionContext: (execCtx, spec) => ({
+      execCtx,
+      config: config !== void 0 ? { ...config, ...spec._meta?.defaultArgs ?? {} } : spec._meta?.defaultArgs ?? {}
+    }),
+    contextRunner: {
+      runWith(ctx, fn) {
+        return contextRunner.runWith(ctx, fn);
+      }
+    }
+  });
+  return adapter;
+}
+
+// src/api/extension/createExtension.ts
+function resolvePackagePath(options) {
+  if (options.packagePath != null && options.packagePath !== "") return options.packagePath;
+  if (options.importMeta?.url) return path6__default.default.dirname(url.fileURLToPath(options.importMeta.url));
+  throw new Error("createExtension: provide packagePath or importMeta");
+}
+function createExtension(options) {
+  const packagePath = resolvePackagePath(options);
+  const kind = options.kind;
+  const buildConfig = "buildConfig" in options ? options.buildConfig : void 0;
+  const contextRunner = createContextRunner();
+  return {
+    register(registry, userConfigOrOpts, opts) {
+      const config = buildConfig ? buildConfig(userConfigOrOpts) : void 0;
+      return registerExtension(registry, {
+        packagePath,
+        kind,
+        config,
+        getContextRunner: () => contextRunner,
+        only: opts?.only ?? userConfigOrOpts?.only,
+        namePrefixes: opts?.namePrefixes ?? userConfigOrOpts?.namePrefixes
+      });
+    },
+    getContext() {
+      return contextRunner.getContext();
+    },
+    runWith(ctx, fn) {
+      return contextRunner.runWith(ctx, fn);
+    }
+  };
+}
+function generateExtensionManifest(projectRoot = process.cwd(), options = {}) {
+  const root = path6__default.default.resolve(projectRoot);
+  const outDir = path6__default.default.resolve(options.outDir ?? path6__default.default.join(root, "dist"));
+  const kind = options.kind ?? "core";
+  const { specs, errors } = chunk5CDN24FP_cjs.scanForTools({
+    projectPath: root,
+    include: options.include ?? ["**/*.ts"],
+    tsconfigPath: options.tsconfigPath
+  });
+  if (errors.length > 0) {
+    console.warn("generateExtensionManifest: scan errors", errors);
+  }
+  const entries = specs.map((spec) => {
+    const sourcePathNoExt = (spec.sourcePath ?? "").replace(/\.(ts|tsx)$/i, "");
+    const coreName = `${kind}/${sourcePathNoExt.replace(/\//g, ".")}`;
+    const sideEffect = spec._meta?.hitl?.sideEffect ?? "none";
+    return {
+      coreName,
+      description: spec.description ?? sourcePathNoExt,
+      inputSchema: spec.inputSchema ?? { type: "object", additionalProperties: true },
+      outputSchema: spec.outputSchema ?? { type: "object", additionalProperties: true },
+      sourcePath: sourcePathNoExt,
+      exportName: spec.exportName ?? "",
+      sideEffect
+    };
+  });
+  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+  const manifestPath = path6__default.default.join(outDir, "core-tools-manifest.json");
+  fs.writeFileSync(
+    manifestPath,
+    JSON.stringify({ kind, tools: entries }, null, 2),
+    "utf-8"
+  );
+  let toolYamlCopied = 0;
+  const copyDirs = options.copyToolYamlDirs;
+  if (copyDirs?.length) {
+    for (const d of copyDirs) {
+      const srcDir = path6__default.default.join(root, d);
+      const destDir = path6__default.default.join(outDir, d);
+      if (!fs.existsSync(srcDir)) continue;
+      try {
+        for (const e of fs.readdirSync(srcDir, { withFileTypes: true })) {
+          if (e.isFile() && e.name.endsWith(".tool.yaml")) {
+            if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+            fs.copyFileSync(path6__default.default.join(srcDir, e.name), path6__default.default.join(destDir, e.name));
+            toolYamlCopied++;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return { manifestPath, toolsCount: entries.length, toolYamlCopied };
+}
+
+// src/api/extension/groupPrefix.ts
+function getGroupNamePrefixes(options) {
+  const { groups, only, groupPrefixMap } = options;
+  const onlySet = only?.length ? new Set(only) : null;
+  const namePrefixes = !onlySet && groups?.length ? groups.map((g) => groupPrefixMap[g]).filter(Boolean) : void 0;
+  return {
+    ...onlySet ? { only: Array.from(onlySet) } : {},
+    ...namePrefixes?.length ? { namePrefixes } : {}
+  };
+}
 
 // src/tools/mcp/MCPClientAdapter.ts
 function textFromCallToolResult(result) {
@@ -235,7 +497,7 @@ var MCPClientAdapter = class {
   constructor(client) {
     this.client = client;
   }
-  kind = chunkAH4NI4GN_cjs.MCP_KIND;
+  kind = chunkAOEZBP6L_cjs.MCP_KIND;
   async invoke(spec, args, _ctx) {
     const params = args != null && typeof args === "object" && !Array.isArray(args) ? args : {};
     const result = await this.client.callTool({ name: spec.name, arguments: params });
@@ -276,7 +538,7 @@ function mcpToolsToSpecs(tools) {
   return tools.map((t) => ({
     name: t.name,
     version: "1.0.0",
-    kind: chunkAH4NI4GN_cjs.MCP_KIND,
+    kind: chunkAOEZBP6L_cjs.MCP_KIND,
     description: t.description ?? `MCP tool: ${t.name}`,
     inputSchema: t.inputSchema ?? chunkDYDNPIV2_cjs.DEFAULT_INPUT_SCHEMA,
     outputSchema: chunkDYDNPIV2_cjs.DEFAULT_OUTPUT_SCHEMA,
@@ -313,11 +575,11 @@ var MCPProcessManager = class {
 
 // src/tools/mcp/registerMCPTools.ts
 async function registerMCPToolsFromConfig(runtime, registry, options = {}) {
-  const configPath = options.configPath ?? process.env.MCP_CONFIG_PATH ?? path.join(process.cwd(), "mcp.json");
-  const dirPath = path.dirname(configPath);
-  const entryPoint = path.basename(configPath);
-  const toolName = options.toolName ?? chunkAH4NI4GN_cjs.MCP_KIND;
-  const loaded = await chunkAT3N7SQK_cjs.loadMCPTool(dirPath, { kind: chunkAH4NI4GN_cjs.MCP_KIND, name: toolName, entryPoint });
+  const configPath = options.configPath ?? process.env.MCP_CONFIG_PATH ?? path6.join(process.cwd(), "mcp.json");
+  const dirPath = path6.dirname(configPath);
+  const entryPoint = path6.basename(configPath);
+  const toolName = options.toolName ?? chunkAOEZBP6L_cjs.MCP_KIND;
+  const loaded = await chunk5CDN24FP_cjs.loadMCPTool(dirPath, { kind: chunkAOEZBP6L_cjs.MCP_KIND, name: toolName, entryPoint });
   if (!loaded.mcpConfig) {
     throw new Error("mcp.json must have command or url");
   }
@@ -333,167 +595,167 @@ async function registerMCPToolsFromConfig(runtime, registry, options = {}) {
 
 Object.defineProperty(exports, "LangChainToolsHub", {
   enumerable: true,
-  get: function () { return chunkFWIMPZC2_cjs.LangChainToolsHub; }
+  get: function () { return chunkNA2YBWZJ_cjs.LangChainToolsHub; }
 });
 Object.defineProperty(exports, "createAgentTools", {
   enumerable: true,
-  get: function () { return chunkFWIMPZC2_cjs.createAgentTools; }
+  get: function () { return chunkNA2YBWZJ_cjs.createAgentTools; }
 });
 Object.defineProperty(exports, "DirectoryScanner", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.DirectoryScanner; }
+  get: function () { return chunk5CDN24FP_cjs.DirectoryScanner; }
 });
 Object.defineProperty(exports, "DiscoveryError", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.DiscoveryError; }
+  get: function () { return chunk5CDN24FP_cjs.DiscoveryError; }
 });
 Object.defineProperty(exports, "SkillManifestError", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.SkillManifestError; }
+  get: function () { return chunk5CDN24FP_cjs.SkillManifestError; }
 });
 Object.defineProperty(exports, "buildFunctionToTool", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.buildFunctionToTool; }
+  get: function () { return chunk5CDN24FP_cjs.buildFunctionToTool; }
 });
 Object.defineProperty(exports, "buildMcpPackage", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.buildMcpPackage; }
+  get: function () { return chunk5CDN24FP_cjs.buildMcpPackage; }
 });
 Object.defineProperty(exports, "initProject", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.initProject; }
+  get: function () { return chunk5CDN24FP_cjs.initProject; }
 });
 Object.defineProperty(exports, "loadMCPTool", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.loadMCPTool; }
+  get: function () { return chunk5CDN24FP_cjs.loadMCPTool; }
 });
 Object.defineProperty(exports, "loadSkillDefinition", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.loadSkillDefinition; }
+  get: function () { return chunk5CDN24FP_cjs.loadSkillDefinition; }
 });
 Object.defineProperty(exports, "parseSkillMd", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.parseSkillMd; }
+  get: function () { return chunk5CDN24FP_cjs.parseSkillMd; }
 });
 Object.defineProperty(exports, "runGeneratedMCP", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.runGeneratedMCP; }
+  get: function () { return chunk5CDN24FP_cjs.runGeneratedMCP; }
 });
 Object.defineProperty(exports, "runMcpServer", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.runMcpServer; }
+  get: function () { return chunk5CDN24FP_cjs.runMcpServer; }
 });
 Object.defineProperty(exports, "scan", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.scan; }
+  get: function () { return chunk5CDN24FP_cjs.scan; }
 });
 Object.defineProperty(exports, "scanForTools", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.scanForTools; }
+  get: function () { return chunk5CDN24FP_cjs.scanForTools; }
 });
 Object.defineProperty(exports, "scanSkillResources", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.scanSkillResources; }
+  get: function () { return chunk5CDN24FP_cjs.scanSkillResources; }
 });
 Object.defineProperty(exports, "validateFrontmatter", {
   enumerable: true,
-  get: function () { return chunkAT3N7SQK_cjs.validateFrontmatter; }
+  get: function () { return chunk5CDN24FP_cjs.validateFrontmatter; }
 });
 Object.defineProperty(exports, "BudgetManager", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.BudgetManager; }
+  get: function () { return chunkAOEZBP6L_cjs.BudgetManager; }
 });
 Object.defineProperty(exports, "EventLog", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.EventLog; }
+  get: function () { return chunkAOEZBP6L_cjs.EventLog; }
 });
 Object.defineProperty(exports, "Metrics", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.Metrics; }
+  get: function () { return chunkAOEZBP6L_cjs.Metrics; }
 });
 Object.defineProperty(exports, "PTCRuntime", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.PTCRuntime; }
+  get: function () { return chunkAOEZBP6L_cjs.PTCRuntime; }
 });
 Object.defineProperty(exports, "PolicyDeniedError", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.PolicyDeniedError; }
+  get: function () { return chunkAOEZBP6L_cjs.PolicyDeniedError; }
 });
 Object.defineProperty(exports, "PolicyEngine", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.PolicyEngine; }
+  get: function () { return chunkAOEZBP6L_cjs.PolicyEngine; }
 });
 Object.defineProperty(exports, "SchemaValidationError", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.SchemaValidationError; }
+  get: function () { return chunkAOEZBP6L_cjs.SchemaValidationError; }
 });
 Object.defineProperty(exports, "SchemaValidator", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.SchemaValidator; }
+  get: function () { return chunkAOEZBP6L_cjs.SchemaValidator; }
 });
 Object.defineProperty(exports, "Tracing", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.Tracing; }
+  get: function () { return chunkAOEZBP6L_cjs.Tracing; }
 });
 Object.defineProperty(exports, "buildEvidence", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.buildEvidence; }
+  get: function () { return chunkAOEZBP6L_cjs.buildEvidence; }
 });
 Object.defineProperty(exports, "createLogger", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.createLogger; }
+  get: function () { return chunkAOEZBP6L_cjs.createLogger; }
 });
 Object.defineProperty(exports, "ensurePackageInCache", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.ensurePackageInCache; }
+  get: function () { return chunkAOEZBP6L_cjs.ensurePackageInCache; }
 });
 Object.defineProperty(exports, "expandToolDescriptorsToRegistryNames", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.expandToolDescriptorsToRegistryNames; }
+  get: function () { return chunkAOEZBP6L_cjs.expandToolDescriptorsToRegistryNames; }
 });
 Object.defineProperty(exports, "getPackageEntryPath", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.getPackageEntryPath; }
+  get: function () { return chunkAOEZBP6L_cjs.getPackageEntryPath; }
 });
 Object.defineProperty(exports, "importFromCache", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.importFromCache; }
+  get: function () { return chunkAOEZBP6L_cjs.importFromCache; }
 });
 Object.defineProperty(exports, "isNpmToolDescriptor", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.isNpmToolDescriptor; }
+  get: function () { return chunkAOEZBP6L_cjs.isNpmToolDescriptor; }
 });
 Object.defineProperty(exports, "loadToolConfig", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.loadToolConfig; }
+  get: function () { return chunkAOEZBP6L_cjs.loadToolConfig; }
 });
 Object.defineProperty(exports, "normalizeToolList", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.normalizeToolList; }
+  get: function () { return chunkAOEZBP6L_cjs.normalizeToolList; }
 });
 Object.defineProperty(exports, "npmDescriptorToRegistryPrefix", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.npmDescriptorToRegistryPrefix; }
+  get: function () { return chunkAOEZBP6L_cjs.npmDescriptorToRegistryPrefix; }
 });
 Object.defineProperty(exports, "parseNpmToolDescriptor", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.parseNpmToolDescriptor; }
+  get: function () { return chunkAOEZBP6L_cjs.parseNpmToolDescriptor; }
 });
 Object.defineProperty(exports, "resolveNpmToolDescriptor", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.resolveNpmToolDescriptor; }
+  get: function () { return chunkAOEZBP6L_cjs.resolveNpmToolDescriptor; }
 });
 Object.defineProperty(exports, "resolveToolDescriptor", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.resolveToolDescriptor; }
+  get: function () { return chunkAOEZBP6L_cjs.resolveToolDescriptor; }
 });
 Object.defineProperty(exports, "sanitizeForLog", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.sanitizeForLog; }
+  get: function () { return chunkAOEZBP6L_cjs.sanitizeForLog; }
 });
 Object.defineProperty(exports, "summarizeForLog", {
   enumerable: true,
-  get: function () { return chunkAH4NI4GN_cjs.summarizeForLog; }
+  get: function () { return chunkAOEZBP6L_cjs.summarizeForLog; }
 });
 Object.defineProperty(exports, "ToolRegistry", {
   enumerable: true,
@@ -530,9 +792,19 @@ Object.defineProperty(exports, "normalizeToolName", {
 exports.MCPClientAdapter = MCPClientAdapter;
 exports.MCPProcessManager = MCPProcessManager;
 exports.connectMCP = connectMCP;
+exports.createContextRunner = createContextRunner;
+exports.createDynamicImportAdapter = createDynamicImportAdapter;
+exports.createExtension = createExtension;
+exports.generateExtensionManifest = generateExtensionManifest;
+exports.getGroupNamePrefixes = getGroupNamePrefixes;
 exports.isIpInBlockedCidrs = isIpInBlockedCidrs;
+exports.loadExtensionManifest = loadExtensionManifest;
+exports.loadToolYaml = loadToolYaml;
 exports.mcpToolsToSpecs = mcpToolsToSpecs;
+exports.registerExtension = registerExtension;
 exports.registerMCPToolsFromConfig = registerMCPToolsFromConfig;
+exports.registerToolsFromManifest = registerToolsFromManifest;
+exports.resolveExtensionPackageRoot = resolveExtensionPackageRoot;
 exports.resolveSandboxedPath = resolveSandboxedPath;
 exports.validateUrl = validateUrl;
 //# sourceMappingURL=index.cjs.map