@easynet/agent-tool 1.0.59 → 1.0.61

package/dist/index.js

@@ -1,523 +1,11 @@
-export { createAgentTools, createLangChainToolsAsync } from './chunk-IWM5B5DU.js';
-export { buildFunctionToTool, buildMcpPackage, initProject, runGeneratedMCP, runMcpServer } from './chunk-Y75CRPVF.js';
-import { scanForTools } from './chunk-A5C2MUNA.js';
-export { PTCRuntime, createMCPServer, createMCPServerStreamableHttp, createMCPStreamableHttpHandler, createHttpService as createOpenAPIServer, createRuntimeFromConfig, createRuntimeFromConfigSync, loadToolConfig, resolveSandboxedPath2 as resolveSandboxedPath, runMCPServerOverStdio, scan, scanForTools, setSandboxValidationEnabled } from './chunk-A5C2MUNA.js';
-import { createTaggedError } from './chunk-FCYBA7PR.js';
-export { ToolRegistry, createTaggedError } from './chunk-FCYBA7PR.js';
-import { createToolSpec } from './chunk-ODEHUAR4.js';
-export { DEFAULT_INPUT_SCHEMA, DEFAULT_OUTPUT_SCHEMA, createToolSpec, normalizeToolName } from './chunk-ODEHUAR4.js';
+export { createAgentTools, createLangChainToolsAsync } from './chunk-QPKBEU64.js';
+export { createMCPServer, createMCPServerStreamableHttp, createMCPStreamableHttpHandler, createHttpService as createOpenAPIServer, createRuntimeFromConfig, createRuntimeFromConfigSync, runMCPServerOverStdio } from './chunk-NVT4X4CB.js';
 import './chunk-NTWOVFEY.js';
