@easynet/agent-tool 1.0.46 → 1.0.48

package/dist/index.js

@@ -1,194 +1,19 @@
-export { LangChainToolsHub, createAgentTools } from './chunk-H66TKSG4.js';
-import { scanForTools, loadMCPTool } from './chunk-SRTE2OUH.js';
-export { DirectoryScanner, DiscoveryError, SkillManifestError, buildFunctionToTool, buildMcpPackage, initProject, loadMCPTool, loadSkillDefinition, parseSkillMd, runGeneratedMCP, runMcpServer, scan, scanForTools, scanSkillResources, validateFrontmatter } from './chunk-SRTE2OUH.js';
-import { MCP_KIND } from './chunk-5GFSI7ZJ.js';
-export { BudgetManager, EventLog, Metrics, PTCRuntime, PolicyDeniedError, PolicyEngine, SchemaValidationError, SchemaValidator, Tracing, buildEvidence, createLogger, ensurePackageInCache, expandToolDescriptorsToRegistryNames, getPackageEntryPath, importFromCache, isNpmToolDescriptor, loadToolConfig, normalizeToolList, npmDescriptorToRegistryPrefix, parseNpmToolDescriptor, resolveLatestVersionFromRegistry, resolveNpmToolDescriptor, resolveSandboxedPath, resolveToolDescriptor, sanitizeForLog, setSandboxValidationEnabled, summarizeForLog } from './chunk-5GFSI7ZJ.js';
+export { createAgentTools, createLangChainToolsAsync } from './chunk-KYBIKD5R.js';
+import { scanForTools } from './chunk-64ZQQV5C.js';
+export { buildFunctionToTool, buildMcpPackage, initProject, runGeneratedMCP, runMcpServer, scan, scanForTools } from './chunk-64ZQQV5C.js';
+export { PTCRuntime, createMCPServer, createMCPServerStreamableHttp, createMCPStreamableHttpHandler, createHttpService as createOpenAPIServer, createRuntimeFromConfig, createRuntimeFromConfigSync, loadToolConfig, resolveSandboxedPath2 as resolveSandboxedPath, runMCPServerOverStdio, setSandboxValidationEnabled } from './chunk-2ZPDD7ZO.js';
 import { createTaggedError } from './chunk-ZRHPGW7W.js';
-export { ToolRegistry, createTaggedError, isRetryable, withRetry } from './chunk-ZRHPGW7W.js';
-import { createToolSpec, DEFAULT_OUTPUT_SCHEMA, DEFAULT_INPUT_SCHEMA } from './chunk-KDB3MY2H.js';
+export { ToolRegistry, createTaggedError } from './chunk-ZRHPGW7W.js';
+import { createToolSpec } from './chunk-KDB3MY2H.js';
 export { DEFAULT_INPUT_SCHEMA, DEFAULT_OUTPUT_SCHEMA, createToolSpec, normalizeToolName } from './chunk-KDB3MY2H.js';
 import './chunk-NTWOVFEY.js';
-import { lookup } from 'dns/promises';
 import { AsyncLocalStorage } from 'async_hooks';
-import path6, { join, dirname, basename } from 'path';
+import path6 from 'path';
 import { pathToFileURL, fileURLToPath } from 'url';
 import { existsSync, readFileSync, statSync, mkdirSync, writeFileSync, readdirSync, copyFileSync } from 'fs';
 import yaml from 'js-yaml';
+import { lookup } from 'dns/promises';
 
