opentool 0.6.4 → 0.7.0

package/README.md

@@ -113,6 +113,37 @@ npx mcp-inspector --config inspector.json --server opentool-dev
 
 Copy `.env.example` to `.env` and add your credentials if you're using wallet/payment features. The inspector starts `opentool dev` automatically, so you only need one terminal. Only tools with `mcp = { enabled: true }` show up in the inspector - HTTP-only tools keep running on localhost.
 
+### Quick x402 test with curl
+
+1. Start the dev server against the example tools:
+
+   ```bash
+   npx opentool dev --input examples/full-metadata/tools
+   ```
+
+2. Trigger the paywall and inspect the returned payment requirements:
+
+   ```bash
+   curl -i \
+     -X POST http://localhost:7000/premium-report \
+     -H "content-type: application/json" \
+     -d '{"symbol":"BTC"}'
+   ```
+
+   The response includes a `402 Payment Required` status and JSON body with an `x402.accepts[0]` object describing the payment request.
+
+3. Submit a follow-up request with an `X-PAYMENT` header produced by your x402 facilitator (for example, by using the Coinbase [x402](https://github.com/coinbase/x402) tooling or your own signing flow):
+
+   ```bash
+   curl -i \
+     -X POST http://localhost:7000/premium-report \
+     -H "content-type: application/json" \
+     -H "X-PAYMENT: ${X402_HEADER}" \
+     -d '{"symbol":"BTC"}'
+   ```
+
+   Replace `${X402_HEADER}` with the base64-encoded payment payload returned by your facilitator’s `/verify` or `/pay` workflow. If the payment is valid the server responds with `200 OK`; otherwise it returns a new `402` with failure details.
+
 ### 5. Build for deployment
 
 ```bash

package/dist/cli/index.d.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { h as Metadata, I as InternalToolDefinition } from '../validate-BLlooEBK.js';
-export { G as GenerateMetadataOptions, i as GenerateMetadataResult, V as ValidateOptions, g as generateMetadata, a as generateMetadataCommand, l as loadAndValidateTools, v as validateCommand, j as validateFullCommand } from '../validate-BLlooEBK.js';
+import { h as Metadata, I as InternalToolDefinition } from '../validate-CqB2Juma.js';
+export { G as GenerateMetadataOptions, i as GenerateMetadataResult, V as ValidateOptions, g as generateMetadata, a as generateMetadataCommand, l as loadAndValidateTools, v as validateCommand, j as validateFullCommand } from '../validate-CqB2Juma.js';
 import 'zod';
-import '../index-D3DaM5Rs.js';
+import '../index-D_bCF2Bf.js';
 
 interface BuildOptions {
     input: string;
@@ -15,6 +15,7 @@ interface BuildArtifacts {
     defaultsApplied: string[];
     tools: InternalToolDefinition[];
     compiledTools: CompiledToolArtifact[];
+    workflowBundles: WorkflowBundleArtifact | null;
 }
 interface CompiledToolArtifact {
     name: string;
@@ -25,6 +26,15 @@ interface CompiledToolArtifact {
     defaultMcpMethod?: string;
     hasWallet: boolean;
 }
+interface WorkflowBundleArtifact {
+    sourceDir: string;
+    outputDir: string;
+    stepsBundlePath: string;
+    workflowsBundlePath: string;
+    webhookBundlePath: string;
+    clientBundlePath?: string;
+    manifestPath?: string;
+}
 declare function buildCommand(options: BuildOptions): Promise<void>;
 declare function buildProject(options: BuildOptions): Promise<BuildArtifacts>;
 

package/dist/cli/index.js

@@ -7,7 +7,7 @@ import { build } from 'esbuild';
 import { z } from 'zod';
 import { createRequire } from 'module';
 import { fileURLToPath, pathToFileURL } from 'url';
-import { zodToJsonSchema } from 'zod-to-json-schema';
+import { zodToJsonSchema } from '@alcyone-labs/zod-to-json-schema';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
@@ -95,7 +95,7 @@ var PaymentConfigSchema = z.object({
   plain402: z.boolean().optional(),
   acceptedMethods: z.array(z.union([z.literal("x402"), z.literal("402")])).optional(),
   acceptedCurrencies: z.array(z.string()).optional(),
-  chainIds: z.array(z.number().int()).optional(),
+  chains: z.array(z.union([z.string(), z.number()])).optional(),
   facilitator: z.string().optional()
 }).strict();
 var DiscoveryMetadataSchema = z.object({
@@ -103,9 +103,9 @@ var DiscoveryMetadataSchema = z.object({
   category: z.string().optional(),
   useCases: z.array(z.string()).optional(),
   capabilities: z.array(z.string()).optional(),
-  requirements: z.record(z.any()).optional(),
-  pricing: z.record(z.any()).optional(),
-  compatibility: z.record(z.any()).optional(),
+  requirements: z.record(z.string(), z.any()).optional(),
+  pricing: z.record(z.string(), z.any()).optional(),
+  compatibility: z.record(z.string(), z.any()).optional(),
   documentation: z.union([z.string(), z.array(z.string())]).optional()
 }).catchall(z.any());
 var ToolMetadataOverridesSchema = z.object({
@@ -148,9 +148,9 @@ var AuthoredMetadataSchema = z.object({
   keywords: z.array(z.string()).optional(),
   useCases: z.array(z.string()).optional(),
   capabilities: z.array(z.string()).optional(),
-  requirements: z.record(z.any()).optional(),
-  pricing: z.record(z.any()).optional(),
-  compatibility: z.record(z.any()).optional(),
+  requirements: z.record(z.string(), z.any()).optional(),
+  pricing: z.record(z.string(), z.any()).optional(),
+  compatibility: z.record(z.string(), z.any()).optional(),
   chains: z.array(z.union([z.string(), z.number()])).optional()
 }).catchall(z.any());
 var MetadataSchema = z.object({
@@ -409,7 +409,7 @@ function resolvePayment(authored, defaults) {
     plain402: acceptedMethods.includes("402"),
     acceptedMethods,
     acceptedCurrencies: Array.isArray(pricing.acceptedCurrencies) ? pricing.acceptedCurrencies : ["USDC"],
-    chainIds: Array.isArray(pricing.chainIds) ? pricing.chainIds : [8453]
+    chains: Array.isArray(pricing.chains) ? pricing.chains : [8453]
   };
 }
 function buildDiscovery(authored) {
@@ -1667,6 +1667,10 @@ async function buildProject(options) {
     projectRoot,
     outputDir
   });
+  const workflowBundles = await buildWorkflowsIfPresent({
+    projectRoot,
+    outputDir
+  });
   const shouldBuildMcpServer = compiledTools.some((artifact) => artifact.mcpEnabled);
   if (shouldBuildMcpServer) {
     await writeMcpServer({
@@ -1684,7 +1688,8 @@ async function buildProject(options) {
     metadata,
     defaultsApplied,
     tools,
-    compiledTools
+    compiledTools,
+    workflowBundles
   };
 }
 async function emitTools(tools, config) {
@@ -1843,6 +1848,18 @@ function logBuildSummary(artifacts, options) {
     console.log(`     - ${tool.name} [${methods}]${walletBadge}`);
   });
   console.log("  \u2022 metadata.json (registry artifact)");
+  if (artifacts.workflowBundles) {
+    console.log("  \u2022 .well-known/workflow/v1/ (workflow bundles)");
+    console.log("     - flow.js");
+    console.log("     - step.js");
+    console.log("     - webhook.js");
+    if (artifacts.workflowBundles.clientBundlePath) {
+      console.log("     - client.js");
+    }
+    if (artifacts.workflowBundles.manifestPath) {
+      console.log("     - manifest.json");
+    }
+  }
   if (artifacts.defaultsApplied.length > 0) {
     console.log("\nDefaults applied during metadata synthesis:");
     artifacts.defaultsApplied.forEach((entry) => console.log(`  \u2022 ${entry}`));
@@ -1851,6 +1868,155 @@ function logBuildSummary(artifacts, options) {
     console.log("\n\u2139\uFE0F MCP adapter skipped (no tools opted in)");
   }
 }
+async function buildWorkflowsIfPresent(options) {
+  const workflowsDir = options.workflowsDir ?? path5.join(options.projectRoot, "workflows");
+  if (!fs4.existsSync(workflowsDir)) {
+    return null;
+  }
+  if (!hasWorkflowSourceFiles(workflowsDir)) {
+    return null;
+  }
+  const nodeVersion = process.versions?.node ?? "0.0.0";
+  const nodeMajor = Number(nodeVersion.split(".")[0] ?? 0);
+  if (!Number.isFinite(nodeMajor) || nodeMajor < 22) {
+    console.warn(
+      `[${timestamp()}] Workflow bundles skipped (requires Node >= 22, current ${nodeVersion})`
+    );
+    return null;
+  }
+  const { BaseBuilder } = await import('@workflow/cli/dist/lib/builders/base-builder.js');
+  class OpenToolWorkflowBuilder extends BaseBuilder {
+    async build() {
+      const inputFiles = await this.getInputFiles();
+      const tsConfig = await this.getTsConfigOptions();
+      const shared = {
+        inputFiles,
+        ...tsConfig.baseUrl ? { tsBaseUrl: tsConfig.baseUrl } : {},
+        ...tsConfig.paths ? { tsPaths: tsConfig.paths } : {}
+      };
+      await this.buildStepsBundle(shared);
+      await this.buildWorkflowsBundle(shared);
+      await this.buildWebhookRoute();
+      await this.buildClientLibrary();
+    }
+    async buildStepsBundle(options2) {
+      console.log(
+        "Creating OpenTool workflow steps bundle at",
+        this.config.stepsBundlePath
+      );
+      const stepsBundlePath2 = path5.resolve(
+        this.config.workingDir,
+        this.config.stepsBundlePath
+      );
+      await fs4.promises.mkdir(path5.dirname(stepsBundlePath2), { recursive: true });
+      await this.createStepsBundle({
+        outfile: stepsBundlePath2,
+        ...options2
+      });
+    }
+    async buildWorkflowsBundle(options2) {
+      console.log(
+        "Creating OpenTool workflow bundle at",
+        this.config.workflowsBundlePath
+      );
+      const workflowBundlePath = path5.resolve(
+        this.config.workingDir,
+        this.config.workflowsBundlePath
+      );
+      await fs4.promises.mkdir(path5.dirname(workflowBundlePath), {
+        recursive: true
+      });
+      await this.createWorkflowsBundle({
+        outfile: workflowBundlePath,
+        bundleFinalOutput: false,
+        ...options2
+      });
+    }
+    async buildWebhookRoute() {
+      console.log(
+        "Creating OpenTool workflow webhook bundle at",
+        this.config.webhookBundlePath
+      );
+      const webhookBundlePath2 = path5.resolve(
+        this.config.workingDir,
+        this.config.webhookBundlePath
+      );
+      await fs4.promises.mkdir(path5.dirname(webhookBundlePath2), {
+        recursive: true
+      });
+      await this.createWebhookBundle({ outfile: webhookBundlePath2 });
+    }
+  }
+  const relativeSourceDir = path5.relative(options.projectRoot, workflowsDir) || ".";
+  const outputBase = path5.join(
+    options.outputDir,
+    ".well-known",
+    "workflow",
+    "v1"
+  );
+  const stepsBundlePath = path5.join(outputBase, "step.js");
+  const workflowsBundlePath = path5.join(outputBase, "flow.js");
+  const webhookBundlePath = path5.join(outputBase, "webhook.js");
+  const manifestPath = path5.join(outputBase, "manifest.json");
+  const builder = new OpenToolWorkflowBuilder({
+    workingDir: options.projectRoot,
+    dirs: [relativeSourceDir],
+    buildTarget: "standalone",
+    stepsBundlePath,
+    workflowsBundlePath,
+    webhookBundlePath,
+    ...{},
+    workflowManifestPath: manifestPath,
+    externalPackages: [
+      "workflow",
+      "workflow/internal/builtins",
+      "workflow/internal/private",
+      "workflow/runtime",
+      "workflow/api"
+    ]
+  });
+  console.log(
+    `[${timestamp()}] Building workflows from ${workflowsDir} -> ${outputBase}`
+  );
+  await builder.build();
+  return {
+    sourceDir: workflowsDir,
+    outputDir: outputBase,
+    stepsBundlePath,
+    workflowsBundlePath,
+    webhookBundlePath,
+    ...{},
+    manifestPath
+  };
+}
+function hasWorkflowSourceFiles(directory) {
+  const entries = fs4.readdirSync(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (hasWorkflowSourceFiles(path5.join(directory, entry.name))) {
+        return true;
+      }
+      continue;
+    }
+    if (entry.isFile()) {
+      const extension = path5.extname(entry.name).toLowerCase();
+      if (WORKFLOW_SOURCE_EXTENSIONS.has(extension)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var WORKFLOW_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts"
+]);
 function timestamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
 }