-import { AsyncLocalStorage } from 'async_hooks';
-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';
-
-function createContextRunner() {
-  const storage = new 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 unwrapArgsForHandler(spec, args) {
-  if (args == null || typeof args !== "object" || Array.isArray(args)) return args;
-  const s = spec.inputSchema;
-  if (s?.type !== "object" || !s.properties || typeof s.properties !== "object") return args;
-  const props = s.properties;
-  const argsProp = props.args;
-  if (argsProp != null && typeof argsProp === "object" && argsProp.type === "object" && argsProp.properties != null) {
-    const obj = args;
-    if (Object.keys(obj).length === 1 && "args" in obj && typeof obj.args === "object" && obj.args !== null) {
-      return obj.args;
-    }
-  }
-  return args;
-}
-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 handlerArgs = unwrapArgsForHandler(spec, mergedArgs);
-      const resolvedPackageRoot = meta?.packageRoot ?? packageRoot;
-      const modulePath = path6.join(resolvedPackageRoot, `${sourcePath}.js`);
-      const mod = await import(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, mergedArgs);
-      const output = await contextRunner.runWith(ctx, () => handler(handlerArgs));
-      return {
-        result: { result: output.result, evidence: output.evidence },
-        raw: { evidence: output.evidence }
-      };
-    }
-  };
-}
-function loadToolYaml(packageRoot, sourcePath) {
-  const dir = path6.dirname(sourcePath);
-  const base = path6.basename(sourcePath);
-  const dirPath = path6.join(packageRoot, dir);
-  const yamlPath = existsSync(path6.join(dirPath, `${base}.tool.yaml`)) ? path6.join(dirPath, `${base}.tool.yaml`) : path6.join(dirPath, `${base}.example.yaml`);
-  if (!existsSync(yamlPath)) return void 0;
-  try {
-    const raw = readFileSync(yamlPath, "utf-8");
-    const data = yaml.load(raw);
-    if (data == null || typeof data !== "object" || Array.isArray(data)) return void 0;
-    const obj = data;
-    const toolBlock = obj?.tool;
-    const arr = toolBlock?.list;
-    if (!Array.isArray(arr)) return void 0;
-    const defaults = toolBlock?.defaults != null && typeof toolBlock.defaults === "object" && !Array.isArray(toolBlock.defaults) ? toolBlock.defaults : {};
-    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;
-    const merged = { ...defaults, ...rest };
-    if (Object.keys(merged).length === 0) return void 0;
-    return merged;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/api/extension/registerFromManifest.ts
-function loadExtensionManifest(manifestPathOrDir) {
-  const p = path6.resolve(manifestPathOrDir);
-  let manifestPath;
-  if (existsSync(p) && statSync(p).isFile()) {
-    manifestPath = p;
-  } else {
-    const inDir = path6.join(p, "core-tools-manifest.json");
-    const inDist = path6.join(p, "dist", "core-tools-manifest.json");
-    manifestPath = existsSync(inDir) ? inDir : inDist;
-  }
-  const raw = 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) {
-    const toolName = entry.name ?? (entry.coreName != null ? entry.coreName.replace(/^[^/]+\//, "").replace(/^src\./, "") : entry.sourcePath.replace(/^src\//, "").replace(/\//g, "."));
-    let spec = createToolSpec({
-      name: toolName,
-      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,
-        shortName: toolName,
-        ...packageRoot != null && { packageRoot },
-        ...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.dirname(fileURLToPath(metaUrlOrPath)) : path6.resolve(metaUrlOrPath);
-  const dist = path6.join(dir, "dist");
-  return 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, mergedArgs) => {
-      const defaultArgs = spec._meta?.defaultArgs ?? {};
-      const baseConfig = config !== void 0 ? config : {};
-      const toolOverrides = baseConfig?.toolOverrides;
-      const shortName = spec._meta?.shortName ?? spec.name;
-      const prefixWithVersion = shortName && spec.name.endsWith(shortName) && spec.name.length > shortName.length ? spec.name.slice(0, spec.name.length - shortName.length - 1) : "";
-      const parts = prefixWithVersion ? prefixWithVersion.split(".") : [];
-      const packageScopedKey = parts.length > 1 ? `${parts.slice(0, -1).join(".")}::${shortName}` : "";
-      const perTool = toolOverrides?.[spec.name] ?? (packageScopedKey ? toolOverrides?.[packageScopedKey] : void 0) ?? toolOverrides?.[shortName] ?? {};
-      const packagePrefix = parts.length > 1 ? parts.slice(0, -1).join(".") : "";
-      const packageDefaults = baseConfig?.packageDefaults;
-      const packageDefaultsForPkg = (packagePrefix && packageDefaults?.[packagePrefix]) ?? (prefixWithVersion && packageDefaults?.[prefixWithVersion]) ?? {};
-      const baseWithoutOverrides = { ...baseConfig };
-      delete baseWithoutOverrides.toolOverrides;
-      delete baseWithoutOverrides.packageDefaults;
-      const resolvedConfig = {
-        ...defaultArgs,
-        ...baseWithoutOverrides,
-        ...packageDefaultsForPkg,
-        ...perTool,
-        ...mergedArgs ?? {}
-      };
-      return { execCtx, config: resolvedConfig };
-    },
-    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.dirname(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) : userConfigOrOpts;
-      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 copyToolYamlRecursive(srcDir, destDir) {
-  if (!existsSync(srcDir)) return 0;
-  let copied = 0;
-  for (const e of readdirSync(srcDir, { withFileTypes: true })) {
-    const srcPath = path6.join(srcDir, e.name);
-    const destPath = path6.join(destDir, e.name);
-    if (e.isFile() && (e.name.endsWith(".tool.yaml") || e.name.endsWith(".example.yaml"))) {
-      if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
-      copyFileSync(srcPath, destPath);
-      copied++;
-    } else if (e.isDirectory()) {
-      copied += copyToolYamlRecursive(srcPath, destPath);
-    }
-  }
-  return copied;
-}
-function generateExtensionManifest(projectRoot = process.cwd(), options = {}) {
-  const root = path6.resolve(projectRoot);
-  const outDir = path6.resolve(options.outDir ?? path6.join(root, "dist"));
-  const kind = options.kind ?? "core";
-  const { specs, errors } = 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 pathBasedName = sourcePathNoExt.replace(/^src\//, "").replace(/\//g, ".");
-    const name = spec.exportName ?? pathBasedName;
-    const sideEffect = spec._meta?.hitl?.sideEffect ?? "none";
-    return {
-      name,
-      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 (!existsSync(outDir)) mkdirSync(outDir, { recursive: true });
-  const manifestPath = path6.join(outDir, "core-tools-manifest.json");
-  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.join(root, d);
-      const destDir = path6.join(outDir, d);
-      try {
-        toolYamlCopied += copyToolYamlRecursive(srcDir, destDir);
-      } catch {
-      }
-    }
-  }
-  return { manifestPath, toolsCount: entries.length, toolYamlCopied };
-}
-function generateManifest(projectRoot = process.cwd(), options = {}) {
-  const { manifestPath, toolsCount, toolYamlCopied } = generateExtensionManifest(projectRoot, {
-    include: ["src/**/*.ts"],
-    copyToolYamlDirs: ["src"],
-    ...options
-  });
-  console.log(`Wrote ${toolsCount} tools to ${path6.relative(projectRoot, manifestPath)}`);
-  if (toolYamlCopied > 0) console.log(`Copied ${toolYamlCopied} .tool.yaml/.example.yaml file(s) to dist`);
-}
-
-// src/api/extension/overrideWithConfig.ts
-function overrideWithConfig(defaults, config) {
-  const c = config != null && typeof config === "object" && !Array.isArray(config) ? config : {};
-  const out = { ...defaults };
-  for (const key of Object.keys(defaults)) {
-    if (key in c && c[key] !== void 0) {
-      out[key] = c[key];
-    }
-  }
-  return out;
-}
-
-// 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((x) => x != null) : void 0;
-  return {
-    ...onlySet ? { only: Array.from(onlySet) } : {},
-    ...namePrefixes?.length ? { namePrefixes } : {}
-  };
-}
-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;
-}
-
-export { createContextRunner, createDynamicImportAdapter, createExtension, generateExtensionManifest, generateManifest, getGroupNamePrefixes, isIpInBlockedCidrs, loadExtensionManifest, loadToolYaml, overrideWithConfig, registerExtension, registerToolsFromManifest, resolveExtensionPackageRoot, validateUrl };
+import './chunk-YRFUGA3C.js';
+import './chunk-45S2HPVU.js';
+import './chunk-QXQ4477T.js';
+import './chunk-WUMLZERG.js';
+import './chunk-RZTTO5MQ.js';
+import './chunk-ODEHUAR4.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map