-async function validateUrl(url, options) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw createTaggedError(
-      "HTTP_DISALLOWED_HOST",
-      `Invalid URL: ${url}`,
-      { url }
-    );
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw createTaggedError(
-      "HTTP_DISALLOWED_HOST",
-      `Protocol not allowed: ${parsed.protocol}. Only http: and https: are supported.`,
-      { url, protocol: parsed.protocol }
-    );
-  }
-  const hostname = parsed.hostname;
-  if (!isHostAllowed(hostname, options.allowedHosts)) {
-    throw createTaggedError(
-      "HTTP_DISALLOWED_HOST",
-      `Host "${hostname}" is not in the allowed hosts list`,
-      { url, hostname, allowedHosts: options.allowedHosts }
-    );
-  }
-  if (isHostBlocked(hostname, options.blockedHosts)) {
-    throw createTaggedError(
-      "HTTP_DISALLOWED_HOST",
-      `Host "${hostname}" is in the blocked hosts list`,
-      { url, hostname, blockedHosts: options.blockedHosts }
-    );
-  }
-  try {
-    const { address } = await lookup(hostname);
-    if (isIpInBlockedCidrs(address, options.blockedCidrs)) {
-      throw createTaggedError(
-        "HTTP_DISALLOWED_HOST",
-        `Host "${hostname}" resolves to blocked IP: ${address}`,
-        { url, hostname, resolvedIp: address }
-      );
-    }
-  } catch (err) {
-    if (err instanceof Error && err.kind === "HTTP_DISALLOWED_HOST") {
-      throw err;
-    }
-    throw createTaggedError(
-      "HTTP_DISALLOWED_HOST",
-      `DNS resolution failed for host "${hostname}": ${err instanceof Error ? err.message : String(err)}`,
-      { url, hostname }
-    );
-  }
-  return parsed;
-}
-function isHostAllowed(hostname, allowedHosts) {
-  for (const pattern of allowedHosts) {
-    if (pattern === "*") {
-      return true;
-    }
-    if (pattern.startsWith("*.")) {
-      const suffix = pattern.slice(1);
-      if (hostname.endsWith(suffix) || hostname === pattern.slice(2)) {
-        return true;
-      }
-    } else if (hostname === pattern) {
-      return true;
-    }
-  }
-  return false;
-}
-function isHostBlocked(hostname, blockedHosts) {
-  for (const pattern of blockedHosts) {
-    if (pattern === "*") {
-      return true;
-    }
-    if (pattern.startsWith("*.")) {
-      const suffix = pattern.slice(1);
-      if (hostname.endsWith(suffix) || hostname === pattern.slice(2)) {
-        return true;
-      }
-    } else if (hostname === pattern) {
-      return true;
-    }
-  }
-  return false;
-}
-function isIpInBlockedCidrs(ip, cidrs) {
-  const normalizedIp = normalizeIp(ip);
-  if (!normalizedIp) return false;
-  for (const cidr of cidrs) {
-    if (cidr.includes(":")) {
-      if (!ip.includes(":")) continue;
-      if (isIpv6InCidr(ip, cidr)) return true;
-    } else {
-      if (isIpv4InCidr(normalizedIp, cidr)) return true;
-    }
-  }
-  return false;
-}
-function normalizeIp(ip) {
-  if (ip.startsWith("::ffff:")) {
-    return ip.slice(7);
-  }
-  if (/^\d+\.\d+\.\d+\.\d+$/.test(ip)) {
-    return ip;
-  }
-  return null;
-}
-function isIpv4InCidr(ip, cidr) {
-  const [cidrIp, prefixStr] = cidr.split("/");
-  if (!cidrIp || !prefixStr) return false;
-  const prefix = parseInt(prefixStr, 10);
-  if (isNaN(prefix) || prefix < 0 || prefix > 32) return false;
-  const ipNum = ipv4ToNum(ip);
-  const cidrNum = ipv4ToNum(cidrIp);
-  if (ipNum === null || cidrNum === null) return false;
-  const mask = prefix === 0 ? 0 : -1 << 32 - prefix >>> 0;
-  return (ipNum & mask) === (cidrNum & mask);
-}
-function ipv4ToNum(ip) {
-  const parts = ip.split(".");
-  if (parts.length !== 4) return null;
-  let num = 0;
-  for (const part of parts) {
-    const n = parseInt(part, 10);
-    if (isNaN(n) || n < 0 || n > 255) return null;
-    num = num << 8 | n;
-  }
-  return num >>> 0;
-}
-function isIpv6InCidr(ip, cidr) {
-  const [cidrIp, prefixStr] = cidr.split("/");
-  if (!cidrIp || !prefixStr) return false;
-  const prefix = parseInt(prefixStr, 10);
-  if (isNaN(prefix)) return false;
-  const ipBytes = expandIpv6(ip);
-  const cidrBytes = expandIpv6(cidrIp);
-  if (!ipBytes || !cidrBytes) return false;
-  const fullBytes = Math.floor(prefix / 8);
-  for (let i = 0; i < fullBytes && i < 16; i++) {
-    if (ipBytes[i] !== cidrBytes[i]) return false;
-  }
-  const remainingBits = prefix % 8;
-  if (remainingBits > 0 && fullBytes < 16) {
-    const mask = -1 << 8 - remainingBits & 255;
-    if ((ipBytes[fullBytes] & mask) !== (cidrBytes[fullBytes] & mask)) return false;
-  }
-  return true;
-}
-function expandIpv6(ip) {
-  const zoneIdx = ip.indexOf("%");
-  if (zoneIdx !== -1) ip = ip.slice(0, zoneIdx);
-  const parts = ip.split("::");
-  if (parts.length > 2) return null;
-  const bytes = new Array(16).fill(0);
-  const expandGroup = (group) => {
-    if (!group) return [];
-    return group.split(":").flatMap((hex) => {
-      const val = parseInt(hex || "0", 16);
-      return [val >> 8 & 255, val & 255];
-    });
-  };
-  if (parts.length === 1) {
-    const expanded = expandGroup(parts[0]);
-    if (expanded.length !== 16) return null;
-    return expanded;
-  }
-  const left = expandGroup(parts[0]);
-  const right = expandGroup(parts[1]);
-  if (left.length + right.length > 16) return null;
-  for (let i = 0; i < left.length; i++) bytes[i] = left[i];
-  for (let i = 0; i < right.length; i++) bytes[16 - right.length + i] = right[i];
-  return bytes;
-}
 function createContextRunner() {
   const storage = new AsyncLocalStorage();
   return {
@@ -510,122 +335,187 @@ function overrideWithConfig(defaults, config) {
 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;
+  const namePrefixes = !onlySet && groups?.length ? groups.map((g) => groupPrefixMap[g]).filter((x) => x != null) : void 0;
   return {
     ...onlySet ? { only: Array.from(onlySet) } : {},
     ...namePrefixes?.length ? { namePrefixes } : {}
   };
 }
-
-// src/tools/mcp/MCPClientAdapter.ts
-function textFromCallToolResult(result) {
-  if (result.content?.length) {
-    const parts = result.content.filter((c) => c.type === "text" && c.text != null).map((c) => c.text);
-    if (parts.length) return parts.join("\n");
+async function validateUrl(url, options) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw createTaggedError(
+      "HTTP_DISALLOWED_HOST",
+      `Invalid URL: ${url}`,
+      { url }
+    );
   }
-  if (result.toolResult !== void 0) return JSON.stringify(result.toolResult);
-  return JSON.stringify(result);
-}
-var MCPClientAdapter = class {
-  constructor(client) {
-    this.client = client;
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw createTaggedError(
+      "HTTP_DISALLOWED_HOST",
+      `Protocol not allowed: ${parsed.protocol}. Only http: and https: are supported.`,
+      { url, protocol: parsed.protocol }
+    );
   }
-  kind = 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 });
-    const text = textFromCallToolResult(result);
-    let resultValue = text;
-    try {
-      resultValue = JSON.parse(text);
-    } catch {
-    }
-    return { result: resultValue, raw: result };
+  const hostname = parsed.hostname;
+  if (!isHostAllowed(hostname, options.allowedHosts)) {
+    throw createTaggedError(
+      "HTTP_DISALLOWED_HOST",
+      `Host "${hostname}" is not in the allowed hosts list`,
+      { url, hostname, allowedHosts: options.allowedHosts }
+    );
   }
-};
-
-// src/tools/mcp/connectMCP.ts
-async function connectMCP(connectionInfo) {
-  if (connectionInfo.type !== "stdio" || !connectionInfo.command) {
-    throw new Error(
-      `MCP stdio requires connectionInfo.type "stdio" and command; got type=${connectionInfo.type}`
+  if (isHostBlocked(hostname, options.blockedHosts)) {
+    throw createTaggedError(
+      "HTTP_DISALLOWED_HOST",
+      `Host "${hostname}" is in the blocked hosts list`,
+      { url, hostname, blockedHosts: options.blockedHosts }
     );
   }
-  const { Client } = await import('@modelcontextprotocol/sdk/client');
-  const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js');
-  const serverParams = {
-    command: connectionInfo.command,
-    args: connectionInfo.args ?? [],
-    env: connectionInfo.env,
-    cwd: connectionInfo.cwd
-  };
-  const transport = new StdioClientTransport(serverParams);
-  const client = new Client({ name: "agent-tool", version: "1.0.0" });
-  await client.connect(transport);
-  return {
-    client,
-    transport
-  };
+  try {
+    const { address } = await lookup(hostname);
+    if (isIpInBlockedCidrs(address, options.blockedCidrs)) {
+      throw createTaggedError(
+        "HTTP_DISALLOWED_HOST",
+        `Host "${hostname}" resolves to blocked IP: ${address}`,
+        { url, hostname, resolvedIp: address }
+      );
+    }
+  } catch (err) {
+    if (err instanceof Error && err.kind === "HTTP_DISALLOWED_HOST") {
+      throw err;
+    }
+    throw createTaggedError(
+      "HTTP_DISALLOWED_HOST",
+      `DNS resolution failed for host "${hostname}": ${err instanceof Error ? err.message : String(err)}`,
+      { url, hostname }
+    );
+  }
+  return parsed;
 }
-function mcpToolsToSpecs(tools) {
-  return tools.map((t) => ({
-    name: t.name,
-    version: "1.0.0",
-    kind: MCP_KIND,
-    description: t.description ?? `MCP tool: ${t.name}`,
-    inputSchema: t.inputSchema ?? DEFAULT_INPUT_SCHEMA,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA,
-    capabilities: []
-  }));
+function isHostAllowed(hostname, allowedHosts) {
+  for (const pattern of allowedHosts) {
+    if (pattern === "*") {
+      return true;
+    }
+    if (pattern.startsWith("*.")) {
+      const suffix = pattern.slice(1);
+      if (hostname.endsWith(suffix) || hostname === pattern.slice(2)) {
+        return true;
+      }
+    } else if (hostname === pattern) {
+      return true;
+    }
+  }
+  return false;
 }
-
-// src/tools/mcp/MCPProcessManager.ts
-var MCPProcessManager = class {
-  connections = /* @__PURE__ */ new Map();
-  getConnectionInfo(toolName, config) {
-    const cached = this.connections.get(toolName);
-    if (cached) return cached;
-    const info = config.url ? { type: "url", url: config.url } : {
-      type: "stdio",
-      command: config.command,
-      args: config.args,
-      env: config.env,
-      cwd: config.cwd
-    };
-    this.connections.set(toolName, info);
-    return info;
+function isHostBlocked(hostname, blockedHosts) {
+  for (const pattern of blockedHosts) {
+    if (pattern === "*") {
+      return true;
+    }
+    if (pattern.startsWith("*.")) {
+      const suffix = pattern.slice(1);
+      if (hostname.endsWith(suffix) || hostname === pattern.slice(2)) {
+        return true;
+      }
+    } else if (hostname === pattern) {
+      return true;
+    }
   }
-  remove(toolName) {
-    return this.connections.delete(toolName);
+  return false;
+}
+function isIpInBlockedCidrs(ip, cidrs) {
+  const normalizedIp = normalizeIp(ip);
+  if (!normalizedIp) return false;
+  for (const cidr of cidrs) {
+    if (cidr.includes(":")) {
+      if (!ip.includes(":")) continue;
+      if (isIpv6InCidr(ip, cidr)) return true;
+    } else {
+      if (isIpv4InCidr(normalizedIp, cidr)) return true;
+    }
   }
-  getToolNames() {
-    return [...this.connections.keys()];
+  return false;
+}
+function normalizeIp(ip) {
+  if (ip.startsWith("::ffff:")) {
+    return ip.slice(7);
   }
-  dispose() {
-    this.connections.clear();
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(ip)) {
+    return ip;
   }
-};
-
-// src/tools/mcp/registerMCPTools.ts
-async function registerMCPToolsFromConfig(runtime, registry, options = {}) {
-  const configPath = options.configPath ?? process.env.MCP_CONFIG_PATH ?? join(process.cwd(), "mcp.json");
-  const dirPath = dirname(configPath);
-  const entryPoint = basename(configPath);
-  const toolName = options.toolName ?? MCP_KIND;
-  const loaded = await loadMCPTool(dirPath, { kind: MCP_KIND, name: toolName, entryPoint });
-  if (!loaded.mcpConfig) {
-    throw new Error("mcp.json must have command or url");
+  return null;
+}
+function isIpv4InCidr(ip, cidr) {
+  const [cidrIp, prefixStr] = cidr.split("/");
+  if (!cidrIp || !prefixStr) return false;
+  const prefix = parseInt(prefixStr, 10);
+  if (isNaN(prefix) || prefix < 0 || prefix > 32) return false;
+  const ipNum = ipv4ToNum(ip);
+  const cidrNum = ipv4ToNum(cidrIp);
+  if (ipNum === null || cidrNum === null) return false;
+  const mask = prefix === 0 ? 0 : -1 << 32 - prefix >>> 0;
+  return (ipNum & mask) === (cidrNum & mask);
+}
+function ipv4ToNum(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) return null;
+  let num = 0;
+  for (const part of parts) {
+    const n = parseInt(part, 10);
+    if (isNaN(n) || n < 0 || n > 255) return null;
+    num = num << 8 | n;
+  }
+  return num >>> 0;
+}
+function isIpv6InCidr(ip, cidr) {
+  const [cidrIp, prefixStr] = cidr.split("/");
+  if (!cidrIp || !prefixStr) return false;
+  const prefix = parseInt(prefixStr, 10);
+  if (isNaN(prefix)) return false;
+  const ipBytes = expandIpv6(ip);
+  const cidrBytes = expandIpv6(cidrIp);
+  if (!ipBytes || !cidrBytes) return false;
+  const fullBytes = Math.floor(prefix / 8);
+  for (let i = 0; i < fullBytes && i < 16; i++) {
+    if (ipBytes[i] !== cidrBytes[i]) return false;
+  }
+  const remainingBits = prefix % 8;
+  if (remainingBits > 0 && fullBytes < 16) {
+    const mask = -1 << 8 - remainingBits & 255;
+    if ((ipBytes[fullBytes] & mask) !== (cidrBytes[fullBytes] & mask)) return false;
   }
-  const manager = new MCPProcessManager();
-  const connectionInfo = manager.getConnectionInfo(toolName, loaded.mcpConfig);
-  const { client, transport } = await connectMCP(connectionInfo);
-  const { tools } = await client.listTools();
-  const specs = mcpToolsToSpecs(tools);
-  registry.bulkRegister(specs);
-  runtime.registerAdapter(new MCPClientAdapter(client));
-  return { transport };
+  return true;
+}
+function expandIpv6(ip) {
+  const zoneIdx = ip.indexOf("%");
+  if (zoneIdx !== -1) ip = ip.slice(0, zoneIdx);
+  const parts = ip.split("::");
+  if (parts.length > 2) return null;
+  const bytes = new Array(16).fill(0);
+  const expandGroup = (group) => {
+    if (!group) return [];
+    return group.split(":").flatMap((hex) => {
+      const val = parseInt(hex || "0", 16);
+      return [val >> 8 & 255, val & 255];
+    });
+  };
+  if (parts.length === 1) {
+    const expanded = expandGroup(parts[0]);
+    if (expanded.length !== 16) return null;
+    return expanded;
+  }
+  const left = expandGroup(parts[0]);
+  const right = expandGroup(parts[1]);
+  if (left.length + right.length > 16) return null;
+  for (let i = 0; i < left.length; i++) bytes[i] = left[i];
+  for (let i = 0; i < right.length; i++) bytes[16 - right.length + i] = right[i];
+  return bytes;
 }
 
-export { MCPClientAdapter, MCPProcessManager, connectMCP, createContextRunner, createDynamicImportAdapter, createExtension, generateExtensionManifest, generateManifest, getGroupNamePrefixes, isIpInBlockedCidrs, loadExtensionManifest, loadToolYaml, mcpToolsToSpecs, overrideWithConfig, registerExtension, registerMCPToolsFromConfig, registerToolsFromManifest, resolveExtensionPackageRoot, validateUrl };
+export { createContextRunner, createDynamicImportAdapter, createExtension, generateExtensionManifest, generateManifest, getGroupNamePrefixes, isIpInBlockedCidrs, loadExtensionManifest, loadToolYaml, overrideWithConfig, registerExtension, registerToolsFromManifest, resolveExtensionPackageRoot, validateUrl };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map