@easynet/agent-tool 1.0.71 → 1.0.73

package/dist/{chunk-VSFIF3WJ.js → chunk-EHXA64OA.js}

@@ -1,5 +1,5 @@
 import { enrichSpecWithCanonicalSchema } from './chunk-NTWOVFEY.js';
-import { MCP_KIND, DirectoryScanner } from './chunk-YRFUGA3C.js';
+import { MCP_KIND, DirectoryScanner } from './chunk-Q6W32HAP.js';
 import { setSandboxValidationEnabled } from './chunk-QXQ4477T.js';
 import { ToolRegistry } from './chunk-WUMLZERG.js';
 import { createTaggedError, withRetry } from './chunk-RZTTO5MQ.js';
@@ -1534,101 +1534,18 @@ var PTCRuntime = class {
    */
   async invoke(intent, ctx) {
     const startTime = Date.now();
-    if (this.logger.isEnabled("debug")) {
-      this.logger.debug("invoke.start", {
-        tool: intent.tool,
-        requestId: ctx.requestId,
-        taskId: ctx.taskId,
-        traceId: ctx.traceId,
-        purpose: intent.purpose,
-        args: this.logger.options.includeArgs ? sanitizeForLog(intent.args) : void 0
-      });
-    }
-    const span = this.tracing.startSpan({
-      name: `tool:${intent.tool}`,
-      traceId: ctx.traceId,
-      attributes: {
-        "tool.name": intent.tool,
-        "tool.purpose": intent.purpose,
-        requestId: ctx.requestId,
-        taskId: ctx.taskId
-      }
-    });
-    emitToolCalled(intent, ctx, this.getObservabilityDeps());
+    const span = this.beginInvokeSpan(intent, ctx);
+    const observability = this.getObservabilityDeps();
+    emitToolCalled(intent, ctx, observability);
     try {
-      const spec = resolveTool(intent.tool, this.registry);
-      this.tracing.addEvent(span.spanId, "resolved", {
-        kind: spec.kind,
-        version: spec.version
-      });
-      const normalizedArgs = normalizeInputAliases(spec, intent.args);
-      const validatedArgs = validateInput(spec, normalizedArgs, this.validator);
-      const enrichedArgs = enrichDefaults(spec, validatedArgs, this.validator);
-      enforcePolicy(spec, enrichedArgs, ctx, {
-        policy: this.policy,
-        eventLog: this.eventLog,
-        metrics: this.metrics,
-        tracing: this.tracing
-      });
-      if (!this.budget.checkRateLimit(spec.name)) {
-        throw createTaggedError(
-          "BUDGET_EXCEEDED",
-          `Rate limit exceeded for tool: ${spec.name}`
-        );
-      }
-      await requireHumanApproval(spec, enrichedArgs, ctx, {
-        onApprovalRequired: this.config.onApprovalRequired,
-        eventLog: this.eventLog,
-        logger: this.logger
-      });
-      if (ctx.dryRun) {
-        return this.buildDryRunResult(spec, enrichedArgs, ctx, startTime, span.spanId);
-      }
-      const { result, raw } = await executeWithBudget(
-        spec,
-        enrichedArgs,
-        ctx,
-        span.spanId,
-        this.getPipelineDeps()
-      );
-      const toolError = asToolReturnedError(result);
-      if (toolError) {
-        const hint = buildInputSchemaHint(spec.inputSchema);
-        throw createTaggedError("UPSTREAM_ERROR", toolError.message, {
-          ...toolError.details && typeof toolError.details === "object" && !Array.isArray(toolError.details) ? toolError.details : {},
-          hint: hint ?? "Check the tool's input schema for required property names."
-        });
+      const pipeline = await this.runInvokePipeline(intent, ctx, span.spanId);
+      if (pipeline.dryRun) {
+        return this.buildDryRunResult(pipeline.spec, pipeline.enrichedArgs, ctx, startTime, span.spanId);
       }
-      const validatedOutput = validateOutput(spec, result, this.validator);
-      const durationMs = Date.now() - startTime;
-      const builtEvidence = buildEvidence({
-        spec,
-        args: enrichedArgs,
-        result: validatedOutput,
-        raw,
-        ctx,
-        durationMs
-      });
-      const adapterEvidence = raw && typeof raw === "object" && Array.isArray(raw.evidence) ? raw.evidence : [];
-      const evidence = [...adapterEvidence, ...builtEvidence];
-      recordSuccess(spec, durationMs, evidence, span.spanId, this.getObservabilityDeps());
-      if (this.logger.isEnabled("debug")) {
-        this.logger.debug("invoke.ok", {
-          tool: spec.name,
-          durationMs,
-          result: this.logger.options.includeResults ? summarizeForLog(validatedOutput) : void 0,
-          raw: this.logger.options.includeRaw ? summarizeForLog(raw) : void 0
-        });
-      }
-      return {
-        ok: true,
-        result: validatedOutput,
-        evidence,
-        raw: this.config.includeRaw !== false ? raw : void 0
-      };
+      return this.buildInvokeSuccessResult(pipeline, ctx, startTime, span.spanId, observability);
     } catch (error) {
       const durationMs = Date.now() - startTime;
-      return handleError(error, intent, ctx, durationMs, span.spanId, this.getObservabilityDeps());
+      return handleError(error, intent, ctx, durationMs, span.spanId, observability);
     }
   }
   /**
@@ -1675,6 +1592,84 @@ var PTCRuntime = class {
       logger: this.logger
     };
   }
+  beginInvokeSpan(intent, ctx) {
+    if (this.logger.isEnabled("debug")) {
+      this.logger.debug("invoke.start", {
+        tool: intent.tool,
+        requestId: ctx.requestId,
+        taskId: ctx.taskId,
+        traceId: ctx.traceId,
+        purpose: intent.purpose,
+        args: this.logger.options.includeArgs ? sanitizeForLog(intent.args) : void 0
+      });
+    }
+    return this.tracing.startSpan({
+      name: `tool:${intent.tool}`,
+      traceId: ctx.traceId,
+      attributes: {
+        "tool.name": intent.tool,
+        "tool.purpose": intent.purpose,
+        requestId: ctx.requestId,
+        taskId: ctx.taskId
+      }
+    });
+  }
+  async runInvokePipeline(intent, ctx, spanId) {
+    const spec = resolveTool(intent.tool, this.registry);
+    this.tracing.addEvent(spanId, "resolved", { kind: spec.kind, version: spec.version });
+    const normalizedArgs = normalizeInputAliases(spec, intent.args);
+    const validatedArgs = validateInput(spec, normalizedArgs, this.validator);
+    const enrichedArgs = enrichDefaults(spec, validatedArgs, this.validator);
+    enforcePolicy(spec, enrichedArgs, ctx, this.getPipelineDeps());
+    if (!this.budget.checkRateLimit(spec.name)) {
+      throw createTaggedError("BUDGET_EXCEEDED", `Rate limit exceeded for tool: ${spec.name}`);
+    }
+    await requireHumanApproval(spec, enrichedArgs, ctx, {
+      onApprovalRequired: this.config.onApprovalRequired,
+      eventLog: this.eventLog,
+      logger: this.logger
+    });
+    if (ctx.dryRun) return { spec, enrichedArgs, dryRun: true };
+    const execution = await executeWithBudget(spec, enrichedArgs, ctx, spanId, this.getPipelineDeps());
+    return { spec, enrichedArgs, dryRun: false, result: execution.result, raw: execution.raw };
+  }
+  buildInvokeSuccessResult(pipeline, ctx, startTime, spanId, observability) {
+    const toolError = asToolReturnedError(pipeline.result);
+    if (toolError) {
+      const hint = buildInputSchemaHint(pipeline.spec.inputSchema);
+      throw createTaggedError("UPSTREAM_ERROR", toolError.message, {
+        ...toolError.details && typeof toolError.details === "object" && !Array.isArray(toolError.details) ? toolError.details : {},
+        hint: hint ?? "Check the tool's input schema for required property names."
+      });
+    }
+    const validatedOutput = validateOutput(pipeline.spec, pipeline.result, this.validator);
+    const durationMs = Date.now() - startTime;
+    const builtEvidence = buildEvidence({
+      spec: pipeline.spec,
+      args: pipeline.enrichedArgs,
+      result: validatedOutput,
+      raw: pipeline.raw,
+      ctx,
+      durationMs
+    });
+    const adapterEvidence = getAdapterEvidence(pipeline.raw);
+    const evidence = [...adapterEvidence, ...builtEvidence];
+    recordSuccess(pipeline.spec, durationMs, evidence, spanId, observability);
+    if (this.logger.isEnabled("debug")) {
+      this.logger.debug("invoke.ok", {
+        tool: pipeline.spec.name,
+        durationMs,
+        result: this.logger.options.includeResults ? summarizeForLog(validatedOutput) : void 0,
+        raw: this.logger.options.includeRaw ? summarizeForLog(pipeline.raw) : void 0
+      });
+    }
+    return {
+      ok: true,
+      result: validatedOutput,
+      evidence,
+      raw: this.config.includeRaw !== false ? pipeline.raw : void 0
+    };
+  }
   buildDryRunResult(spec, args, _ctx, startTime, spanId) {
     this.tracing.endSpan(spanId, "ok");
     return {
@@ -1697,6 +1692,11 @@ var PTCRuntime = class {
     };
   }
 };
+function getAdapterEvidence(raw) {
+  if (!raw || typeof raw !== "object") return [];
+  const value = raw.evidence;
+  return Array.isArray(value) ? value : [];
+}
 function asToolReturnedError(result) {
   if (result == null || typeof result !== "object" || Array.isArray(result)) {
     return null;
@@ -2224,7 +2224,20 @@ function toolsToOpenAPISpec(registry, options = {}) {
   const version = options.version ?? "1.0.0";
   const basePath = (options.basePath ?? "").replace(/\/$/, "");
   const specs = registry.snapshot().map(enrichSpecWithCanonicalSchema);
-  const toolNamesSchema = {
+  const prefix = basePath ? `${basePath}/` : "/";
+  const paths = createBasePaths(prefix);
+  const schemaEntries = addPerToolPaths(specs, prefix, paths);
+  return {
+    openapi: "3.0.3",
+    info: { title, version },
+    paths,
+    components: {
+      schemas: Object.fromEntries(schemaEntries)
+    }
+  };
+}
+function createToolNamesSchema() {
+  return {
     type: "object",
     required: ["tools"],
     properties: {
@@ -2241,7 +2254,9 @@ function toolsToOpenAPISpec(registry, options = {}) {
       }
     }
   };
-  const invokeRequestBody = {
+}
+function createInvokeRequestBodySchema() {
+  return {
     type: "object",
     required: ["tool", "args"],
     properties: {
@@ -2253,8 +2268,9 @@ function toolsToOpenAPISpec(registry, options = {}) {
       }
     }
   };
-  const prefix = basePath ? `${basePath}/` : "/";
-  const paths = {
+}
+function createBasePaths(prefix) {
+  return {
     [`${prefix}tools`]: {
       get: {
         summary: "List tools",
@@ -2263,11 +2279,7 @@ function toolsToOpenAPISpec(registry, options = {}) {
         responses: {
           "200": {
             description: "List of tools",
-            content: {
-              "application/json": {
-                schema: toolNamesSchema
-              }
-            }
+            content: { "application/json": { schema: createToolNamesSchema() } }
           }
         }
       }
@@ -2279,62 +2291,42 @@ function toolsToOpenAPISpec(registry, options = {}) {
         operationId: "invokeTool",
         requestBody: {
           required: true,
-          content: {
-            "application/json": {
-              schema: invokeRequestBody
-            }
-          }
+          content: { "application/json": { schema: createInvokeRequestBodySchema() } }
         },
         responses: {
-          "200": {
-            description: "Tool result",
-            content: { "application/json": { schema: resultSchema } }
-          },
-          "400": {
-            description: "Bad request",
-            content: { "application/json": { schema: errorSchema } }
-          }
+          "200": { description: "Tool result", content: { "application/json": { schema: resultSchema } } },
+          "400": { description: "Bad request", content: { "application/json": { schema: errorSchema } } }
         }
       }
     }
   };
+}
+function addPerToolPaths(specs, prefix, paths) {
   const schemaEntries = [];
-  for (const s of specs) {
-    const key = toolSchemaKey(s.name);
-    schemaEntries.push([key, s.inputSchema]);
-    const slug = toolNameToSlug(s.name);
-    paths[`${prefix}invoke/${slug}`] = {
-      post: {
-        summary: s.description ?? s.name,
-        description: `Invoke tool \`${s.name}\`. Request body is the tool's arguments (JSON Schema below).`,
-        operationId: `invoke_${key}`,
-        requestBody: {
-          required: true,
-          content: {
-            "application/json": {
-              schema: { $ref: `#/components/schemas/${key}` }
-            }
-          }
-        },
-        responses: {
-          "200": {
-            description: "Tool result",
-            content: { "application/json": { schema: resultSchema } }
-          },
-          "400": {
-            description: "Bad request (invalid args or tool error)",
-            content: { "application/json": { schema: errorSchema } }
-          }
-        }
-      }
-    };
+  for (const spec of specs) {
+    const key = toolSchemaKey(spec.name);
+    schemaEntries.push([key, spec.inputSchema]);
+    paths[`${prefix}invoke/${toolNameToSlug(spec.name)}`] = createPerToolPathSpec(spec, key);
   }
+  return schemaEntries;
+}
+function createPerToolPathSpec(spec, key) {
   return {
-    openapi: "3.0.3",
-    info: { title, version },
-    paths,
-    components: {
-      schemas: Object.fromEntries(schemaEntries)
+    post: {
+      summary: spec.description ?? spec.name,
+      description: `Invoke tool \`${spec.name}\`. Request body is the tool's arguments (JSON Schema below).`,
+      operationId: `invoke_${key}`,
+      requestBody: {
+        required: true,
+        content: { "application/json": { schema: { $ref: `#/components/schemas/${key}` } } }
+      },
+      responses: {
+        "200": { description: "Tool result", content: { "application/json": { schema: resultSchema } } },
+        "400": {
+          description: "Bad request (invalid args or tool error)",
+          content: { "application/json": { schema: errorSchema } }
+        }
+      }
     }
   };
 }
@@ -2443,117 +2435,118 @@ function swaggerUiHtml(specUrl) {
 function createOpenAPIHttpServer(runtime, options = {}) {
   const basePath = (options.basePath ?? "").replace(/\/$/, "");
   const ctxFactory = options.execContextFactory ?? (() => ({ ...DEFAULT_CTX }));
-  const server = createServer(async (req, res) => {
-    const url = req.url ?? "/";
-    const path = url.split("?")[0] ?? "/";
-    const norm = basePath ? path === basePath ? "" : path.replace(basePath, "") || "/" : path;
-    try {
-      if (req.method === "GET" && (norm === "/" || norm === "/swagger")) {
-        const specPath = basePath ? `${basePath}/openapi.json` : "/openapi.json";
-        const html = swaggerUiHtml(specPath);
-        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-        res.end(html);
-        return;
-      }
-      if (req.method === "GET" && (norm === "/openapi.json" || norm === "/spec")) {
-        const spec = toolsToOpenAPISpec(runtime.getRegistry(), {
-          title: "Tool API",
-          version: "1.0.0",
-          basePath: basePath || void 0
-        });
-        sendJson(res, 200, spec);
-        return;
-      }
-      if (req.method === "GET" && norm === "/tools") {
-        const { enrichSpecWithCanonicalSchema: enrichSpecWithCanonicalSchema2 } = await import('./canonicalCoreSchemas-PHGTNPN5.js');
-        const specs = runtime.getRegistry().snapshot().map(enrichSpecWithCanonicalSchema2);
-        const tools = specs.map((s) => ({
-          name: s.name,
-          description: s.description,
-          kind: s.kind,
-          inputSchema: s.inputSchema
-        }));
-        sendJson(res, 200, { tools });
-        return;
-      }
-      if (req.method === "POST" && norm === "/invoke") {
-        let body;
-        try {
-          body = await parseBody(req);
-        } catch (err) {
-          const hint = err instanceof BodyParseError ? err.hint : void 0;
-          sendJson(res, 400, {
-            ok: false,
-            error: "Invalid JSON body",
-            kind: "BAD_REQUEST",
-            ...hint ? { hint } : {}
-          });
-          return;
-        }
-        const tool = body?.tool;
-        const args = body?.args ?? {};
-        if (typeof tool !== "string" || !tool.trim()) {
-          sendJson(res, 400, { error: "Missing or invalid 'tool' in body", kind: "BAD_REQUEST" });
-          return;
-        }
-        const ctx = ctxFactory(req);
-        const result = await runtime.invoke(
-          { tool: tool.trim(), args, purpose: "openapi" },
-          ctx
-        );
-        if (result.ok) {
-          sendJson(res, 200, { result: result.result });
-          return;
-        }
-        sendJson(res, 400, {
-          error: result.error?.message ?? "Tool failed",
-          kind: result.error?.kind,
-          details: result.error?.details
-        });
-        return;
-      }
-      if (req.method === "POST" && norm.startsWith("/invoke/") && norm.length > "/invoke/".length) {
-        const slug = norm.slice("/invoke/".length);
-        const toolName = slugToToolName(slug);
-        let args;
-        let hint;
-        try {
-          args = await parseBody(req);
-        } catch (err) {
-          hint = err instanceof BodyParseError ? err.hint : void 0;
-          sendJson(res, 400, {
-            ok: false,
-            error: "Invalid JSON body",
-            kind: "BAD_REQUEST",
-            ...hint ? { hint } : {}
-          });
-          return;
-        }
-        const ctx = ctxFactory(req);
-        const result = await runtime.invoke(
-          { tool: toolName, args: args ?? {}, purpose: "openapi" },
-          ctx
-        );
-        if (result.ok) {
-          sendJson(res, 200, { result: result.result });
-          return;
-        }
-        sendJson(res, 400, {
-          error: result.error?.message ?? "Tool failed",
-          kind: result.error?.kind,
-          details: result.error?.details
-        });
-        return;
-      }
-      res.writeHead(404, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Not found", path: norm }));
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      sendJson(res, 500, { error: message, kind: "INTERNAL_ERROR" });
-    }
-  });
+  const server = createServer(
+    (req, res) => handleOpenApiHttpRequest({ runtime, req, res, basePath, ctxFactory })
+  );
   return server;
 }
+async function handleOpenApiHttpRequest(input) {
+  const norm = normalizePath(input.req.url, input.basePath);
+  try {
+    if (await maybeHandleDocsRoute(input, norm)) return;
+    if (await maybeHandleToolsRoute(input, norm)) return;
+    if (await maybeHandleInvokeRoute(input, norm)) return;
+    sendJson(input.res, 404, { error: "Not found", path: norm });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    sendJson(input.res, 500, { error: message, kind: "INTERNAL_ERROR" });
+  }
+}
+function normalizePath(url, basePath) {
+  const path = (url ?? "/").split("?")[0] ?? "/";
+  return basePath ? path === basePath ? "" : path.replace(basePath, "") || "/" : path;
+}
+async function maybeHandleDocsRoute(input, norm) {
+  if (input.req.method === "GET" && (norm === "/" || norm === "/swagger")) {
+    const specPath = input.basePath ? `${input.basePath}/openapi.json` : "/openapi.json";
+    input.res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    input.res.end(swaggerUiHtml(specPath));
+    return true;
+  }
+  if (input.req.method === "GET" && (norm === "/openapi.json" || norm === "/spec")) {
+    sendJson(
+      input.res,
+      200,
+      toolsToOpenAPISpec(input.runtime.getRegistry(), {
+        title: "Tool API",
+        version: "1.0.0",
+        basePath: input.basePath || void 0
+      })
+    );
+    return true;
+  }
+  return false;
+}
+async function maybeHandleToolsRoute(input, norm) {
+  if (input.req.method !== "GET" || norm !== "/tools") return false;
+  const { enrichSpecWithCanonicalSchema: enrichSpecWithCanonicalSchema2 } = await import('./canonicalCoreSchemas-PHGTNPN5.js');
+  const tools = input.runtime.getRegistry().snapshot().map(enrichSpecWithCanonicalSchema2).map((s) => ({
+    name: s.name,
+    description: s.description,
+    kind: s.kind,
+    inputSchema: s.inputSchema
+  }));
+  sendJson(input.res, 200, { tools });
+  return true;
+}
+async function maybeHandleInvokeRoute(input, norm) {
+  if (input.req.method !== "POST") return false;
+  if (norm === "/invoke") {
+    const body = await parseBodyOrSendError(input.req, input.res);
+    if (!body) return true;
+    const tool = body.tool;
+    if (typeof tool !== "string" || !tool.trim()) {
+      sendJson(input.res, 400, { error: "Missing or invalid 'tool' in body", kind: "BAD_REQUEST" });
+      return true;
+    }
+    await invokeAndSend(input.runtime, input.ctxFactory(input.req), input.res, tool.trim(), body.args ?? {});
+    return true;
+  }
+  if (norm.startsWith("/invoke/") && norm.length > "/invoke/".length) {
+    const args = await parseArgsOrSendError(input.req, input.res);
+    if (args === void 0) return true;
+    await invokeAndSend(input.runtime, input.ctxFactory(input.req), input.res, slugToToolName(norm.slice(8)), args);
+    return true;
+  }
+  return false;
+}
+async function parseBodyOrSendError(req, res) {
+  try {
+    return await parseBody(req);
+  } catch (err) {
+    sendBadJsonBody(res, err);
+    return null;
+  }
+}
+async function parseArgsOrSendError(req, res) {
+  try {
+    return await parseBody(req) ?? {};
+  } catch (err) {
+    sendBadJsonBody(res, err);
+    return void 0;
+  }
+}
+function sendBadJsonBody(res, err) {
+  const hint = err instanceof BodyParseError ? err.hint : void 0;
+  sendJson(res, 400, {
+    ok: false,
+    error: "Invalid JSON body",
+    kind: "BAD_REQUEST",
+    ...hint ? { hint } : {}
+  });
+}
+async function invokeAndSend(runtime, ctx, res, tool, args) {
+  const result = await runtime.invoke({ tool, args, purpose: "openapi" }, ctx);
+  if (result.ok) {
+    sendJson(res, 200, { result: result.result });
+    return;
+  }
+  sendJson(res, 400, {
+    error: result.error?.message ?? "Tool failed",
+    kind: result.error?.kind,
+    details: result.error?.details
+  });
+}
 function listenOpenAPIHttpServer(server, options = {}) {
   return new Promise((resolve4, reject) => {
     const port = options.port ?? 0;
@@ -2713,5 +2706,5 @@ async function runMCPServerOverStdio(runtime, options = {}) {
 }
 
 export { PTCRuntime, createHttpService, createMCPServer, createMCPServerStreamableHttp, createMCPStreamableHttpHandler, createRuntimeFromConfig, createRuntimeFromConfigSync, expandToolDescriptorsToRegistryNames, fileDescriptorToPackagePrefix, findAndLoadToolConfig, getDisplayScope, isBarePackageDescriptor, loadToolConfig, npmDescriptorToPackagePrefixWithVersion, resolveSandboxedPath, resolveToolDescriptor, runMCPServerOverStdio };
-//# sourceMappingURL=chunk-VSFIF3WJ.js.map
-//# sourceMappingURL=chunk-VSFIF3WJ.js.map
+//# sourceMappingURL=chunk-EHXA64OA.js.map
+//# sourceMappingURL=chunk-EHXA64OA.js.map