opentool 0.4.6 → 0.6.0

package/dist/cli/index.js

@@ -1,70 +1,2221 @@
 #!/usr/bin/env node
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+import { program } from 'commander';
+import * as fs4 from 'fs';
+import * as path5 from 'path';
+import { tmpdir } from 'os';
+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 { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import * as http from 'http';
+
+function resolveTsconfig(projectRoot) {
+  const candidate = path5.join(projectRoot, "tsconfig.json");
+  if (fs4.existsSync(candidate)) {
+    return candidate;
+  }
+  return void 0;
+}
+async function transpileWithEsbuild(options) {
+  if (options.entryPoints.length === 0) {
+    throw new Error("No entry points provided for esbuild transpilation");
+  }
+  const projectRoot = options.projectRoot;
+  const tempBase = options.outDir ?? fs4.mkdtempSync(path5.join(tmpdir(), "opentool-"));
+  if (!fs4.existsSync(tempBase)) {
+    fs4.mkdirSync(tempBase, { recursive: true });
+  }
+  const tsconfig = resolveTsconfig(projectRoot);
+  const buildOptions = {
+    entryPoints: options.entryPoints,
+    outdir: tempBase,
+    bundle: false,
+    format: options.format,
+    platform: "node",
+    target: "node20",
+    logLevel: "warning",
+    sourcesContent: false,
+    sourcemap: false,
+    packages: "external",
+    loader: {
+      ".ts": "ts",
+      ".tsx": "tsx",
+      ".cts": "ts",
+      ".mts": "ts",
+      ".js": "js",
+      ".jsx": "jsx",
+      ".mjs": "js",
+      ".cjs": "js"
+    },
+    metafile: false,
+    allowOverwrite: true,
+    absWorkingDir: projectRoot
+  };
+  if (tsconfig) {
+    buildOptions.tsconfig = tsconfig;
+  }
+  await build(buildOptions);
+  if (options.format === "esm") {
+    const packageJsonPath = path5.join(tempBase, "package.json");
+    if (!fs4.existsSync(packageJsonPath)) {
+      fs4.writeFileSync(packageJsonPath, JSON.stringify({ type: "module" }), "utf8");
+    }
+  }
+  const cleanup = () => {
+    if (options.outDir) {
+      return;
+    }
+    fs4.rmSync(tempBase, { recursive: true, force: true });
+  };
+  return { outDir: tempBase, cleanup };
+}
+var METADATA_SPEC_VERSION = "1.0.0";
+var McpAnnotationsSchema = z.object({
+  title: z.string().optional(),
+  readOnlyHint: z.boolean().optional(),
+  destructiveHint: z.boolean().optional(),
+  idempotentHint: z.boolean().optional(),
+  openWorldHint: z.boolean().optional(),
+  requiresPayment: z.boolean().optional()
+}).strict();
+var PaymentConfigSchema = z.object({
+  amountUSDC: z.number().nonnegative().optional(),
+  description: z.string().optional(),
+  x402: z.boolean().optional(),
+  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(),
+  facilitator: z.string().optional()
+}).strict();
+var DiscoveryMetadataSchema = z.object({
+  keywords: z.array(z.string()).optional(),
+  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(),
+  documentation: z.union([z.string(), z.array(z.string())]).optional()
+}).catchall(z.any());
+var ToolMetadataOverridesSchema = z.object({
+  name: z.string().optional(),
+  description: z.string().optional(),
+  annotations: McpAnnotationsSchema.optional(),
+  payment: PaymentConfigSchema.optional(),
+  discovery: DiscoveryMetadataSchema.optional()
+}).catchall(z.any());
+var ToolSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  inputSchema: z.any(),
+  annotations: McpAnnotationsSchema.optional(),
+  payment: PaymentConfigSchema.optional(),
+  discovery: DiscoveryMetadataSchema.optional()
+}).strict();
+var AuthoredMetadataSchema = z.object({
+  metadataSpecVersion: z.string().optional(),
+  name: z.string().optional(),
+  displayName: z.string().optional(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  author: z.string().optional(),
+  repository: z.string().optional(),
+  website: z.string().optional(),
+  category: z.string().optional(),
+  categories: z.array(z.string()).optional(),
+  termsOfService: z.string().optional(),
+  mcpUrl: z.string().optional(),
+  payment: PaymentConfigSchema.optional(),
+  discovery: DiscoveryMetadataSchema.optional(),
+  promptExamples: z.array(z.string()).optional(),
+  iconPath: z.string().optional(),
+  videoPath: z.string().optional(),
+  image: z.string().optional(),
+  animation_url: z.string().optional(),
+  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()
+}).catchall(z.any());
+var MetadataSchema = z.object({
+  metadataSpecVersion: z.string().default(METADATA_SPEC_VERSION),
+  name: z.string(),
+  displayName: z.string(),
+  version: z.string(),
+  description: z.string().optional(),
+  author: z.string().optional(),
+  repository: z.string().optional(),
+  website: z.string().optional(),
+  category: z.string(),
+  termsOfService: z.string().optional(),
+  mcpUrl: z.string().optional(),
+  payment: PaymentConfigSchema.optional(),
+  tools: z.array(ToolSchema).min(1),
+  discovery: DiscoveryMetadataSchema.optional(),
+  promptExamples: z.array(z.string()).optional(),
+  iconPath: z.string().optional(),
+  videoPath: z.string().optional(),
+  image: z.string().optional(),
+  animation_url: z.string().optional()
+}).strict();
+createRequire(import.meta.url);
+function resolveCompiledPath(outDir, originalFile, extension = ".js") {
+  const baseName = path5.basename(originalFile).replace(/\.[^.]+$/, "");
+  return path5.join(outDir, `${baseName}${extension}`);
+}
+async function importFresh(modulePath) {
+  const fileUrl = pathToFileURL(modulePath).href;
+  const cacheBuster = `t=${Date.now()}-${Math.random()}`;
+  const separator = fileUrl.includes("?") ? "&" : "?";
+  return import(`${fileUrl}${separator}${cacheBuster}`);
+}
+
+// src/cli/shared/metadata.ts
+var METADATA_ENTRY = "metadata.ts";
+async function loadAuthoredMetadata(projectRoot) {
+  const absPath = path5.join(projectRoot, METADATA_ENTRY);
+  if (!fs4.existsSync(absPath)) {
+    throw new Error(
+      `metadata.ts not found in ${projectRoot}. Create metadata.ts to describe your agent.`
+    );
+  }
+  const tempDir = path5.join(projectRoot, ".opentool-temp");
+  if (fs4.existsSync(tempDir)) {
+    fs4.rmSync(tempDir, { recursive: true, force: true });
+  }
+  const { outDir, cleanup } = await transpileWithEsbuild({
+    entryPoints: [absPath],
+    projectRoot,
+    format: "esm",
+    outDir: tempDir
+  });
+  try {
+    const compiledPath = resolveCompiledPath(outDir, METADATA_ENTRY);
+    const moduleExports = await importFresh(compiledPath);
+    const metadataExport = extractMetadataExport(moduleExports);
+    const parsed = AuthoredMetadataSchema.parse(metadataExport);
+    return { metadata: parsed, sourcePath: absPath };
+  } finally {
+    cleanup();
+    if (fs4.existsSync(tempDir)) {
+      fs4.rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+}
+function extractMetadataExport(moduleExports) {
+  if (!moduleExports || typeof moduleExports !== "object") {
+    throw new Error("metadata.ts must export a metadata object");
+  }
+  const exportsObject = moduleExports;
+  if (exportsObject.metadata) {
+    return exportsObject.metadata;
+  }
+  if (exportsObject.default && typeof exportsObject.default === "object") {
+    const defaultExport = exportsObject.default;
+    if (defaultExport.metadata) {
+      return defaultExport.metadata;
+    }
+    return defaultExport;
+  }
+  return moduleExports;
+}
+function readPackageJson(projectRoot) {
+  const packagePath = path5.join(projectRoot, "package.json");
+  if (!fs4.existsSync(packagePath)) {
+    return {};
+  }
+  try {
+    const content = fs4.readFileSync(packagePath, "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to read package.json: ${error}`);
+  }
+}
+async function buildMetadataArtifact(options) {
+  const projectRoot = options.projectRoot;
+  const packageInfo = readPackageJson(projectRoot);
+  const { metadata: authored, sourcePath } = await loadAuthoredMetadata(projectRoot);
+  const defaultsApplied = [];
+  const folderName = path5.basename(projectRoot);
+  const name = resolveField(
+    "name",
+    authored.name,
+    () => packageInfo.name ?? folderName,
+    defaultsApplied,
+    "package.json name"
+  );
+  const displayName = resolveField(
+    "displayName",
+    authored.displayName,
+    () => {
+      const source = packageInfo.name ?? folderName;
+      return source.split(/[-_]/).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
+    },
+    defaultsApplied,
+    "package.json name"
+  );
+  const versionRaw = resolveField(
+    "version",
+    authored.version,
+    () => packageInfo.version ?? "0.1.0",
+    defaultsApplied,
+    "package.json version"
+  );
+  const version = typeof versionRaw === "number" ? String(versionRaw) : versionRaw;
+  const category = determineCategory(authored, defaultsApplied);
+  const description = authored.description ?? packageInfo.description;
+  if (!authored.description && packageInfo.description) {
+    defaultsApplied.push("description \u2192 package.json description");
+  }
+  const author = authored.author ?? packageInfo.author;
+  if (!authored.author && packageInfo.author) {
+    defaultsApplied.push("author \u2192 package.json author");
+  }
+  const repository = authored.repository ?? extractRepository(packageInfo.repository);
+  if (!authored.repository && repository) {
+    defaultsApplied.push("repository \u2192 package.json repository");
+  }
+  const website = authored.website ?? packageInfo.homepage;
+  if (!authored.website && packageInfo.homepage) {
+    defaultsApplied.push("website \u2192 package.json homepage");
+  }
+  const payment = resolvePayment(authored, defaultsApplied);
+  const baseImage = authored.image ?? authored.iconPath;
+  const animation = authored.animation_url ?? authored.videoPath;
+  const discovery = buildDiscovery(authored);
+  const metadataTools = options.tools.map((tool) => {
+    const overrides = tool.metadata ? ToolMetadataOverridesSchema.parse(tool.metadata) : {};
+    const toolName = overrides.name ?? tool.filename;
+    const toolDescription = overrides.description ?? `${toolName} tool`;
+    const toolPayment = overrides.payment ?? payment ?? void 0;
+    if (!overrides.payment && toolPayment && payment && toolPayment === payment) {
+      defaultsApplied.push(`tool ${toolName} payment \u2192 agent payment`);
+    }
+    const toolDiscovery = overrides.discovery ?? void 0;
+    const toolDefinition = {
+      name: toolName,
+      description: toolDescription,
+      inputSchema: tool.inputSchema
+    };
+    if (overrides.annotations) {
+      toolDefinition.annotations = overrides.annotations;
+    }
+    if (toolPayment) {
+      toolDefinition.payment = toolPayment;
+    }
+    if (toolDiscovery) {
+      toolDefinition.discovery = toolDiscovery;
+    }
+    return toolDefinition;
+  });
+  const metadata = MetadataSchema.parse({
+    metadataSpecVersion: authored.metadataSpecVersion ?? METADATA_SPEC_VERSION,
+    name,
+    displayName,
+    version,
+    description,
+    author,
+    repository,
+    website,
+    category,
+    termsOfService: authored.termsOfService,
+    mcpUrl: authored.mcpUrl,
+    payment: payment ?? void 0,
+    tools: metadataTools,
+    discovery,
+    promptExamples: authored.promptExamples,
+    iconPath: authored.iconPath,
+    videoPath: authored.videoPath,
+    image: baseImage,
+    animation_url: animation
+  });
+  return {
+    metadata,
+    defaultsApplied,
+    sourceMetadataPath: sourcePath
+  };
+}
+function resolveField(field, value, fallback, defaultsApplied, fallbackLabel) {
+  if (value !== void 0 && value !== null && value !== "") {
+    return value;
+  }
+  const resolved = fallback();
+  defaultsApplied.push(`${field} \u2192 ${fallbackLabel}`);
+  return resolved;
+}
+function determineCategory(authored, defaultsApplied) {
+  if (authored.category) {
+    return authored.category;
+  }
+  if (Array.isArray(authored.categories) && authored.categories.length > 0) {
+    defaultsApplied.push("category \u2192 metadata.categories[0]");
+    return authored.categories[0];
+  }
+  defaultsApplied.push("category \u2192 default category");
+  return "utility";
+}
+function extractRepository(repository) {
+  if (!repository) {
+    return void 0;
+  }
+  if (typeof repository === "string") {
+    return repository;
+  }
+  return repository.url;
+}
+function resolvePayment(authored, defaults) {
+  if (authored.payment) {
+    return authored.payment;
+  }
+  const discoveryPricing = authored.discovery?.pricing;
+  const legacyPricing = authored.pricing;
+  const pricing = discoveryPricing ?? legacyPricing;
+  if (!pricing) {
+    return void 0;
+  }
+  const amount = typeof pricing.defaultAmount === "number" ? pricing.defaultAmount : 0;
+  const sourceLabel = discoveryPricing ? "discovery.pricing.defaultAmount" : "pricing.defaultAmount";
+  defaults.push(`payment \u2192 synthesized from ${sourceLabel}`);
+  const acceptedMethodsRaw = Array.isArray(pricing.acceptedMethods) ? pricing.acceptedMethods : ["402"];
+  const acceptedMethods = acceptedMethodsRaw.map(
+    (method) => method === "x402" ? "x402" : "402"
+  );
+  return {
+    amountUSDC: amount,
+    description: typeof pricing.description === "string" ? pricing.description : void 0,
+    x402: acceptedMethods.includes("x402"),
+    plain402: acceptedMethods.includes("402"),
+    acceptedMethods,
+    acceptedCurrencies: Array.isArray(pricing.acceptedCurrencies) ? pricing.acceptedCurrencies : ["USDC"],
+    chainIds: Array.isArray(pricing.chainIds) ? pricing.chainIds : [8453]
+  };
+}
+function buildDiscovery(authored) {
+  const legacyDiscovery = {};
+  if (Array.isArray(authored.keywords) && authored.keywords.length > 0) {
+    legacyDiscovery.keywords = authored.keywords;
+  }
+  if (Array.isArray(authored.useCases) && authored.useCases.length > 0) {
+    legacyDiscovery.useCases = authored.useCases;
+  }
+  if (Array.isArray(authored.capabilities) && authored.capabilities.length > 0) {
+    legacyDiscovery.capabilities = authored.capabilities;
+  }
+  if (authored.requirements) {
+    legacyDiscovery.requirements = authored.requirements;
+  }
+  if (authored.compatibility) {
+    legacyDiscovery.compatibility = authored.compatibility;
+  }
+  if (Array.isArray(authored.categories) && authored.categories.length > 0) {
+    legacyDiscovery.category = authored.categories[0];
+  }
+  if (authored.pricing) {
+    legacyDiscovery.pricing = authored.pricing;
+  }
+  const merged = {
+    ...legacyDiscovery,
+    ...authored.discovery ?? {}
+  };
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+var PAYMENT_SCHEMA_VERSION = 1;
+var paymentSchemaVersionSchema = z.literal(PAYMENT_SCHEMA_VERSION);
+var decimalStringSchema = z.string().regex(/^(?:0|[1-9]\d*)(?:\.\d+)?$/, "Value must be a positive decimal string");
+var currencySchema = z.object({
+  code: z.string().min(2).max(12).transform((value) => value.toUpperCase()),
+  symbol: z.string().min(1).max(6).optional(),
+  decimals: z.number().int().min(0).max(36).optional(),
+  kind: z.enum(["fiat", "crypto"]).default("crypto").optional(),
+  description: z.string().optional()
+});
+var paymentAmountSchema = z.object({
+  value: decimalStringSchema,
+  currency: currencySchema,
+  display: z.string().optional()
+});
+var cryptoAssetSchema = z.object({
+  symbol: z.string().min(2).max(12),
+  network: z.string().min(1).optional(),
+  chainId: z.number().int().min(0).optional(),
+  address: z.string().min(1).optional(),
+  decimals: z.number().int().min(0).max(36).optional(),
+  standard: z.enum(["erc20", "spl", "custom"]).default("erc20").optional(),
+  description: z.string().optional()
+});
+var facilitatorConfigSchema = z.object({
+  url: z.string().url(),
+  vendor: z.string().optional(),
+  verifyPath: z.string().default("/verify").optional(),
+  settlePath: z.string().default("/settle").optional(),
+  apiKey: z.string().optional(),
+  apiKeyEnv: z.string().optional(),
+  apiKeyHeader: z.string().default("Authorization").optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  timeoutMs: z.number().int().positive().optional()
+});
+var settlementTermsSchema = z.object({
+  windowSeconds: z.number().int().positive().optional(),
+  targetConfirmations: z.number().int().positive().optional(),
+  finalityDescription: z.string().optional(),
+  slaDescription: z.string().optional()
+});
+var paymentFieldSchema = z.object({
+  key: z.string().min(1),
+  label: z.string().min(1),
+  required: z.boolean().default(true).optional(),
+  description: z.string().optional(),
+  example: z.string().optional()
+});
+var x402ProofSchema = z.object({
+  mode: z.literal("x402"),
+  scheme: z.string().min(1),
+  network: z.string().min(1),
+  version: z.number().int().min(1).optional(),
+  facilitator: facilitatorConfigSchema.optional(),
+  verifier: z.string().optional()
+});
+var directProofSchema = z.object({
+  mode: z.literal("direct"),
+  proofTypes: z.array(z.string().min(1)).nonempty(),
+  verifier: z.string().optional(),
+  instructions: z.string().optional(),
+  fields: z.array(paymentFieldSchema).optional(),
+  allowsManualReview: z.boolean().optional()
+});
+var paymentProofSchema = z.discriminatedUnion("mode", [
+  x402ProofSchema,
+  directProofSchema
+]);
+var paymentOptionSchema = z.object({
+  id: z.string().min(1),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  amount: paymentAmountSchema,
+  asset: cryptoAssetSchema,
+  payTo: z.string().min(1),
+  resource: z.string().url().optional(),
+  proof: paymentProofSchema,
+  settlement: settlementTermsSchema.optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var paymentRequirementsSchema = z.object({
+  schemaVersion: paymentSchemaVersionSchema,
+  message: z.string().optional(),
+  title: z.string().optional(),
+  resource: z.string().url().optional(),
+  accepts: z.array(paymentOptionSchema).nonempty(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  fallbackText: z.string().optional()
+});
+var x402PaymentHeaderSchema = z.object({
+  x402Version: z.number().int().min(1),
+  scheme: z.string().min(1),
+  network: z.string().min(1),
+  payload: z.unknown(),
+  correlationId: z.string().optional()
+});
+var directPaymentPayloadSchema = z.object({
+  schemaVersion: z.literal(1),
+  optionId: z.string().min(1),
+  proofType: z.string().min(1),
+  payload: z.unknown(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var paymentSuccessMetadataSchema = z.object({
+  optionId: z.string().min(1),
+  verifier: z.string().optional(),
+  txHash: z.string().optional(),
+  networkId: z.string().optional(),
+  amount: paymentAmountSchema.optional(),
+  settledAt: z.string().datetime().optional(),
+  payload: z.unknown().optional()
+});
+var paymentFailureSchema = z.object({
+  reason: z.string().min(1),
+  code: z.enum([
+    "verifier_not_found",
+    "verification_failed",
+    "invalid_payload",
+    "unsupported_option",
+    "missing_header",
+    "unknown"
+  ]).default("unknown").optional(),
+  retryable: z.boolean().optional(),
+  detail: z.unknown().optional()
+});
+
+// src/helpers/payment.ts
+var X402_VERSION_DEFAULT = 1;
+var HEADER_X402 = "X-PAYMENT";
+var HEADER_DIRECT = "X-PAYMENT-PROOF";
+var HEADER_PAYMENT_RESPONSE = "X-PAYMENT-RESPONSE";
+var x402RequirementSchema = z.object({
+  scheme: z.string().min(1),
+  network: z.string().min(1),
+  maxAmountRequired: z.string().min(1),
+  asset: z.string().min(1),
+  payTo: z.string().min(1),
+  resource: z.string().optional(),
+  description: z.string().optional(),
+  mimeType: z.string().optional(),
+  outputSchema: z.unknown().optional(),
+  maxTimeoutSeconds: z.number().int().positive().optional(),
+  extra: z.record(z.string(), z.unknown()).nullable().optional()
+});
+function createPaymentRequiredBody(definition) {
+  const parsed = paymentRequirementsSchema.parse(definition);
+  const x402Accepts = parsed.accepts.filter((option) => option.proof.mode === "x402").map(
+    (option) => toX402Requirement(option, parsed.resource, option.settlement)
+  ).filter((value) => Boolean(value));
+  const x402Body = x402Accepts.length > 0 ? {
+    x402Version: resolveX402Version(parsed.accepts),
+    error: parsed.message ?? "Payment required",
+    accepts: x402Accepts
+  } : void 0;
+  if (x402Body) {
+    return {
+      ...parsed,
+      x402: x402Body
+    };
+  }
+  return parsed;
+}
+function paymentRequiredResponse(definition, init) {
+  const body = createPaymentRequiredBody(definition);
+  const headers = new Headers(init?.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json; charset=utf-8");
+  }
+  return new Response(JSON.stringify(body), {
+    ...init,
+    status: 402,
+    headers
+  });
+}
+function extractPaymentAttempts(source) {
+  const attempts = [];
+  const failures = [];
+  const x402Header = source.headers.get(HEADER_X402);
+  if (x402Header) {
+    const { attempt, failure } = parseX402Header(x402Header);
+    if (attempt) {
+      attempts.push(attempt);
+    } else if (failure) {
+      failures.push(failure);
+    }
+  }
+  const directHeader = source.headers.get(HEADER_DIRECT);
+  if (directHeader) {
+    const { attempt, failure } = parseDirectHeader(directHeader);
+    if (attempt) {
+      attempts.push(attempt);
+    } else if (failure) {
+      failures.push(failure);
+    }
+  }
+  if (attempts.length === 0 && failures.length === 0) {
+    failures.push(
+      paymentFailureSchema.parse({
+        reason: "No payment headers present",
+        code: "missing_header",
+        retryable: false
+      })
+    );
+  }
+  return { attempts, failures };
+}
+async function verifyPayment(options) {
+  const definition = paymentRequirementsSchema.parse(options.definition);
+  const attempts = options.attempts ? options.attempts : options.request ? extractPaymentAttempts(options.request).attempts : [];
+  if (attempts.length === 0) {
+    return {
+      success: false,
+      optionId: "",
+      attemptType: "direct",
+      failure: paymentFailureSchema.parse({
+        reason: "No payment attempt found",
+        code: "missing_header",
+        retryable: false
+      })
+    };
+  }
+  for (const attempt of attempts) {
+    const option = findMatchingOption(definition, attempt);
+    if (!option) {
+      continue;
+    }
+    if (attempt.type === "x402") {
+      const proof = option.proof;
+      const verifierId = proof.verifier ?? (proof.facilitator ? "x402:facilitator" : void 0);
+      if (verifierId === "x402:facilitator" && proof.facilitator) {
+        const context2 = {
+          attempt,
+          option,
+          definition
+        };
+        if (options.settle !== void 0) {
+          context2.settle = options.settle;
+        }
+        return runFacilitatorVerifier({
+          ...context2,
+          fetchImpl: options.fetchImpl ?? fetch
+        });
+      }
+      const verifier = verifierId ? options.verifiers?.[verifierId] : void 0;
+      if (!verifier) {
+        return {
+          success: false,
+          optionId: option.id,
+          attemptType: attempt.type,
+          failure: paymentFailureSchema.parse({
+            reason: `No verifier registered for id: ${verifierId ?? "(missing)"}`,
+            code: "verifier_not_found",
+            retryable: false
+          })
+        };
+      }
+      const context = {
+        attempt,
+        option,
+        definition
+      };
+      if (options.settle !== void 0) {
+        context.settle = options.settle;
+      }
+      return verifier(context);
+    }
+    if (attempt.type === "direct") {
+      const proof = option.proof;
+      const verifierId = proof.verifier ?? `direct:${attempt.payload.proofType}`;
+      const verifier = verifierId ? options.verifiers?.[verifierId] : void 0;
+      if (!verifier) {
+        return {
+          success: false,
+          optionId: option.id,
+          attemptType: attempt.type,
+          failure: paymentFailureSchema.parse({
+            reason: `No verifier registered for id: ${verifierId}`,
+            code: "verifier_not_found",
+            retryable: false
+          })
+        };
+      }
+      const context = {
+        attempt,
+        option,
+        definition
+      };
+      if (options.settle !== void 0) {
+        context.settle = options.settle;
+      }
+      return verifier(context);
+    }
+  }
+  return {
+    success: false,
+    optionId: "",
+    attemptType: attempts[0]?.type ?? "direct",
+    failure: paymentFailureSchema.parse({
+      reason: "No matching payment option for attempt",
+      code: "unsupported_option",
+      retryable: false
+    })
+  };
+}
+function createPaymentResponseHeader(metadata) {
+  const parsed = paymentSuccessMetadataSchema.parse(metadata);
+  return encodeJson(parsed);
+}
+function parseX402Header(value) {
+  try {
+    const payload = decodeJson(value, x402PaymentHeaderSchema);
+    return {
+      attempt: {
+        type: "x402",
+        headerName: HEADER_X402,
+        raw: value,
+        payload
+      }
+    };
+  } catch (error) {
+    return {
+      failure: paymentFailureSchema.parse({
+        reason: `Invalid X-PAYMENT header: ${error.message}`,
+        code: "invalid_payload",
+        retryable: false
+      })
+    };
+  }
+}
+function parseDirectHeader(value) {
+  try {
+    const payload = decodeJson(value, directPaymentPayloadSchema);
+    return {
+      attempt: {
+        type: "direct",
+        headerName: HEADER_DIRECT,
+        raw: value,
+        payload
+      }
+    };
+  } catch (error) {
+    return {
+      failure: paymentFailureSchema.parse({
+        reason: `Invalid X-PAYMENT-PROOF header: ${error.message}`,
+        code: "invalid_payload",
+        retryable: false
+      })
+    };
+  }
+}
+function findMatchingOption(definition, attempt) {
+  return definition.accepts.find((candidate) => {
+    const option = paymentOptionSchema.parse(candidate);
+    if (attempt.type === "x402" && option.proof.mode === "x402") {
+      return option.proof.scheme === attempt.payload.scheme && option.proof.network === attempt.payload.network;
+    }
+    if (attempt.type === "direct" && option.proof.mode === "direct") {
+      return option.id === attempt.payload.optionId;
+    }
+    return false;
+  });
+}
+function resolveX402Version(options) {
+  const versions = [];
+  for (const option of options) {
+    if (option.proof.mode === "x402" && option.proof.version) {
+      versions.push(option.proof.version);
+    }
+  }
+  return versions.length > 0 ? Math.max(...versions) : X402_VERSION_DEFAULT;
+}
+function toX402Requirement(option, fallbackResource, settlement) {
+  if (option.proof.mode !== "x402") {
+    return void 0;
+  }
+  const decimals = resolveDecimals(option);
+  const assetAddress = option.asset.address;
+  if (!assetAddress) {
+    throw new Error(
+      `x402 payment option '${option.id}' is missing asset.address`
+    );
+  }
+  const units = decimalToBaseUnits(option.amount.value, decimals);
+  return x402RequirementSchema.parse({
+    scheme: option.proof.scheme,
+    network: option.proof.network,
+    maxAmountRequired: units,
+    asset: assetAddress,
+    payTo: option.payTo,
+    resource: option.resource ?? fallbackResource,
+    description: option.description,
+    maxTimeoutSeconds: settlement?.windowSeconds,
+    extra: {
+      symbol: option.asset.symbol,
+      currencyCode: option.amount.currency.code,
+      decimals
+    }
+  });
+}
+function resolveDecimals(option) {
+  if (typeof option.asset.decimals === "number") {
+    return option.asset.decimals;
+  }
+  if (typeof option.amount.currency.decimals === "number") {
+    return option.amount.currency.decimals;
+  }
+  throw new Error(
+    `Payment option '${option.id}' must specify asset.decimals or currency.decimals`
+  );
+}
+function decimalToBaseUnits(value, decimals) {
+  const [whole, fraction = ""] = value.split(".");
+  const sanitizedFraction = fraction.slice(0, decimals);
+  const paddedFraction = sanitizedFraction.padEnd(decimals, "0");
+  const combined = `${whole}${paddedFraction}`.replace(/^0+/, "");
+  return combined.length > 0 ? combined : "0";
+}
+function decodeJson(value, schema) {
+  const base64 = normalizeBase64(value);
+  const json = Buffer.from(base64, "base64").toString("utf-8");
+  const parsed = JSON.parse(json);
+  return schema.parse(parsed);
+}
+function encodeJson(value) {
+  const json = JSON.stringify(value);
+  return Buffer.from(json, "utf-8").toString("base64");
+}
+function normalizeBase64(input) {
+  if (/^[A-Za-z0-9+/=]+$/.test(input)) {
+    return input;
+  }
+  const restored = input.replace(/-/g, "+").replace(/_/g, "/");
+  const paddingNeeded = (4 - restored.length % 4) % 4;
+  return restored + "=".repeat(paddingNeeded);
+}
+async function runFacilitatorVerifier({
+  attempt,
+  option,
+  definition,
+  settle,
+  fetchImpl
+}) {
+  if (option.proof.mode !== "x402" || attempt.type !== "x402" || !option.proof.facilitator) {
+    return {
+      success: false,
+      optionId: option.id,
+      attemptType: attempt.type,
+      failure: paymentFailureSchema.parse({
+        reason: "Facilitator verifier invoked for non-x402 option",
+        code: "verification_failed",
+        retryable: false
+      })
+    };
+  }
+  const facilitator = option.proof.facilitator;
+  const verifierUrl = new URL(
+    facilitator.verifyPath ?? "/verify",
+    ensureTrailingSlash(facilitator.url)
+  ).toString();
+  const requirement = toX402Requirement(option, definition.resource, option.settlement);
+  if (!requirement) {
+    return {
+      success: false,
+      optionId: option.id,
+      attemptType: attempt.type,
+      failure: paymentFailureSchema.parse({
+        reason: "Unable to derive x402 requirement for facilitator",
+        code: "verification_failed",
+        retryable: false
+      })
+    };
+  }
+  const headers = buildFacilitatorHeaders(facilitator);
+  const controller = facilitator.timeoutMs ? new AbortController() : void 0;
+  const timeout = facilitator.timeoutMs ? setTimeout(() => controller?.abort(), facilitator.timeoutMs) : void 0;
+  try {
+    const verifyResponse = await fetchImpl(verifierUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        x402Version: attempt.payload.x402Version,
+        paymentHeader: attempt.raw,
+        paymentRequirements: requirement
+      }),
+      signal: controller?.signal ?? null
+    });
+    if (!verifyResponse.ok) {
+      return {
+        success: false,
+        optionId: option.id,
+        attemptType: attempt.type,
+        failure: paymentFailureSchema.parse({
+          reason: `Facilitator verify request failed: ${verifyResponse.status}`,
+          code: "verification_failed",
+          retryable: verifyResponse.status >= 500
+        })
+      };
+    }
+    const verifyPayload = await verifyResponse.json();
+    if (!verifyPayload.isValid) {
+      return {
+        success: false,
+        optionId: option.id,
+        attemptType: attempt.type,
+        failure: paymentFailureSchema.parse({
+          reason: verifyPayload.invalidReason ?? "Facilitator verification failed",
+          code: "verification_failed",
+          retryable: false
+        })
+      };
+    }
+    if (!settle) {
+      return {
+        success: true,
+        optionId: option.id,
+        attemptType: attempt.type,
+        metadata: paymentSuccessMetadataSchema.parse({
+          optionId: option.id,
+          verifier: facilitator.vendor ?? "facilitator"
+        })
+      };
+    }
+    const settleUrl = new URL(
+      facilitator.settlePath ?? "/settle",
+      ensureTrailingSlash(facilitator.url)
+    ).toString();
+    const settleResponse = await fetchImpl(settleUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        x402Version: attempt.payload.x402Version,
+        paymentHeader: attempt.raw,
+        paymentRequirements: requirement
+      }),
+      signal: controller?.signal ?? null
+    });
+    if (!settleResponse.ok) {
+      return {
+        success: false,
+        optionId: option.id,
+        attemptType: attempt.type,
+        failure: paymentFailureSchema.parse({
+          reason: `Facilitator settle request failed: ${settleResponse.status}`,
+          code: "verification_failed",
+          retryable: settleResponse.status >= 500
+        })
+      };
+    }
+    const settlePayload = await settleResponse.json();
+    if (!settlePayload.success) {
+      return {
+        success: false,
+        optionId: option.id,
+        attemptType: attempt.type,
+        failure: paymentFailureSchema.parse({
+          reason: settlePayload.error ?? "Facilitator settlement failed",
+          code: "verification_failed",
+          retryable: false
+        })
+      };
+    }
+    const metadata = paymentSuccessMetadataSchema.parse({
+      optionId: option.id,
+      verifier: facilitator.vendor ?? "facilitator",
+      txHash: settlePayload.txHash ?? void 0,
+      networkId: settlePayload.networkId ?? void 0
+    });
+    return {
+      success: true,
+      optionId: option.id,
+      attemptType: attempt.type,
+      metadata,
+      responseHeaders: {
+        [HEADER_PAYMENT_RESPONSE]: createPaymentResponseHeader(metadata)
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      optionId: option.id,
+      attemptType: attempt.type,
+      failure: paymentFailureSchema.parse({
+        reason: `Facilitator request error: ${error.message}`,
+        code: "verification_failed",
+        retryable: false
+      })
+    };
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}
+function buildFacilitatorHeaders(config) {
+  const headers = {
+    "content-type": "application/json"
+  };
+  if (config?.headers) {
+    Object.assign(headers, config.headers);
+  }
+  const apiKey = resolveFacilitatorApiKey(config);
+  if (apiKey) {
+    const headerName = config?.apiKeyHeader ?? "Authorization";
+    headers[headerName] = apiKey;
+  }
+  return headers;
+}
+function resolveFacilitatorApiKey(config) {
+  if (!config) {
+    return void 0;
+  }
+  if (config.apiKey) {
+    return config.apiKey;
+  }
+  if (config.apiKeyEnv && typeof process !== "undefined") {
+    return process.env?.[config.apiKeyEnv];
+  }
+  return void 0;
+}
+function ensureTrailingSlash(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+
+// src/payment/index.ts
+var PAYMENT_CONTEXT_SYMBOL = Symbol.for("opentool.payment.context");
+var PaymentRequiredError = class extends Error {
+  constructor(response, verification) {
+    super("Payment required");
+    this.name = "PaymentRequiredError";
+    this.response = response;
+    this.verification = verification;
+  }
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const build_1 = require("./build");
-const dev_1 = require("./dev");
-const validate_1 = require("./validate");
-const generate_metadata_1 = require("./generate-metadata");
-commander_1.program
-    .name('opentool')
-    .description('OpenTool CLI for building and developing serverless MCP tools')
-    .version('1.0.0');
-// Dev command (like next dev)
-commander_1.program
-    .command('dev')
-    .description('Start MCP server with stdio transport')
-    .option('-i, --input <dir>', 'Input directory containing tools', 'tools')
-    .option('--watch', 'Watch for file changes', false)
-    .action(dev_1.devCommand);
-// Build command (like next build)
-commander_1.program
-    .command('build')
-    .description('Build tools for deployment')
-    .option('-i, --input <dir>', 'Input directory containing tools', 'tools')
-    .option('-o, --output <dir>', 'Output directory for built tools', 'dist')
-    .option('--name <name>', 'Server name', 'opentool-server')
-    .option('--version <version>', 'Server version', '1.0.0')
-    .action(build_1.buildCommand);
-// Validate command (metadata only)
-commander_1.program
-    .command('validate')
-    .description('Validate metadata for registry submission')
-    .option('-i, --input <dir>', 'Input directory containing tools', 'tools')
-    .action(validate_1.validateCommand);
-// Full validation command (tools + metadata)
-commander_1.program
-    .command('validate-full')
-    .description('Full validation of tools and metadata')
-    .option('-i, --input <dir>', 'Input directory containing tools', 'tools')
-    .action(validate_1.validateFullCommand);
-// Generate metadata command
-commander_1.program
-    .command('metadata')
-    .description('Generate OpenTool metadata JSON without building')
-    .option('-i, --input <dir>', 'Input directory containing tools', 'tools')
-    .option('-o, --output <file>', 'Output file path for metadata.json', 'metadata.json')
-    .option('--name <name>', 'Server name', 'opentool-server')
-    .option('--version <version>', 'Server version', '1.0.0')
-    .action(generate_metadata_1.generateMetadataCommand);
-// Parse arguments
-commander_1.program.parse();
-__exportStar(require("./build"), exports);
-__exportStar(require("./dev"), exports);
-__exportStar(require("./validate"), exports);
-__exportStar(require("./generate-metadata"), exports);
+function setPaymentContext(request, context) {
+  try {
+    Object.defineProperty(request, PAYMENT_CONTEXT_SYMBOL, {
+      value: context,
+      configurable: true,
+      enumerable: false,
+      writable: true
+    });
+  } catch {
+    request[PAYMENT_CONTEXT_SYMBOL] = context;
+  }
+}
+function applyPaymentHeaders(response, headers) {
+  const entries = Object.entries(headers ?? {});
+  if (entries.length === 0) {
+    return response;
+  }
+  let mutated = false;
+  const merged = new Headers(response.headers);
+  for (const [key, value] of entries) {
+    if (!merged.has(key)) {
+      merged.set(key, value);
+      mutated = true;
+    }
+  }
+  if (!mutated) {
+    return response;
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: merged
+  });
+}
+function withPaymentRequirement(handler, payment, options = {}) {
+  return async (request) => {
+    const verification = await requirePayment(request, payment, options);
+    if (verification instanceof Response) {
+      return verification;
+    }
+    setPaymentContext(request, verification);
+    const response = await Promise.resolve(handler(request));
+    return applyPaymentHeaders(response, verification.headers);
+  };
+}
+async function requirePayment(request, payment, options = {}) {
+  const { definition, verifiers } = normalizePayment(payment);
+  const mergedVerifiers = {
+    ...verifiers,
+    ...options.verifiers ?? {}
+  };
+  const verifyOptions = {
+    definition,
+    request
+  };
+  if (Object.keys(mergedVerifiers).length > 0) {
+    verifyOptions.verifiers = mergedVerifiers;
+  }
+  if (options.settle !== void 0) {
+    verifyOptions.settle = options.settle;
+  }
+  if (options.fetchImpl) {
+    verifyOptions.fetchImpl = options.fetchImpl;
+  }
+  const verification = await verifyPayment(verifyOptions);
+  if (!verification.success || !verification.metadata) {
+    if (options.onFailure) {
+      return options.onFailure(verification);
+    }
+    const response = paymentRequiredResponse(definition);
+    throw new PaymentRequiredError(response, verification);
+  }
+  return {
+    payment: verification.metadata,
+    headers: verification.responseHeaders ?? {},
+    optionId: verification.optionId,
+    result: verification
+  };
+}
+function normalizePayment(payment) {
+  if (isDefinedPayment(payment)) {
+    return {
+      definition: payment.definition,
+      verifiers: payment.verifiers ?? {}
+    };
+  }
+  return {
+    definition: payment,
+    verifiers: {}
+  };
+}
+function isDefinedPayment(value) {
+  return !!value && typeof value === "object" && "definition" in value && value.definition !== void 0;
+}
+
+// src/adapters/mcp.ts
+function createMcpAdapter(options) {
+  const normalizedSchema = ensureSchema(options.schema);
+  const defaultMethod = resolveDefaultMethod(options);
+  const httpHandler = options.httpHandlers[defaultMethod];
+  if (!httpHandler) {
+    throw new Error(
+      `Tool "${options.name}" does not export an HTTP handler for ${defaultMethod}`
+    );
+  }
+  return async function invoke(rawArguments) {
+    const validated = normalizedSchema ? normalizedSchema.parse(rawArguments ?? {}) : rawArguments;
+    const request = buildRequest(options.name, defaultMethod, validated);
+    try {
+      const response = await Promise.resolve(httpHandler(request));
+      return await responseToToolResponse(response);
+    } catch (error) {
+      if (error instanceof PaymentRequiredError) {
+        return await responseToToolResponse(error.response);
+      }
+      throw error;
+    }
+  };
+}
+function resolveDefaultMethod(options) {
+  const explicit = options.defaultMethod?.toUpperCase();
+  if (explicit && typeof options.httpHandlers[explicit] === "function") {
+    return explicit;
+  }
+  const preferredOrder = ["POST", "PUT", "PATCH", "GET", "DELETE", "OPTIONS", "HEAD"];
+  for (const method of preferredOrder) {
+    if (typeof options.httpHandlers[method] === "function") {
+      return method;
+    }
+  }
+  const available = Object.keys(options.httpHandlers).filter(
+    (method) => typeof options.httpHandlers[method] === "function"
+  );
+  if (available.length > 0) {
+    return available[0];
+  }
+  throw new Error(`No HTTP handlers available for tool "${options.name}"`);
+}
+function ensureSchema(schema) {
+  if (!schema) {
+    return void 0;
+  }
+  if (schema instanceof z.ZodType) {
+    return schema;
+  }
+  if (typeof schema?.parse === "function") {
+    return schema;
+  }
+  throw new Error("MCP adapter requires a valid Zod schema to validate arguments");
+}
+function buildRequest(name, method, params) {
+  const url = new URL(`https://opentool.local/${encodeURIComponent(name)}`);
+  const headers = new Headers({
+    "x-opentool-invocation": "mcp",
+    "x-opentool-tool": name
+  });
+  if (method === "GET" || method === "HEAD") {
+    if (params && typeof params === "object") {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value == null) {
+          return;
+        }
+        url.searchParams.set(key, String(value));
+      });
+    }
+    return new Request(url, { method, headers });
+  }
+  headers.set("Content-Type", "application/json");
+  const init = { method, headers };
+  if (params != null) {
+    init.body = JSON.stringify(params);
+  }
+  return new Request(url, init);
+}
+async function responseToToolResponse(response) {
+  const statusIsError = response.status >= 400;
+  const contentType = response.headers.get("content-type") ?? "";
+  const text = await response.text();
+  if (contentType.includes("application/json")) {
+    try {
+      const payload = text ? JSON.parse(text) : {};
+      if (payload && typeof payload === "object" && Array.isArray(payload.content)) {
+        return {
+          content: payload.content,
+          isError: payload.isError ?? statusIsError
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+        isError: statusIsError
+      };
+    } catch {
+      return {
+        content: [{ type: "text", text }],
+        isError: statusIsError
+      };
+    }
+  }
+  if (!text) {
+    return {
+      content: [],
+      isError: statusIsError
+    };
+  }
+  return {
+    content: [{ type: "text", text }],
+    isError: statusIsError
+  };
+}
+
+// src/types/index.ts
+var HTTP_METHODS = [
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS"
+];
+
+// src/cli/validate.ts
+var SUPPORTED_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+];
+async function validateCommand(options) {
+  console.log("\u{1F50D} Validating OpenTool metadata...");
+  try {
+    const toolsDir = path5.resolve(options.input);
+    if (!fs4.existsSync(toolsDir)) {
+      throw new Error(`Tools directory not found: ${toolsDir}`);
+    }
+    const projectRoot = path5.dirname(toolsDir);
+    const tools = await loadAndValidateTools(toolsDir, { projectRoot });
+    if (tools.length === 0) {
+      throw new Error("No valid tools found - metadata validation aborted");
+    }
+    const { metadata, defaultsApplied, sourceMetadataPath } = await buildMetadataArtifact({
+      projectRoot,
+      tools
+    });
+    logMetadataSummary(metadata, defaultsApplied, sourceMetadataPath);
+    console.log("\n\u2705 Metadata validation passed!\n");
+  } catch (error) {
+    console.error("\u274C Metadata validation failed:", error);
+    process.exit(1);
+  }
+}
+async function validateFullCommand(options) {
+  console.log("\u{1F50D} Running full OpenTool validation...\n");
+  try {
+    const toolsDir = path5.resolve(options.input);
+    if (!fs4.existsSync(toolsDir)) {
+      throw new Error(`Tools directory not found: ${toolsDir}`);
+    }
+    const projectRoot = path5.dirname(toolsDir);
+    const tools = await loadAndValidateTools(toolsDir, { projectRoot });
+    if (tools.length === 0) {
+      throw new Error("No tools discovered in the target directory");
+    }
+    const names = tools.map((tool) => tool.metadata?.name ?? tool.filename);
+    const duplicates = findDuplicates(names);
+    if (duplicates.length > 0) {
+      throw new Error(`Duplicate tool names found: ${duplicates.join(", ")}`);
+    }
+    const { metadata, defaultsApplied, sourceMetadataPath } = await buildMetadataArtifact({
+      projectRoot,
+      tools
+    });
+    console.log(`\u{1F4E6} Tools loaded: ${tools.length}`);
+    tools.forEach((tool) => {
+      const toolName = tool.metadata?.name ?? tool.filename;
+      const description = tool.metadata?.description ?? `${toolName} tool`;
+      console.log(`  \u2022 ${toolName} \u2014 ${description}`);
+    });
+    logMetadataSummary(metadata, defaultsApplied, sourceMetadataPath);
+    console.log("\n\u2705 Full validation completed successfully\n");
+  } catch (error) {
+    console.error("\u274C Full validation failed:", error);
+    process.exit(1);
+  }
+}
+async function loadAndValidateTools(toolsDir, options = {}) {
+  const files = fs4.readdirSync(toolsDir).filter((file) => SUPPORTED_EXTENSIONS.includes(path5.extname(file)));
+  if (files.length === 0) {
+    return [];
+  }
+  const projectRoot = options.projectRoot ?? path5.dirname(toolsDir);
+  const tempDir = path5.join(toolsDir, ".opentool-temp");
+  if (fs4.existsSync(tempDir)) {
+    fs4.rmSync(tempDir, { recursive: true, force: true });
+  }
+  const entryPoints = files.map((file) => path5.join(toolsDir, file));
+  const { outDir, cleanup } = await transpileWithEsbuild({
+    entryPoints,
+    projectRoot,
+    format: "esm",
+    outDir: tempDir
+  });
+  const tools = [];
+  try {
+    for (const file of files) {
+      const compiledPath = resolveCompiledPath(outDir, file);
+      if (!fs4.existsSync(compiledPath)) {
+        throw new Error(`Failed to compile ${file}`);
+      }
+      const moduleExports = await importFresh(compiledPath);
+      const toolModule = extractToolModule(moduleExports, file);
+      const schema = ensureZodSchema(toolModule.schema, file);
+      const paymentExport = toolModule.payment;
+      const toolName = toolModule.metadata?.name ?? toolModule.metadata?.title ?? toBaseName(file);
+      const inputSchemaRaw = schema ? toJsonSchema(toolName, schema) : void 0;
+      const inputSchema = normalizeInputSchema(inputSchemaRaw);
+      const httpHandlersRaw = collectHttpHandlers(toolModule, file);
+      const httpHandlers = [...httpHandlersRaw];
+      if (httpHandlers.length === 0) {
+        throw new Error(
+          `${file} must export at least one HTTP handler (e.g. POST)`
+        );
+      }
+      if (paymentExport) {
+        for (let index = 0; index < httpHandlers.length; index += 1) {
+          const entry = httpHandlers[index];
+          httpHandlers[index] = {
+            ...entry,
+            handler: withPaymentRequirement(entry.handler, paymentExport)
+          };
+        }
+      }
+      const httpHandlerMap = toHttpHandlerMap(httpHandlers);
+      const defaultMethod = typeof toolModule.mcp?.defaultMethod === "string" ? toolModule.mcp.defaultMethod : void 0;
+      const adapter = createMcpAdapter({
+        name: toolName,
+        httpHandlers: httpHandlerMap,
+        ...defaultMethod ? { defaultMethod } : {},
+        ...schema ? { schema } : {}
+      });
+      let metadataOverrides = toolModule.metadata ?? null;
+      if (paymentExport?.metadata) {
+        if (metadataOverrides) {
+          metadataOverrides = {
+            ...metadataOverrides,
+            payment: metadataOverrides.payment ?? paymentExport.metadata,
+            annotations: {
+              ...metadataOverrides.annotations ?? {},
+              requiresPayment: metadataOverrides.annotations?.requiresPayment ?? true
+            }
+          };
+        } else {
+          metadataOverrides = {
+            payment: paymentExport.metadata,
+            annotations: { requiresPayment: true }
+          };
+        }
+      }
+      const tool = {
+        schema: schema ?? void 0,
+        inputSchema,
+        metadata: metadataOverrides,
+        httpHandlers,
+        mcpConfig: normalizeMcpConfig(toolModule.mcp, file),
+        filename: toBaseName(file),
+        sourcePath: path5.join(toolsDir, file),
+        handler: async (params) => adapter(params),
+        payment: paymentExport ?? null
+      };
+      tools.push(tool);
+    }
+  } finally {
+    cleanup();
+    if (fs4.existsSync(tempDir)) {
+      fs4.rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+  return tools;
+}
+function extractToolModule(exportsObject, filename) {
+  const candidates = [exportsObject, exportsObject?.default];
+  for (const candidate of candidates) {
+    if (candidate && typeof candidate === "object") {
+      const hasSchema = candidate.schema && typeof candidate.schema === "object";
+      const hasHttp = HTTP_METHODS.some((method) => typeof candidate[method] === "function");
+      if (hasSchema || hasHttp) {
+        return candidate;
+      }
+    }
+  }
+  throw new Error(
+    `${filename} must export a tool definition. Expected a Zod schema plus HTTP handlers (export async function POST).`
+  );
+}
+function toJsonSchema(name, schema) {
+  if (!schema) {
+    return void 0;
+  }
+  try {
+    return zodToJsonSchema(schema, {
+      name: `${name}Schema`,
+      target: "jsonSchema7",
+      $refStrategy: "none"
+    });
+  } catch (error) {
+    throw new Error(`Failed to convert Zod schema for ${name}: ${error}`);
+  }
+}
+function toBaseName(file) {
+  return file.replace(/\.[^.]+$/, "");
+}
+function ensureZodSchema(schemaCandidate, filename) {
+  if (schemaCandidate == null) {
+    return void 0;
+  }
+  if (schemaCandidate instanceof z.ZodType) {
+    return schemaCandidate;
+  }
+  const schema = schemaCandidate;
+  if (typeof schema?.parse !== "function") {
+    throw new Error(`${filename} schema export must be a Zod schema (missing parse method)`);
+  }
+  return schema;
+}
+function collectHttpHandlers(module, filename) {
+  const handlers = [];
+  for (const method of HTTP_METHODS) {
+    const handler = module?.[method];
+    if (typeof handler === "function") {
+      handlers.push({
+        method,
+        handler: async (request) => handler.call(module, request)
+      });
+    }
+  }
+  handlers.sort((a, b) => HTTP_METHODS.indexOf(a.method) - HTTP_METHODS.indexOf(b.method));
+  const duplicates = findDuplicates(handlers.map((h) => h.method));
+  if (duplicates.length > 0) {
+    throw new Error(
+      `${filename} exports multiple handlers for HTTP method(s): ${duplicates.join(", ")}`
+    );
+  }
+  return handlers;
+}
+function toHttpHandlerMap(handlers) {
+  return handlers.reduce((acc, handler) => {
+    acc[handler.method.toUpperCase()] = handler.handler;
+    return acc;
+  }, {});
+}
+function normalizeInputSchema(schema) {
+  if (!schema || typeof schema !== "object") {
+    return schema;
+  }
+  const clone = JSON.parse(JSON.stringify(schema));
+  if (typeof clone.$ref === "string" && clone.$ref.startsWith("#/definitions/")) {
+    const refName = clone.$ref.replace("#/definitions/", "");
+    const definitions = clone.definitions;
+    if (definitions && typeof definitions[refName] === "object") {
+      return normalizeInputSchema(definitions[refName]);
+    }
+  }
+  delete clone.$ref;
+  delete clone.definitions;
+  if (!("type" in clone)) {
+    clone.type = "object";
+  }
+  return clone;
+}
+function normalizeMcpConfig(rawConfig, filename) {
+  if (rawConfig == null) {
+    return null;
+  }
+  if (rawConfig === false) {
+    return null;
+  }
+  if (rawConfig === true) {
+    return { enabled: true };
+  }
+  if (!isPlainObject(rawConfig)) {
+    throw new Error(`${filename} export \\"mcp\\" must be an object with an enabled flag`);
+  }
+  const enabledRaw = rawConfig.enabled;
+  if (enabledRaw === false) {
+    return null;
+  }
+  if (enabledRaw !== true) {
+    throw new Error(`${filename} mcp.enabled must be explicitly set to true to opt-in to MCP`);
+  }
+  const modeRaw = rawConfig.mode;
+  let mode;
+  if (typeof modeRaw === "string") {
+    const normalized = modeRaw.toLowerCase();
+    if (["stdio", "lambda", "dual"].includes(normalized)) {
+      mode = normalized;
+    } else {
+      throw new Error(
+        `${filename} mcp.mode must be one of "stdio", "lambda", or "dual" if specified`
+      );
+    }
+  }
+  const defaultMethodRaw = rawConfig.defaultMethod;
+  const defaultMethod = typeof defaultMethodRaw === "string" ? defaultMethodRaw.toUpperCase() : void 0;
+  const overridesRaw = rawConfig.metadataOverrides;
+  const metadataOverrides = isPlainObject(overridesRaw) ? overridesRaw : void 0;
+  const config = {
+    enabled: true
+  };
+  if (mode) {
+    config.mode = mode;
+  }
+  if (defaultMethod) {
+    config.defaultMethod = defaultMethod;
+  }
+  if (metadataOverrides) {
+    config.metadataOverrides = metadataOverrides;
+  }
+  return config;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function findDuplicates(values) {
+  const seen = /* @__PURE__ */ new Map();
+  const duplicates = /* @__PURE__ */ new Set();
+  values.forEach((value) => {
+    const count = seen.get(value) ?? 0;
+    seen.set(value, count + 1);
+    if (count >= 1) {
+      duplicates.add(value);
+    }
+  });
+  return Array.from(duplicates.values());
+}
+function logMetadataSummary(metadata, defaultsApplied, sourceMetadataPath) {
+  console.log(`\u{1F4C4} metadata loaded from ${sourceMetadataPath}`);
+  console.log("\n\u{1F4CA} Metadata Summary:");
+  console.log(`  \u2022 Name: ${metadata.name}`);
+  console.log(`  \u2022 Display Name: ${metadata.displayName}`);
+  console.log(`  \u2022 Version: ${metadata.version}`);
+  console.log(`  \u2022 Category: ${metadata.category}`);
+  console.log(`  \u2022 Tools: ${metadata.tools.length}`);
+  console.log(`  \u2022 Spec Version: ${metadata.metadataSpecVersion}`);
+  if (metadata.payment) {
+    console.log(`  \u2022 Payment: $${metadata.payment.amountUSDC} USDC`);
+  }
+  if (defaultsApplied.length > 0) {
+    console.log("\nDefaults applied during metadata synthesis:");
+    defaultsApplied.forEach((entry) => console.log(`  \u2022 ${entry}`));
+  }
+}
+
+// src/cli/build.ts
+async function buildCommand(options) {
+  const start = timestamp();
+  console.log(`[${start}] Building OpenTool project...`);
+  try {
+    const artifacts = await buildProject(options);
+    logBuildSummary(artifacts, options);
+  } catch (error) {
+    const end = timestamp();
+    console.error(`[${end}] Build failed:`, error);
+    process.exit(1);
+  }
+}
+async function buildProject(options) {
+  const toolsDir = path5.resolve(options.input);
+  if (!fs4.existsSync(toolsDir)) {
+    throw new Error(`Tools directory not found: ${toolsDir}`);
+  }
+  const projectRoot = path5.dirname(toolsDir);
+  const outputDir = path5.resolve(options.output);
+  fs4.mkdirSync(outputDir, { recursive: true });
+  const serverName = options.name ?? "opentool-server";
+  const serverVersion = options.version ?? "1.0.0";
+  const tools = await loadAndValidateTools(toolsDir, { projectRoot });
+  if (tools.length === 0) {
+    throw new Error("No valid tools found - build aborted");
+  }
+  const { metadata, defaultsApplied } = await buildMetadataArtifact({
+    projectRoot,
+    tools
+  });
+  const metadataPath = path5.join(outputDir, "metadata.json");
+  fs4.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+  const compiledTools = await emitTools(tools, {
+    projectRoot,
+    outputDir
+  });
+  const shouldBuildMcpServer = compiledTools.some((artifact) => artifact.mcpEnabled);
+  if (shouldBuildMcpServer) {
+    await writeMcpServer({
+      outputDir,
+      serverName,
+      serverVersion,
+      compiledTools});
+  } else {
+    const serverPath = path5.join(outputDir, "mcp-server.js");
+    if (fs4.existsSync(serverPath)) {
+      fs4.rmSync(serverPath);
+    }
+  }
+  return {
+    metadata,
+    defaultsApplied,
+    tools,
+    compiledTools
+  };
+}
+async function emitTools(tools, config) {
+  const toolsOutDir = path5.join(config.outputDir, "tools");
+  if (fs4.existsSync(toolsOutDir)) {
+    fs4.rmSync(toolsOutDir, { recursive: true, force: true });
+  }
+  fs4.mkdirSync(toolsOutDir, { recursive: true });
+  const entryPoints = tools.map((tool) => {
+    if (!tool.sourcePath) {
+      throw new Error(`Missing sourcePath for tool ${tool.filename}`);
+    }
+    return tool.sourcePath;
+  });
+  await transpileWithEsbuild({
+    entryPoints,
+    projectRoot: config.projectRoot,
+    format: "cjs",
+    outDir: toolsOutDir
+  });
+  const compiled = tools.map((tool) => {
+    if (!tool.sourcePath) {
+      throw new Error(`Missing sourcePath for tool ${tool.filename}`);
+    }
+    const base = path5.basename(tool.sourcePath).replace(/\.[^.]+$/, "");
+    const modulePath = path5.join("tools", `${base}.js`);
+    if (!fs4.existsSync(path5.join(config.outputDir, modulePath))) {
+      throw new Error(`Expected compiled output missing: ${modulePath}`);
+    }
+    const defaultMcpMethod = tool.mcpConfig?.defaultMethod;
+    return {
+      name: tool.metadata?.name ?? tool.filename,
+      filename: base,
+      modulePath,
+      httpMethods: tool.httpHandlers.map((handler) => handler.method),
+      mcpEnabled: tool.mcpConfig?.enabled ?? false,
+      ...defaultMcpMethod ? { defaultMcpMethod } : {},
+      hasWallet: Boolean(tool.payment)
+    };
+  });
+  return compiled;
+}
+function renderMcpServer(options) {
+  const toolImports = options.compiledTools.map((tool, index) => `const tool${index} = require('./${tool.modulePath}');`).join("\n");
+  const registry = options.compiledTools.map((artifact, index) => {
+    const config = {
+      enabled: artifact.mcpEnabled,
+      defaultMethod: artifact.defaultMcpMethod ?? null,
+      httpMethods: artifact.httpMethods,
+      filename: artifact.filename
+    };
+    return `  { meta: metadata.tools[${index}], module: tool${index}, config: ${JSON.stringify(config)} }`;
+  }).join(",\n");
+  return `#!/usr/bin/env node
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { CallToolRequestSchema, ListToolsRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
+const metadata = require('./metadata.json');
+const { createMcpAdapter, HTTP_METHODS } = require('opentool/dist/adapters/mcp.js');
+
+${toolImports}
+
+const toolRegistry = [
+${registry}
+];
+
+const adapters = toolRegistry.map((entry) => {
+  if (!entry.config.enabled) {
+    return null;
+  }
+
+  const httpHandlers = Object.fromEntries(
+    HTTP_METHODS
+      .map((method) => [method, entry.module[method]])
+      .filter(([, handler]) => typeof handler === 'function')
+  );
+
+  return {
+    meta: entry.meta,
+    invoke: createMcpAdapter({
+      name: entry.meta.name,
+      schema: entry.module.schema,
+      httpHandlers,
+      defaultMethod: entry.config.defaultMethod || undefined,
+    }),
+  };
+});
+
+const server = new Server(
+  {
+    name: '${escapeForJs(options.serverName)}',
+    version: '${escapeForJs(options.serverVersion)}',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: adapters
+    .filter((entry) => entry !== null)
+    .map((entry) => entry.meta),
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const adapter = adapters.find((entry) => entry && entry.meta.name === request.params.name);
+  if (!adapter) {
+    throw new Error('Tool ' + request.params.name + ' is not registered for MCP');
+  }
+
+  try {
+    return await adapter.invoke(request.params.arguments);
+  } catch (error) {
+    const message = (error && error.message) || String(error);
+    return {
+      content: [{ type: 'text', text: 'Error: ' + message }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}
+
+module.exports = { server };
+`;
+}
+async function writeMcpServer(options) {
+  const serverCode = renderMcpServer(options);
+  const serverPath = path5.join(options.outputDir, "mcp-server.js");
+  fs4.writeFileSync(serverPath, serverCode);
+  fs4.chmodSync(serverPath, 493);
+}
+function logBuildSummary(artifacts, options) {
+  const end = timestamp();
+  console.log(`[${end}] Build completed successfully!`);
+  console.log(`Output directory: ${path5.resolve(options.output)}`);
+  console.log("Generated files:");
+  const hasMcp = artifacts.compiledTools.some((tool) => tool.mcpEnabled);
+  if (hasMcp) {
+    console.log("  \u2022 mcp-server.js (stdio server)");
+  }
+  console.log(`  \u2022 tools/ (${artifacts.compiledTools.length} compiled tools)`);
+  artifacts.compiledTools.forEach((tool) => {
+    const methods = tool.httpMethods.join(", ");
+    const walletBadge = tool.hasWallet ? " [wallet]" : "";
+    console.log(`     - ${tool.name} [${methods}]${walletBadge}`);
+  });
+  console.log("  \u2022 metadata.json (registry artifact)");
+  if (artifacts.defaultsApplied.length > 0) {
+    console.log("\nDefaults applied during metadata synthesis:");
+    artifacts.defaultsApplied.forEach((entry) => console.log(`  \u2022 ${entry}`));
+  }
+  if (!hasMcp) {
+    console.log("\n\u2139\uFE0F MCP adapter skipped (no tools opted in)");
+  }
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+}
+function escapeForJs(value) {
+  return value.replace(/'/g, "\\'");
+}
+var __dirname2 = path5.dirname(fileURLToPath(import.meta.url));
+var packageJson = JSON.parse(
+  fs4.readFileSync(path5.resolve(__dirname2, "../../package.json"), "utf-8")
+);
+var cyan = "\x1B[36m";
+var bold = "\x1B[1m";
+var dim = "\x1B[2m";
+var reset = "\x1B[0m";
+async function devCommand(options) {
+  const port = options.port ?? 7e3;
+  const watch2 = options.watch ?? true;
+  const enableStdio = options.stdio ?? false;
+  const log = enableStdio ? (_message) => {
+  } : (message) => console.log(message);
+  try {
+    const toolsDir = path5.resolve(options.input);
+    if (!fs4.existsSync(toolsDir)) {
+      throw new Error(`Tools directory not found: ${toolsDir}`);
+    }
+    const projectRoot = path5.dirname(toolsDir);
+    let toolDefinitions = await loadToolDefinitions(toolsDir, projectRoot);
+    if (toolDefinitions.length === 0) {
+      throw new Error("No tools found in the target directory");
+    }
+    let routes = expandRoutes(toolDefinitions);
+    const stdioController = enableStdio ? await startMcpServer(() => toolDefinitions) : null;
+    if (watch2) {
+      fs4.watch(toolsDir, async (_eventType, filename) => {
+        if (filename && !/\.(ts|js|mjs|cjs|tsx|jsx)$/.test(filename)) {
+          return;
+        }
+        log(
+          `${dim}
+Detected change in ${filename ?? "tools directory"}, reloading...${reset}`
+        );
+        try {
+          toolDefinitions = await loadToolDefinitions(toolsDir, projectRoot);
+          routes = expandRoutes(toolDefinitions);
+          logReload(toolDefinitions, enableStdio, log);
+        } catch (error) {
+          console.error("Failed to reload tools:", error);
+        }
+      });
+    }
+    const server = http.createServer(async (req, res) => {
+      const method = (req.method || "GET").toUpperCase();
+      const url = new URL(req.url || "/", `http://localhost:${port}`);
+      const routePath = url.pathname;
+      log(`${dim}[request] ${method} ${routePath}${reset}`);
+      try {
+        await handleRequest({ req, res, port, routes });
+        log(
+          `${dim}[response] ${method} ${routePath} ${res.statusCode}${reset}`
+        );
+      } catch (error) {
+        console.error("Error handling request:", error);
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: error.message }));
+        log(`${dim}[response] ${method} ${routePath} 500${reset}`);
+      }
+    });
+    server.listen(port, () => {
+      log(`${bold}${dim}> dev opentool${reset}`);
+      log(
+        `   * ${bold}opentool${reset} ${cyan}v${packageJson.version}${reset}`
+      );
+      log(`   * ${bold}HTTP:${reset} http://localhost:${port}`);
+      logStartup(toolDefinitions, enableStdio, log);
+    });
+    process.on("SIGINT", async () => {
+      log(`
+${dim}Shutting down dev server...${reset}`);
+      server.close();
+      if (stdioController) {
+        await stdioController.close();
+      }
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("Dev server failed:", error);
+    process.exit(1);
+  }
+}
+async function startMcpServer(getTools) {
+  const server = new Server(
+    {
+      name: "opentool-dev",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = getTools().filter(isMcpEnabled);
+    return {
+      tools: tools.map((tool) => ({
+        name: tool.metadata?.name ?? tool.filename,
+        description: tool.metadata?.description ?? `${tool.filename} tool`,
+        inputSchema: tool.inputSchema,
+        annotations: tool.metadata?.annotations,
+        payment: tool.metadata?.payment,
+        discovery: tool.metadata?.discovery
+      }))
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const tools = getTools().filter(isMcpEnabled);
+    const tool = tools.find((entry) => {
+      const toolName = entry.metadata?.name ?? entry.filename;
+      return toolName === request.params.name;
+    });
+    if (!tool) {
+      throw new Error(`Tool ${request.params.name} not found`);
+    }
+    try {
+      const validatedParams = tool.schema.parse(
+        request.params.arguments
+      );
+      const handler = tool.handler ?? createMcpAdapter({
+        name: tool.metadata?.name ?? tool.filename,
+        httpHandlers: toHttpHandlerMap2(tool.httpHandlers),
+        ...tool.schema ? { schema: tool.schema } : {},
+        ...tool.mcpConfig?.defaultMethod ? { defaultMethod: tool.mcpConfig.defaultMethod } : {}
+      });
+      const result = await handler(validatedParams);
+      return result;
+    } catch (error) {
+      const message = error && error.message || String(error);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true
+      };
+    }
+  });
+  const transport = new StdioServerTransport();
+  server.connect(transport).catch((error) => {
+    console.error("MCP transport error:", error);
+  });
+  return {
+    async close() {
+      await server.close();
+      if (typeof transport.close === "function") {
+        transport.close();
+      }
+    }
+  };
+}
+async function loadToolDefinitions(toolsDir, projectRoot) {
+  return loadAndValidateTools(toolsDir, { projectRoot });
+}
+function expandRoutes(tools) {
+  const routes = [];
+  tools.forEach((tool) => {
+    tool.httpHandlers.forEach((handlerDef) => {
+      routes.push({
+        tool,
+        method: handlerDef.method.toUpperCase(),
+        handler: async (request) => handlerDef.handler(request)
+      });
+    });
+  });
+  return routes;
+}
+function logStartup(tools, stdio, log) {
+  log(`
+Tools: ${tools.length} tool${tools.length === 1 ? "" : "s"}`);
+  printToolList(tools, log);
+  if (stdio) {
+    const mcpTools = tools.filter(isMcpEnabled);
+    const label = mcpTools.length > 0 ? `MCP stdio enabled (${mcpTools.length} tool${mcpTools.length === 1 ? "" : "s"})` : "MCP stdio enabled (no tools opted in)";
+    log(`${dim}${label}${reset}`);
+  }
+}
+function logReload(tools, stdio, log) {
+  log(`
+Reloaded ${tools.length} tool${tools.length === 1 ? "" : "s"}`);
+  printToolList(tools, log);
+  if (stdio) {
+    const mcpTools = tools.filter(isMcpEnabled);
+    const label = mcpTools.length > 0 ? `MCP stdio enabled (${mcpTools.length} tool${mcpTools.length === 1 ? "" : "s"})` : "MCP stdio enabled (no tools opted in)";
+    log(`${dim}${label}${reset}`);
+  }
+}
+function printToolList(tools, log) {
+  tools.forEach((tool) => {
+    const name = tool.metadata?.name ?? tool.filename;
+    const methods = tool.httpHandlers.map((handler) => handler.method).join(", ");
+    const tags = [];
+    if (tool.mcpConfig?.enabled) {
+      tags.push(`${dim}[mcp]${reset}`);
+    }
+    if (tool.payment || tool.metadata && tool.metadata.payment) {
+      tags.push(`${dim}[payments]${reset}`);
+    }
+    const tagSuffix = tags.length ? ` ${tags.join(" ")}` : "";
+    log(`  \u2022 ${name} \u2014 ${methods}${tagSuffix}`);
+  });
+}
+async function handleRequest(params) {
+  const { req, res, port, routes } = params;
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader(
+    "Access-Control-Allow-Methods",
+    HTTP_METHODS.join(", ") + ", OPTIONS"
+  );
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  if (req.method === "OPTIONS") {
+    res.writeHead(200);
+    res.end();
+    return;
+  }
+  const method = (req.method || "GET").toUpperCase();
+  const url = new URL(req.url || "/", `http://localhost:${port}`);
+  const toolName = url.pathname.slice(1) || "index";
+  const route = findRoute(toolName, method, routes);
+  if (!route) {
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: `Tool not found: ${method} /${toolName}`,
+        availableTools: routes.map((r) => `${r.method} /${routeName(r.tool)}`)
+      })
+    );
+    return;
+  }
+  const body = await readRequestBody(req);
+  const request = createWebRequest({ req, url, body });
+  let response;
+  try {
+    response = await route.handler(request);
+  } catch (error) {
+    if (error instanceof PaymentRequiredError) {
+      response = error.response;
+    } else {
+      throw error;
+    }
+  }
+  const headers = {};
+  response.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  res.writeHead(response.status, headers);
+  if (method === "HEAD") {
+    res.end();
+    return;
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  res.end(Buffer.from(arrayBuffer));
+}
+function findRoute(toolName, method, routes) {
+  const direct = routes.find(
+    (route) => routeName(route.tool) === toolName && route.method === method
+  );
+  if (direct) {
+    return direct;
+  }
+  if (method === "HEAD") {
+    return routes.find(
+      (route) => routeName(route.tool) === toolName && route.method === "GET"
+    );
+  }
+  return void 0;
+}
+function routeName(tool) {
+  return tool.metadata?.name ?? tool.filename;
+}
+async function readRequestBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks);
+}
+function createWebRequest(params) {
+  const { req, url, body } = params;
+  const headers = new Headers();
+  Object.entries(req.headers).forEach(([key, value]) => {
+    if (value === void 0) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((entry) => headers.append(key, entry));
+      return;
+    }
+    headers.set(key, value);
+  });
+  const method = (req.method || "GET").toUpperCase();
+  const init = {
+    method,
+    headers
+  };
+  if (body.length > 0 && method !== "GET" && method !== "HEAD") {
+    init.body = body.toString();
+  }
+  return new Request(url, init);
+}
+function toHttpHandlerMap2(handlers) {
+  return handlers.reduce(
+    (acc, handler) => {
+      acc[handler.method.toUpperCase()] = handler.handler;
+      return acc;
+    },
+    {}
+  );
+}
+function isMcpEnabled(tool) {
+  return Boolean(tool.mcpConfig?.enabled);
+}
+async function generateMetadataCommand(options) {
+  const startTimestamp = timestamp2();
+  console.log(`[${startTimestamp}] Generating OpenTool metadata...`);
+  try {
+    const result = await generateMetadata(options);
+    const endTimestamp = timestamp2();
+    console.log(`[${endTimestamp}] Metadata generation completed successfully!`);
+    console.log(`Output file: ${result.outputPath}`);
+    console.log(`Spec version: ${result.metadata.metadataSpecVersion}`);
+    console.log(`Tools included: ${result.tools.length}`);
+    if (result.defaultsApplied.length > 0) {
+      console.log("Applied defaults:");
+      for (const entry of result.defaultsApplied) {
+        console.log(`  \u2022 ${entry}`);
+      }
+    }
+  } catch (error) {
+    const endTimestamp = timestamp2();
+    console.error(`[${endTimestamp}] Metadata generation failed:`, error);
+    process.exit(1);
+  }
+}
+async function generateMetadata(options) {
+  const toolsDir = path5.resolve(options.input);
+  if (!fs4.existsSync(toolsDir)) {
+    throw new Error(`Tools directory not found: ${toolsDir}`);
+  }
+  const projectRoot = path5.dirname(toolsDir);
+  const tools = await loadAndValidateTools(toolsDir, { projectRoot });
+  const { metadata, defaultsApplied } = await buildMetadataArtifact({
+    projectRoot,
+    tools
+  });
+  const outputPath = options.output ? path5.resolve(options.output) : path5.join(projectRoot, "metadata.json");
+  fs4.writeFileSync(outputPath, JSON.stringify(metadata, null, 2));
+  return {
+    metadata,
+    defaultsApplied,
+    tools,
+    outputPath
+  };
+}
+function timestamp2() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+}
+
+// src/cli/index.ts
+program.name("opentool").description("OpenTool CLI for building and developing serverless MCP tools").version("1.0.0");
+program.command("dev").description("Start HTTP dev server (optional MCP stdio)").option("-i, --input <dir>", "Input directory containing tools", "tools").option("-p, --port <port>", "Port to listen on", "7000").option("--stdio", "Expose MCP stdio transport", false).option("--no-watch", "Disable file watching").action((cmdOptions) => {
+  devCommand({
+    input: cmdOptions.input,
+    port: Number(cmdOptions.port ?? 7e3),
+    watch: cmdOptions.watch,
+    stdio: cmdOptions.stdio
+  });
+});
+program.command("build").description("Build tools for deployment").option("-i, --input <dir>", "Input directory containing tools", "tools").option("-o, --output <dir>", "Output directory for built tools", "dist").option("--name <name>", "Server name", "opentool-server").option("--version <version>", "Server version", "1.0.0").action(buildCommand);
+program.command("validate").description("Validate metadata for registry submission").option("-i, --input <dir>", "Input directory containing tools", "tools").action(validateCommand);
+program.command("validate-full").description("Full validation of tools and metadata").option("-i, --input <dir>", "Input directory containing tools", "tools").action(validateFullCommand);
+program.command("metadata").description("Generate OpenTool metadata JSON without building").option("-i, --input <dir>", "Input directory containing tools", "tools").option(
+  "-o, --output <file>",
+  "Output file path for metadata.json",
+  "metadata.json"
+).option("--name <name>", "Server name", "opentool-server").option("--version <version>", "Server version", "1.0.0").action(generateMetadataCommand);
+program.parse();
+
+export { buildCommand, buildProject, devCommand, generateMetadata, generateMetadataCommand, loadAndValidateTools, validateCommand, validateFullCommand };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map