@easynet/agent-tool 1.0.24 → 1.0.26

package/dist/{chunk-BPHY6UVK.js → chunk-UUQGKFSG.js}

@@ -1728,11 +1728,7 @@ function getProjectRequire() {
   if (existsSync(join(cwd, "tool.yaml"))) return createRequire(join(cwd, "tool.yaml"));
   return null;
 }
-var DEFAULT_EXTENSION_PACKAGES = [
-  "@easynet/agent-tool-builtin-tools",
-  "@easynet/agent-tool-builtin",
-  "@easynet/agent-tool-buildin"
-];
+var DEFAULT_EXTENSION_PACKAGES = [];
 function getInstalledPackageVersion(packageName) {
   const projectRequire = getProjectRequire();
   const requirers = [requireFromPackage];
@@ -1749,6 +1745,9 @@ function getInstalledPackageVersion(packageName) {
   }
   return null;
 }
+function getRegisterFn(mod) {
+  return mod?.register ?? mod?.registerCoreTools;
+}
 function loadExtensionFromNodeModules() {
   const projectRequire = getProjectRequire();
   const requirers = [requireFromPackage];
@@ -1757,7 +1756,8 @@ function loadExtensionFromNodeModules() {
     for (const pkg of DEFAULT_EXTENSION_PACKAGES) {
       try {
         const mod = req(pkg);
-        if (mod && typeof mod.registerCoreTools === "function") return { registerCoreTools: mod.registerCoreTools, packageName: pkg };
+        const fn = getRegisterFn(mod);
+        if (typeof fn === "function") return { register: fn, packageName: pkg };
       } catch {
         continue;
       }
@@ -1808,6 +1808,44 @@ function parseNpmDescriptor(entry) {
   const version = rest.slice(at + 1).split("#")[0]?.trim() || "latest";
   return { packageName, version };
 }
+function loadExtensionFromToolYamlNodeModules(configFilePath, stepLog) {
+  const localPath = isAbsolute(configFilePath) ? configFilePath : resolve(process.cwd(), configFilePath);
+  if (!existsSync(localPath)) return null;
+  const config = loadToolConfig(localPath);
+  const tools = config.tools;
+  if (!Array.isArray(tools) || tools.length === 0) return null;
+  const configDir = dirname(localPath);
+  const packageJsonPath = join(configDir, "package.json");
+  if (!existsSync(packageJsonPath)) return null;
+  const configRequire = createRequire(packageJsonPath);
+  if (stepLog) stepLog("Trying tool.yaml npm entries from node_modules");
+  for (const entry of tools) {
+    const entryStr = String(entry).trim();
+    const parsed = parseNpmDescriptor(entryStr);
+    if (!parsed) continue;
+    try {
+      const mod = configRequire(parsed.packageName);
+      const fn = getRegisterFn(mod);
+      if (typeof fn === "function") {
+        const resolvedVersion = getInstalledPackageVersionFromRequire(parsed.packageName, configRequire) ?? "latest";
+        return { register: fn, descriptor: entryStr, resolvedVersion };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function getInstalledPackageVersionFromRequire(packageName, req) {
+  try {
+    const pkgJsonPath = req.resolve(`${packageName}/package.json`);
+    const json = readFileSync(pkgJsonPath, "utf-8");
+    const pkg = JSON.parse(json);
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
 function loadExtensionFromToolYamlCache(configFilePath, stepLog) {
   const localPath = isAbsolute(configFilePath) ? configFilePath : resolve(process.cwd(), configFilePath);
   if (!existsSync(localPath)) return null;
@@ -1829,9 +1867,10 @@ function loadExtensionFromToolYamlCache(configFilePath, stepLog) {
         const entryPath = getPackageEntryPath(cacheDir);
         const req = createRequire(join(cacheDir, "package.json"));
         const mod = req(entryPath);
-        if (mod && typeof mod.registerCoreTools === "function") {
+        const fn = getRegisterFn(mod);
+        if (typeof fn === "function") {
           const resolvedVersion = basename(cacheDir);
-          return { registerCoreTools: mod.registerCoreTools, descriptor: entryStr, resolvedVersion };
+          return { register: fn, descriptor: entryStr, resolvedVersion };
         }
         break;
       } catch {
@@ -1861,9 +1900,10 @@ async function loadExtensionFromToolYamlCacheAsync(configFilePath, stepLog) {
         const cacheDir = ensurePackageInCache(parsed.packageName, parsed.version, opts);
         if (stepLog) stepLog(`Using cache: ${cacheDir}`);
         const mod = await importFromCache(cacheDir);
-        if (mod && typeof mod.registerCoreTools === "function") {
+        const fn = getRegisterFn(mod);
+        if (typeof fn === "function") {
           const resolvedVersion = basename(cacheDir);
-          return { registerCoreTools: mod.registerCoreTools, descriptor: entryStr, resolvedVersion };
+          return { register: fn, descriptor: entryStr, resolvedVersion };
         }
         break;
       } catch {
@@ -1874,13 +1914,6 @@ async function loadExtensionFromToolYamlCacheAsync(configFilePath, stepLog) {
   }
   return null;
 }
-function loadExampleTools() {
-  try {
-    return requireFromPackage("@easynet/agent-tool-example-tools");
-  } catch {
-    return null;
-  }
-}
 function createRuntimeFromConfigSync(options = {}) {
   const registry = new ToolRegistry();
   const stepLog = options.stepLog;
@@ -1893,70 +1926,67 @@ function createRuntimeFromConfigSync(options = {}) {
       const resolvedVersion = getInstalledPackageVersion(extensionNode.packageName);
       const prefix = npmDescriptorToRegistryPrefix(descriptor, resolvedVersion ?? void 0);
       const reg = prefix ? createPrefixingRegistry(registry, prefix) : registry;
-      const coreAdapter = extensionNode.registerCoreTools(reg, options.coreTools);
+      const coreAdapter = extensionNode.register(reg, options.coreTools);
       const runtime3 = new PTCRuntime({ registry });
       runtime3.registerAdapter(coreAdapter);
-      if (options.exampleTools !== void 0) {
-        const example = loadExampleTools();
-        if (example) {
-          const exampleAdapter = example.registerExampleTools(registry, options.exampleTools);
-          runtime3.registerAdapter(exampleAdapter);
-        }
-      }
       return { runtime: runtime3, registry };
     }
     if (options.configFilePath) {
+      const extensionFromNodeModules = loadExtensionFromToolYamlNodeModules(options.configFilePath, stepLog);
+      if (extensionFromNodeModules) {
+        if (stepLog) stepLog("Registered extension from tool.yaml list (node_modules)");
+        const prefix = npmDescriptorToRegistryPrefix(extensionFromNodeModules.descriptor, extensionFromNodeModules.resolvedVersion);
+        const reg = prefix ? createPrefixingRegistry(registry, prefix) : registry;
+        const coreAdapter = extensionFromNodeModules.register(reg, options.coreTools);
+        const runtime3 = new PTCRuntime({ registry });
+        runtime3.registerAdapter(coreAdapter);
+        return { runtime: runtime3, registry };
+      }
       if (stepLog) stepLog("No extension in node_modules, loading from tool.yaml cache");
       const extensionCache = loadExtensionFromToolYamlCache(options.configFilePath, stepLog);
       if (extensionCache) {
         if (stepLog) stepLog("Registered extension from cache");
         const prefix = npmDescriptorToRegistryPrefix(extensionCache.descriptor, extensionCache.resolvedVersion);
         const reg = prefix ? createPrefixingRegistry(registry, prefix) : registry;
-        const coreAdapter = extensionCache.registerCoreTools(reg, options.coreTools);
+        const coreAdapter = extensionCache.register(reg, options.coreTools);
         const runtime3 = new PTCRuntime({ registry });
         runtime3.registerAdapter(coreAdapter);
-        if (options.exampleTools !== void 0) {
-          const example = loadExampleTools();
-          if (example) {
-            const exampleAdapter = example.registerExampleTools(registry, options.exampleTools);
-            runtime3.registerAdapter(exampleAdapter);
-          }
-        }
         return { runtime: runtime3, registry };
       }
     }
     const runtime2 = new PTCRuntime({ registry });
     return { runtime: runtime2, registry };
   }
-  if (options.exampleTools !== void 0) {
-    const example = loadExampleTools();
-    if (example) {
-      const exampleAdapter = example.registerExampleTools(registry, options.exampleTools);
-      const runtime2 = new PTCRuntime({ registry });
-      runtime2.registerAdapter(exampleAdapter);
-      return { runtime: runtime2, registry };
-    }
-  }
   const runtime = new PTCRuntime({ registry });
   return { runtime, registry };
 }
 async function createRuntimeFromConfig(options = {}) {
-  const syncResult = createRuntimeFromConfigSync(options);
-  if (options.coreTools !== void 0 && options.configFilePath && syncResult.registry.snapshot().length === 0) {
-    if (options.stepLog) options.stepLog("No extension from sync, trying async cache load");
-    const extension = await loadExtensionFromToolYamlCacheAsync(options.configFilePath, options.stepLog);
-    if (extension) {
-      if (options.stepLog) options.stepLog("Registered extension from async cache");
+  if (options.coreTools !== void 0 && options.configFilePath) {
+    const fromNodeModules = loadExtensionFromToolYamlNodeModules(options.configFilePath, options.stepLog);
+    if (fromNodeModules) {
+      if (options.stepLog) options.stepLog("Registered extension from tool.yaml list (node_modules)");
+      const registry = new ToolRegistry();
+      const prefix = npmDescriptorToRegistryPrefix(fromNodeModules.descriptor, fromNodeModules.resolvedVersion);
+      const reg = prefix ? createPrefixingRegistry(registry, prefix) : registry;
+      const coreAdapter = fromNodeModules.register(reg, options.coreTools);
+      const runtime = new PTCRuntime({ registry });
+      runtime.registerAdapter(coreAdapter);
+      return { runtime, registry };
+    }
+    if (options.stepLog) options.stepLog("Loading extension from tool.yaml cache (dynamic: npm pack + import)");
+    const fromCache = await loadExtensionFromToolYamlCacheAsync(options.configFilePath, options.stepLog);
+    if (fromCache) {
+      if (options.stepLog) options.stepLog("Registered extension from cache");
       const registry = new ToolRegistry();
-      const prefix = npmDescriptorToRegistryPrefix(extension.descriptor, extension.resolvedVersion);
+      const prefix = npmDescriptorToRegistryPrefix(fromCache.descriptor, fromCache.resolvedVersion);
       const reg = prefix ? createPrefixingRegistry(registry, prefix) : registry;
-      const coreAdapter = extension.registerCoreTools(reg, options.coreTools);
+      const coreAdapter = fromCache.register(reg, options.coreTools);
       const runtime = new PTCRuntime({ registry });
       runtime.registerAdapter(coreAdapter);
       return { runtime, registry };
     }
   }
-  return syncResult;
+  return createRuntimeFromConfigSync(options);
 }
 
 // src/tools/mcp/types.ts
@@ -1967,5 +1997,5 @@ var LANGCHAIN_KIND = "langchain";
 var LANGCHAIN_DIR_NAME = "langchain";
 
 export { BudgetManager, EventLog, LANGCHAIN_DIR_NAME, LANGCHAIN_KIND, MCP_KIND, Metrics, PTCRuntime, PolicyDeniedError, PolicyEngine, SchemaValidationError, SchemaValidator, Tracing, buildEvidence, createLogger, createRuntimeFromConfig, createRuntimeFromConfigSync, ensurePackageInCache, expandToolDescriptorsToRegistryNames, findAndLoadToolConfig, getDisplayScope, getPackageEntryPath, importFromCache, isBarePackageDescriptor, isNpmToolDescriptor, loadToolConfig, normalizeToolList, npmDescriptorToRegistryPrefix, parseNpmToolDescriptor, resolveNpmToolDescriptor, resolveSandboxedPath, resolveToolDescriptor, sanitizeForLog, summarizeForLog };
-//# sourceMappingURL=chunk-BPHY6UVK.js.map
-//# sourceMappingURL=chunk-BPHY6UVK.js.map
+//# sourceMappingURL=chunk-UUQGKFSG.js.map
+//# sourceMappingURL=chunk-UUQGKFSG.js.map