opentool 0.6.3 → 0.6.5

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,6 +1,6 @@
 #!/usr/bin/env node
-import { h as Metadata, I as InternalToolDefinition } from '../validate-DiIOFUU5.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-DiIOFUU5.js';
+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 'zod';
 import '../index-D3DaM5Rs.js';
 
@@ -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

@@ -79,7 +79,7 @@ async function transpileWithEsbuild(options) {
   };
   return { outDir: tempBase, cleanup };
 }
-var METADATA_SPEC_VERSION = "1.0.0";
+var METADATA_SPEC_VERSION = "1.1.0";
 var McpAnnotationsSchema = z.object({
   title: z.string().optional(),
   readOnlyHint: z.boolean().optional(),
@@ -113,7 +113,8 @@ var ToolMetadataOverridesSchema = z.object({
   description: z.string().optional(),
   annotations: McpAnnotationsSchema.optional(),
   payment: PaymentConfigSchema.optional(),
-  discovery: DiscoveryMetadataSchema.optional()
+  discovery: DiscoveryMetadataSchema.optional(),
+  chains: z.array(z.union([z.string(), z.number()])).optional()
 }).catchall(z.any());
 var ToolSchema = z.object({
   name: z.string(),
@@ -121,7 +122,8 @@ var ToolSchema = z.object({
   inputSchema: z.any(),
   annotations: McpAnnotationsSchema.optional(),
   payment: PaymentConfigSchema.optional(),
-  discovery: DiscoveryMetadataSchema.optional()
+  discovery: DiscoveryMetadataSchema.optional(),
+  chains: z.array(z.union([z.string(), z.number()])).optional()
 }).strict();
 var AuthoredMetadataSchema = z.object({
   metadataSpecVersion: z.string().optional(),
@@ -148,7 +150,8 @@ var AuthoredMetadataSchema = z.object({
   capabilities: z.array(z.string()).optional(),
   requirements: z.record(z.any()).optional(),
   pricing: z.record(z.any()).optional(),
-  compatibility: z.record(z.any()).optional()
+  compatibility: z.record(z.any()).optional(),
+  chains: z.array(z.union([z.string(), z.number()])).optional()
 }).catchall(z.any());
 var MetadataSchema = z.object({
   metadataSpecVersion: z.string().default(METADATA_SPEC_VERSION),
@@ -169,7 +172,8 @@ var MetadataSchema = z.object({
   iconPath: z.string().optional(),
   videoPath: z.string().optional(),
   image: z.string().optional(),
-  animation_url: z.string().optional()
+  animation_url: z.string().optional(),
+  chains: z.array(z.union([z.string(), z.number()])).optional()
 }).strict();
 createRequire(import.meta.url);
 function resolveCompiledPath(outDir, originalFile, extension = ".js") {
@@ -305,6 +309,7 @@ async function buildMetadataArtifact(options) {
       defaultsApplied.push(`tool ${toolName} payment \u2192 agent payment`);
     }
     const toolDiscovery = overrides.discovery ?? void 0;
+    const toolChains = overrides.chains ?? authored.chains ?? void 0;
     const toolDefinition = {
       name: toolName,
       description: toolDescription,
@@ -319,6 +324,9 @@ async function buildMetadataArtifact(options) {
     if (toolDiscovery) {
       toolDefinition.discovery = toolDiscovery;
     }
+    if (toolChains) {
+      toolDefinition.chains = toolChains;
+    }
     return toolDefinition;
   });
   const metadata = MetadataSchema.parse({
@@ -340,7 +348,8 @@ async function buildMetadataArtifact(options) {
     iconPath: authored.iconPath,
     videoPath: authored.videoPath,
     image: baseImage,
-    animation_url: animation
+    animation_url: animation,
+    chains: authored.chains
   });
   return {
     metadata,
@@ -1658,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({
@@ -1675,7 +1688,8 @@ async function buildProject(options) {
     metadata,
     defaultsApplied,
     tools,
-    compiledTools
+    compiledTools,
+    workflowBundles
   };
 }
 async function emitTools(tools, config) {
@@ -1834,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}`));
@@ -1842,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);
 }