opentool 0.5.0 → 0.6.1

package/dist/index.js

@@ -1,26 +1,3259 @@
-"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);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateCommand = exports.loadAndValidateTools = exports.generateMetadataCommand = exports.generateMetadata = void 0;
-__exportStar(require("./runtime"), exports);
-__exportStar(require("./types"), exports);
-var generate_metadata_1 = require("./cli/generate-metadata");
-Object.defineProperty(exports, "generateMetadata", { enumerable: true, get: function () { return generate_metadata_1.generateMetadata; } });
-Object.defineProperty(exports, "generateMetadataCommand", { enumerable: true, get: function () { return generate_metadata_1.generateMetadataCommand; } });
-var validate_1 = require("./cli/validate");
-Object.defineProperty(exports, "loadAndValidateTools", { enumerable: true, get: function () { return validate_1.loadAndValidateTools; } });
-Object.defineProperty(exports, "validateCommand", { enumerable: true, get: function () { return validate_1.validateCommand; } });
+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 fs2 from 'fs';
+import * as path5 from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { z } from 'zod';
+import { zeroAddress, createPublicClient, http, createWalletClient } from 'viem';
+import { baseSepolia, mainnet, base } from 'viem/chains';
+import { privateKeyToAccount } from 'viem/accounts';
+import { Turnkey } from '@turnkey/sdk-server';
+import { createAccount } from '@turnkey/viem';
+import { tmpdir } from 'os';
+import { build } from 'esbuild';
+import { createRequire } from 'module';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+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: 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}/`;
+}
+var PAYMENT_HEADERS = {
+  x402: HEADER_X402,
+  direct: HEADER_DIRECT,
+  response: HEADER_PAYMENT_RESPONSE
+};
+
+// src/payment/index.ts
+var DEFAULT_ID_X402 = "x402";
+var DEFAULT_ID_402 = "402";
+var SUPPORTED_CURRENCIES = {
+  USDC: {
+    decimals: 6,
+    symbol: "USDC",
+    x402: {
+      network: "base",
+      assetAddress: "0x833589fCD6eDb6E08f4c7C37b7b4c6e997E08A43"
+    }
+  }
+};
+var DEFAULT_FACILITATORS = {
+  opentool: "https://facilitator.opentool.dev/x402",
+  coinbase: "https://payments.coinbase.com/x402"
+};
+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;
+  }
+};
+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 getPaymentContext(request) {
+  return request[PAYMENT_CONTEXT_SYMBOL];
+}
+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);
+  };
+}
+function definePayment(config) {
+  const verifiers = {
+    ...config.verifiers ?? {}
+  };
+  const methods = config.acceptedMethods ?? ["402"];
+  const includeX402 = methods.includes("x402");
+  const includePlain402 = methods.includes("402");
+  if (!includeX402 && !includePlain402) {
+    throw new Error(
+      "definePayment requires at least one payment transport (x402 or 402)"
+    );
+  }
+  const currencyCode = normalizeCurrency(config.currency);
+  const currencySpec = SUPPORTED_CURRENCIES[currencyCode];
+  if (!currencySpec) {
+    throw new Error(`Unsupported currency for payments: ${currencyCode}`);
+  }
+  const decimals = currencySpec.decimals;
+  const symbol = currencySpec.symbol;
+  const value = toDecimalString(config.amount);
+  const accepts = [];
+  if (includeX402) {
+    const overrides = config.x402 ?? {};
+    const defaults = currencySpec.x402;
+    if (!defaults && (!overrides.network || !overrides.assetAddress)) {
+      throw new Error(
+        "x402 payments require a network and assetAddress; supply them or choose a supported currency."
+      );
+    }
+    const facilitator = resolveFacilitator(
+      config.facilitator ?? overrides.facilitator ?? "opentool"
+    );
+    accepts.push(
+      paymentOptionSchema.parse({
+        id: overrides.id ?? DEFAULT_ID_X402,
+        title: `Pay ${value} ${currencyCode}`,
+        amount: {
+          value,
+          currency: { code: currencyCode, symbol, decimals }
+        },
+        asset: {
+          symbol,
+          network: overrides.network ?? defaults?.network ?? "",
+          address: overrides.assetAddress ?? defaults?.assetAddress ?? "",
+          decimals,
+          standard: "erc20"
+        },
+        payTo: config.payTo,
+        proof: {
+          mode: "x402",
+          network: overrides.network ?? defaults?.network ?? "",
+          scheme: overrides.scheme ?? "exact",
+          version: overrides.version ?? 1,
+          facilitator,
+          verifier: facilitator ? "x402:facilitator" : void 0
+        },
+        settlement: overrides.settlement
+      })
+    );
+  }
+  if (includePlain402) {
+    const overrides = config.direct ?? {};
+    const id = overrides.id ?? DEFAULT_ID_402;
+    const verifierId = overrides.verifierId ?? `direct:${id}`;
+    const proofType = overrides.proofType ?? id;
+    const verifier = overrides.verify ?? buildDefaultDirectVerifier(overrides.token, verifierId, id);
+    verifiers[verifierId] = verifier;
+    accepts.push(
+      paymentOptionSchema.parse({
+        id,
+        title: `Pay ${value} ${currencyCode}`,
+        amount: {
+          value,
+          currency: { code: currencyCode, symbol, decimals }
+        },
+        asset: {
+          symbol,
+          decimals,
+          standard: "erc20"
+        },
+        payTo: config.payTo,
+        proof: {
+          mode: "direct",
+          proofTypes: [proofType],
+          verifier: verifierId,
+          instructions: overrides.instructions,
+          fields: overrides.fields,
+          allowsManualReview: overrides.allowsManualReview
+        },
+        settlement: overrides.settlement
+      })
+    );
+  }
+  const facilitatorLabel = includeX402 ? resolveFacilitatorLabel(config.facilitator ?? config.x402?.facilitator) : void 0;
+  const baseMetadata = {};
+  if (currencyCode === "USDC") {
+    baseMetadata.amountUSDC = Number(value);
+  }
+  baseMetadata.x402 = includeX402;
+  baseMetadata.plain402 = includePlain402;
+  baseMetadata.acceptedMethods = methods;
+  baseMetadata.acceptedCurrencies = config.acceptedCurrencies ?? [currencyCode];
+  if (config.chainIds) {
+    baseMetadata.chainIds = config.chainIds;
+  }
+  if (facilitatorLabel) {
+    baseMetadata.facilitator = facilitatorLabel;
+  }
+  const metadata = config.metadata ? { ...baseMetadata, ...config.metadata } : baseMetadata;
+  const definition = {
+    schemaVersion: PAYMENT_SCHEMA_VERSION,
+    accepts,
+    metadata
+  };
+  if (config.message !== void 0) {
+    definition.message = config.message;
+  }
+  if (config.resource !== void 0) {
+    definition.resource = config.resource;
+  }
+  const defined = {
+    definition,
+    verifiers,
+    metadata
+  };
+  if (config.message !== void 0) {
+    defined.message = config.message;
+  }
+  return defined;
+}
+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;
+}
+function resolveFacilitator(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    if (value in DEFAULT_FACILITATORS) {
+      return {
+        url: DEFAULT_FACILITATORS[value]
+      };
+    }
+    return { url: value };
+  }
+  return value;
+}
+function resolveFacilitatorLabel(value) {
+  if (!value) {
+    return "opentool";
+  }
+  if (typeof value === "string") {
+    if (value === "opentool" || value === "coinbase") {
+      return value;
+    }
+    return "custom";
+  }
+  return "custom";
+}
+function normalizeCurrency(currency) {
+  return (currency ?? "USDC").toUpperCase();
+}
+function toDecimalString(value) {
+  return typeof value === "number" ? value.toString() : value;
+}
+function buildDefaultDirectVerifier(expectedToken, verifierId, optionId) {
+  return async ({ attempt, option }) => {
+    if (attempt.type !== "direct") {
+      return {
+        success: false,
+        optionId: option.id,
+        attemptType: attempt.type,
+        failure: {
+          reason: "Expected direct payment payload",
+          code: "invalid_payload"
+        }
+      };
+    }
+    const payload = attempt.payload.payload;
+    if (expectedToken) {
+      if (payload?.token !== expectedToken) {
+        return {
+          success: false,
+          optionId: option.id,
+          attemptType: attempt.type,
+          failure: {
+            reason: "Invalid or missing payment proof",
+            code: "verification_failed"
+          }
+        };
+      }
+    } else if (!payload) {
+      return {
+        success: false,
+        optionId: option.id,
+        attemptType: attempt.type,
+        failure: {
+          reason: "Payment proof is required",
+          code: "verification_failed"
+        }
+      };
+    }
+    return {
+      success: true,
+      optionId,
+      attemptType: attempt.type,
+      metadata: {
+        optionId,
+        verifier: verifierId,
+        payload
+      }
+    };
+  };
+}
+
+// src/adapters/mcp.ts
+var HTTP_METHODS = [
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS"
+];
+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/runtime/index.ts
+function createDevServer(tools) {
+  const metadata = loadMetadata();
+  const metadataMap = buildMetadataMap(metadata);
+  const adapters = buildAdapters(tools);
+  const server = new Server(
+    {
+      name: "opentool-dev",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: adapters.map(({ tool }) => serializeTool(tool, metadataMap))
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const entry = adapters.find(({ tool }) => {
+      const toolName = tool.metadata?.name || tool.filename;
+      return toolName === request.params.name;
+    });
+    if (!entry) {
+      throw new Error(`Tool ${request.params.name} not found or not MCP-enabled`);
+    }
+    try {
+      return await entry.invoke(request.params.arguments);
+    } catch (error) {
+      const message = error && error.message || String(error);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true
+      };
+    }
+  });
+  return server;
+}
+async function createStdioServer(tools) {
+  const metadata = loadMetadata();
+  const metadataMap = buildMetadataMap(metadata);
+  const toolDefinitions = tools || await loadToolsFromDirectory(metadataMap);
+  const adapters = buildAdapters(toolDefinitions);
+  const server = new Server(
+    {
+      name: "opentool-runtime",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: adapters.map(({ tool }) => serializeTool(tool, metadataMap))
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const entry = adapters.find(({ tool }) => {
+      const toolName = tool.metadata?.name || tool.filename;
+      return toolName === request.params.name;
+    });
+    if (!entry) {
+      throw new Error(`Tool ${request.params.name} not found or not MCP-enabled`);
+    }
+    try {
+      return await entry.invoke(request.params.arguments);
+    } catch (error) {
+      const message = error && error.message || String(error);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true
+      };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("MCP stdio server started");
+}
+function buildAdapters(tools) {
+  return tools.filter((tool) => isMcpEnabled(tool)).map((tool) => {
+    const httpHandlers = toHttpHandlerMap(tool.httpHandlers);
+    const adapterOptions = {
+      name: tool.metadata?.name || tool.filename,
+      httpHandlers,
+      ...tool.schema ? { schema: tool.schema } : {},
+      ...tool.mcpConfig?.defaultMethod ? { defaultMethod: tool.mcpConfig.defaultMethod } : {}
+    };
+    const adapter = createMcpAdapter(adapterOptions);
+    return {
+      tool,
+      invoke: adapter
+    };
+  });
+}
+async function loadToolsFromDirectory(metadataMap) {
+  const tools = [];
+  const toolsDir = path5.join(process.cwd(), "tools");
+  if (!fs2.existsSync(toolsDir)) {
+    return tools;
+  }
+  const files = fs2.readdirSync(toolsDir);
+  for (const file of files) {
+    if (!isSupportedToolFile(file)) {
+      continue;
+    }
+    const toolPath = path5.join(toolsDir, file);
+    try {
+      const exportsObject = __require(toolPath);
+      const candidate = resolveModuleCandidate(exportsObject);
+      if (!candidate?.schema) {
+        continue;
+      }
+      const baseName = file.replace(/\.[^.]+$/, "");
+      const name = candidate.metadata?.name || baseName;
+      const meta = metadataMap.get(name);
+      let inputSchema = meta?.inputSchema;
+      if (!inputSchema) {
+        try {
+          inputSchema = zodToJsonSchema(candidate.schema, {
+            name: `${name}Schema`,
+            target: "jsonSchema7",
+            $refStrategy: "none"
+          });
+        } catch (error) {
+          inputSchema = { type: "object" };
+        }
+      }
+      inputSchema = normalizeInputSchema(inputSchema);
+      const payment = candidate.payment ?? null;
+      const httpHandlersRaw = collectHttpHandlers(candidate);
+      const httpHandlers = [...httpHandlersRaw];
+      if (httpHandlers.length === 0) {
+        continue;
+      }
+      if (payment) {
+        for (let index = 0; index < httpHandlers.length; index += 1) {
+          const entry = httpHandlers[index];
+          httpHandlers[index] = {
+            ...entry,
+            handler: withPaymentRequirement(entry.handler, payment)
+          };
+        }
+      }
+      const mcpConfig = normalizeRuntimeMcpConfig(candidate.mcp);
+      const adapterOptions = {
+        name,
+        httpHandlers: toHttpHandlerMap(httpHandlers),
+        ...candidate.schema ? { schema: candidate.schema } : {},
+        ...typeof candidate.mcp?.defaultMethod === "string" ? { defaultMethod: candidate.mcp.defaultMethod } : {}
+      };
+      const adapter = createMcpAdapter(adapterOptions);
+      const tool = {
+        ...candidate.schema ? { schema: candidate.schema } : {},
+        inputSchema,
+        metadata: candidate.metadata || meta || null,
+        filename: baseName,
+        httpHandlers,
+        mcpConfig,
+        handler: async (params) => adapter(params),
+        payment
+      };
+      tools.push(tool);
+    } catch (error) {
+      console.warn(`Failed to load tool from ${file}: ${error}`);
+    }
+  }
+  return tools;
+}
+function loadMetadata() {
+  const metadataPath = path5.join(process.cwd(), "metadata.json");
+  if (!fs2.existsSync(metadataPath)) {
+    return null;
+  }
+  try {
+    const contents = fs2.readFileSync(metadataPath, "utf8");
+    return JSON.parse(contents);
+  } catch (error) {
+    console.warn(`Failed to parse metadata.json: ${error}`);
+    return null;
+  }
+}
+function buildMetadataMap(metadata) {
+  const map = /* @__PURE__ */ new Map();
+  if (!metadata?.tools) {
+    return map;
+  }
+  metadata.tools.forEach((tool) => {
+    map.set(tool.name, tool);
+  });
+  return map;
+}
+function serializeTool(tool, metadataMap) {
+  const name = tool.metadata?.name || tool.filename;
+  const meta = metadataMap.get(name);
+  return {
+    name,
+    description: meta?.description || tool.metadata?.description || `${tool.filename} tool`,
+    inputSchema: meta?.inputSchema || tool.inputSchema,
+    annotations: meta?.annotations || tool.metadata?.annotations,
+    payment: meta?.payment || tool.metadata?.payment,
+    discovery: meta?.discovery || tool.metadata?.discovery
+  };
+}
+function isSupportedToolFile(file) {
+  return /\.(cjs|mjs|js|ts)$/i.test(file);
+}
+function resolveModuleCandidate(exportsObject) {
+  if (!exportsObject) {
+    return null;
+  }
+  if (exportsObject.schema) {
+    return exportsObject;
+  }
+  if (exportsObject.default && exportsObject.default.schema) {
+    return exportsObject.default;
+  }
+  return exportsObject;
+}
+function collectHttpHandlers(module) {
+  const handlers = [];
+  HTTP_METHODS.forEach((method) => {
+    const handler = module?.[method];
+    if (typeof handler === "function") {
+      handlers.push({
+        method,
+        handler: async (request) => handler.call(module, request)
+      });
+    }
+  });
+  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 refKey = clone.$ref.replace("#/definitions/", "");
+    if (clone.definitions && typeof clone.definitions[refKey] === "object") {
+      return normalizeInputSchema(clone.definitions[refKey]);
+    }
+  }
+  delete clone.$ref;
+  delete clone.definitions;
+  if (!clone.type) {
+    clone.type = "object";
+  }
+  return clone;
+}
+function normalizeRuntimeMcpConfig(rawConfig) {
+  if (isPlainObject(rawConfig) && rawConfig.enabled === true) {
+    let normalizedMode;
+    if (typeof rawConfig.mode === "string") {
+      const candidate = rawConfig.mode.toLowerCase();
+      if (candidate === "stdio" || candidate === "lambda" || candidate === "dual") {
+        normalizedMode = candidate;
+      } else {
+        throw new Error('mcp.mode must be one of "stdio", "lambda", or "dual"');
+      }
+    }
+    const metadataOverrides = isPlainObject(rawConfig.metadataOverrides) ? rawConfig.metadataOverrides : void 0;
+    const config = { enabled: true };
+    if (normalizedMode) {
+      config.mode = normalizedMode;
+    }
+    if (typeof rawConfig.defaultMethod === "string") {
+      config.defaultMethod = rawConfig.defaultMethod.toUpperCase();
+    }
+    if (metadataOverrides) {
+      config.metadataOverrides = metadataOverrides;
+    }
+    return config;
+  }
+  return null;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMcpEnabled(tool) {
+  return Boolean(tool.mcpConfig?.enabled);
+}
+function resolveRuntimePath(value) {
+  if (value.startsWith("file://")) {
+    return fileURLToPath(value);
+  }
+  return path5.resolve(value);
+}
+
+// src/types/index.ts
+var HTTP_METHODS2 = [
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS"
+];
+var BASE_ALCHEMY_HOST = "https://base-mainnet.g.alchemy.com/v2/";
+var ETHEREUM_ALCHEMY_HOST = "https://eth-mainnet.g.alchemy.com/v2/";
+var BASE_SEPOLIA_ALCHEMY_HOST = "https://base-sepolia.g.alchemy.com/v2/";
+function buildRpcResolver(host, fallbackUrls) {
+  return (options) => {
+    if (options?.url) {
+      return options.url;
+    }
+    if (options?.apiKey) {
+      return `${host}${options.apiKey}`;
+    }
+    if (fallbackUrls.length > 0) {
+      return fallbackUrls[0];
+    }
+    throw new Error(
+      "No RPC URL available: supply a full url via options or an apiKey for the default host"
+    );
+  };
+}
+var chains = {
+  base: {
+    id: base.id,
+    slug: "base",
+    name: "Base",
+    chain: base,
+    rpcUrl: buildRpcResolver(BASE_ALCHEMY_HOST, base.rpcUrls.default.http),
+    publicRpcUrls: base.rpcUrls.default.http
+  },
+  ethereum: {
+    id: mainnet.id,
+    slug: "ethereum",
+    name: "Ethereum",
+    chain: mainnet,
+    rpcUrl: buildRpcResolver(
+      ETHEREUM_ALCHEMY_HOST,
+      mainnet.rpcUrls.default.http
+    ),
+    publicRpcUrls: mainnet.rpcUrls.default.http
+  },
+  baseSepolia: {
+    id: baseSepolia.id,
+    slug: "base-sepolia",
+    name: "Base Sepolia",
+    chain: baseSepolia,
+    rpcUrl: buildRpcResolver(
+      BASE_SEPOLIA_ALCHEMY_HOST,
+      baseSepolia.rpcUrls.default.http
+    )
+  }
+};
+function createNativeToken(chainId, symbol, name) {
+  return {
+    [symbol]: {
+      symbol,
+      name,
+      decimals: 18,
+      address: zeroAddress,
+      chainId,
+      isNative: true
+    }
+  };
+}
+function token(chainId, symbol, name, address, decimals) {
+  return {
+    symbol,
+    name,
+    decimals,
+    address,
+    chainId
+  };
+}
+var tokens = {
+  base: {
+    ...createNativeToken(base.id, "ETH", "Ether"),
+    USDC: token(
+      base.id,
+      "USDC",
+      "USD Coin",
+      "0x833589fCD6eDb6E08f4c7C31c9A8Ba32D74b86B2",
+      6
+    )
+  },
+  ethereum: {
+    ...createNativeToken(mainnet.id, "ETH", "Ether"),
+    USDC: token(
+      mainnet.id,
+      "USDC",
+      "USD Coin",
+      "0xA0b86991c6218b36c1d19d4a2e9Eb0cE3606eB48",
+      6
+    )
+  }
+};
+var DEFAULT_CHAIN = chains.base;
+var DEFAULT_TOKENS = tokens.base;
+var registry = {
+  chains,
+  tokens
+};
+function normalizePrivateKey(raw) {
+  const trimmed = raw.trim();
+  const withPrefix = trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
+  if (!/^0x[0-9a-fA-F]{64}$/.test(withPrefix)) {
+    throw new Error("wallet() privateKey must be a 32-byte hex string");
+  }
+  return withPrefix;
+}
+function createPrivateKeyProvider(config) {
+  const privateKey = normalizePrivateKey(config.privateKey);
+  const account = privateKeyToAccount(privateKey);
+  const transport = http(config.rpcUrl);
+  const publicClient = createPublicClient({
+    chain: config.chain.chain,
+    transport
+  });
+  const walletClient = createWalletClient({
+    account,
+    chain: config.chain.chain,
+    transport
+  });
+  async function sendTransaction(params) {
+    const tx = {
+      account
+    };
+    if (params.to) {
+      tx.to = params.to;
+    }
+    if (params.value !== void 0) {
+      tx.value = params.value;
+    }
+    if (params.data !== void 0) {
+      tx.data = params.data;
+    }
+    return walletClient.sendTransaction(tx);
+  }
+  async function getNativeBalance() {
+    return publicClient.getBalance({ address: account.address });
+  }
+  async function transfer(params) {
+    return sendTransaction({
+      to: params.to,
+      value: params.amount,
+      ...params.data !== void 0 ? { data: params.data } : {}
+    });
+  }
+  return {
+    address: account.address,
+    account,
+    walletClient,
+    publicClient,
+    sendTransaction,
+    getNativeBalance,
+    transfer
+  };
+}
+async function createTurnkeyProvider(config) {
+  const turnkey = new Turnkey({
+    apiBaseUrl: config.apiBaseUrl ?? "https://api.turnkey.com",
+    // The delegated sub-organization the API key pair belongs to.
+    defaultOrganizationId: config.organizationId,
+    apiPublicKey: config.apiPublicKey,
+    apiPrivateKey: config.apiPrivateKey
+  });
+  const account = await createAccount({
+    client: turnkey.apiClient(),
+    organizationId: config.organizationId,
+    signWith: config.signWith
+  });
+  const transport = http(config.rpcUrl);
+  const publicClient = createPublicClient({
+    chain: config.chain.chain,
+    transport
+  });
+  const walletClient = createWalletClient({
+    account,
+    chain: config.chain.chain,
+    transport
+  });
+  async function sendTransaction(params) {
+    const tx = {
+      account
+    };
+    if (params.to) {
+      tx.to = params.to;
+    }
+    if (params.value !== void 0) {
+      tx.value = params.value;
+    }
+    if (params.data !== void 0) {
+      tx.data = params.data;
+    }
+    return walletClient.sendTransaction(tx);
+  }
+  async function getNativeBalance() {
+    return publicClient.getBalance({ address: account.address });
+  }
+  async function transfer(params) {
+    return sendTransaction({
+      to: params.to,
+      value: params.amount,
+      ...params.data !== void 0 ? { data: params.data } : {}
+    });
+  }
+  return {
+    address: account.address,
+    account,
+    walletClient,
+    publicClient,
+    sendTransaction,
+    getNativeBalance,
+    transfer
+  };
+}
+
+// src/wallets/index.ts
+function resolveChainSlug(reference) {
+  if (reference === void 0) {
+    return Object.entries(chains).find(([, meta]) => meta.id === DEFAULT_CHAIN.id)?.[0] || DEFAULT_CHAIN.slug;
+  }
+  if (typeof reference === "number") {
+    const match = Object.entries(chains).find(([, meta]) => meta.id === reference);
+    if (match) {
+      return match[0];
+    }
+  } else if (typeof reference === "string") {
+    const sanitize = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (reference in chains) {
+      return reference;
+    }
+    const normalized = sanitize(reference);
+    const keyMatch = Object.entries(chains).find(([key]) => sanitize(key) === normalized);
+    if (keyMatch) {
+      return keyMatch[0];
+    }
+    const slugMatch = Object.entries(chains).find(([, meta]) => {
+      return meta.slug && sanitize(meta.slug) === normalized;
+    });
+    if (slugMatch) {
+      return slugMatch[0];
+    }
+    const asNumber = Number.parseInt(normalized, 10);
+    if (!Number.isNaN(asNumber)) {
+      const match = Object.entries(chains).find(([, meta]) => meta.id === asNumber);
+      if (match) {
+        return match[0];
+      }
+    }
+  }
+  throw new Error(`Unknown chain reference: ${reference}`);
+}
+function getRpcUrl(chain, options) {
+  const slug = resolveChainSlug(chain);
+  const entry = chains[slug];
+  return entry.rpcUrl(options);
+}
+async function wallet(options = {}) {
+  if (options.privateKey && options.turnkey) {
+    throw new Error("wallet() cannot be initialized with both privateKey and turnkey credentials");
+  }
+  const slug = resolveChainSlug(options.chain);
+  const chain = chains[slug];
+  const tokens2 = tokens[slug] ?? {};
+  const overrides = {};
+  if (options.rpcUrl) {
+    overrides.url = options.rpcUrl;
+  }
+  if (options.apiKey) {
+    overrides.apiKey = options.apiKey;
+  }
+  const rpcUrl = getRpcUrl(slug, overrides);
+  let providerType = "readonly";
+  let signerProvider;
+  if (options.privateKey) {
+    signerProvider = createPrivateKeyProvider({
+      chain,
+      rpcUrl,
+      privateKey: options.privateKey
+    });
+    providerType = "privateKey";
+  } else if (options.turnkey) {
+    const turnkeyConfig = {
+      chain,
+      rpcUrl,
+      organizationId: options.turnkey.organizationId,
+      apiPublicKey: options.turnkey.apiPublicKey,
+      apiPrivateKey: options.turnkey.apiPrivateKey,
+      signWith: options.turnkey.signWith
+    };
+    if (options.turnkey.apiBaseUrl) {
+      turnkeyConfig.apiBaseUrl = options.turnkey.apiBaseUrl;
+    }
+    signerProvider = await createTurnkeyProvider(turnkeyConfig);
+    providerType = "turnkey";
+  }
+  const publicClient = signerProvider?.publicClient ?? createPublicClient({
+    chain: chain.chain,
+    transport: http(rpcUrl)
+  });
+  const baseContext = {
+    chain,
+    tokens: tokens2,
+    rpcUrl,
+    providerType,
+    publicClient,
+    getRpcUrl: (override) => getRpcUrl(slug, override)
+  };
+  if (signerProvider) {
+    const { publicClient: _ignored, ...rest } = signerProvider;
+    return {
+      ...baseContext,
+      ...rest
+    };
+  }
+  return baseContext;
+}
+var walletToolkit = {
+  chains,
+  tokens,
+  registry,
+  defaults: {
+    chain: DEFAULT_CHAIN,
+    tokens: DEFAULT_TOKENS
+  },
+  getRpcUrl,
+  wallet
+};
+
+// src/ai/errors.ts
+var AIError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "AIError";
+    if (options && "cause" in options) {
+      this.cause = options.cause;
+    }
+  }
+};
+var AIFetchError = class extends AIError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "AIFetchError";
+  }
+};
+var AIResponseError = class extends AIError {
+  constructor(details, message) {
+    super(message ?? `AI response error: ${details.status} ${details.statusText}`);
+    this.name = "AIResponseError";
+    this.status = details.status;
+    this.statusText = details.statusText;
+    this.body = details.body;
+    this.headers = details.headers ?? {};
+  }
+};
+var AIAbortError = class extends AIError {
+  constructor(message = "AI request aborted") {
+    super(message);
+    this.name = "AIAbortError";
+  }
+};
+
+// src/ai/config.ts
+var DEFAULT_BASE_URL = "https://gateway.openpond.dev";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_MODEL = "openai/gpt-5-mini";
+function assertFetchAvailable(fetchImplementation) {
+  if (!fetchImplementation) {
+    throw new Error(
+      "No fetch implementation available. Provide one via AIClientConfig.fetchImplementation."
+    );
+  }
+}
+function resolveConfig(config = {}) {
+  const fetchImplementation = config.fetchImplementation ?? globalThis.fetch;
+  assertFetchAvailable(fetchImplementation);
+  const resolved = {
+    baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+    defaultModel: config.defaultModel ?? DEFAULT_MODEL,
+    defaultHeaders: {
+      "Content-Type": "application/json",
+      ...config.defaultHeaders
+    },
+    fetchImplementation,
+    timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  };
+  if (config.apiKey !== void 0) {
+    resolved.apiKey = config.apiKey;
+  }
+  return resolved;
+}
+function mergeHeaders(base2, overrides) {
+  if (!overrides) {
+    return { ...base2 };
+  }
+  const merged = { ...base2 };
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === void 0) {
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+
+// src/ai/models.ts
+var MODEL_REGISTRY = [
+  {
+    name: "openai/gpt-5-mini",
+    label: "OpenAI GPT-5 Mini",
+    provider: "openai",
+    supportsStreaming: true,
+    supportsTools: true,
+    reasoning: true,
+    aliases: ["gpt-5-mini", "gpt5-mini", "gpt-5.0-mini"],
+    default: true
+  },
+  {
+    name: "anthropic/claude-4-sonnet-20250514",
+    label: "Claude 4 Sonnet (20250514)",
+    provider: "anthropic",
+    supportsStreaming: true,
+    supportsTools: true,
+    aliases: ["claude-4-sonnet", "claude-sonnet"]
+  },
+  {
+    name: "google/gemini-2.0-flash-001",
+    label: "Gemini 2.0 Flash",
+    provider: "google",
+    supportsStreaming: true,
+    supportsTools: true,
+    aliases: ["gemini-2.0-flash", "gemini-flash"]
+  },
+  {
+    name: "deepseek/deepseek-chat",
+    label: "DeepSeek Chat",
+    provider: "deepseek",
+    supportsStreaming: true,
+    supportsTools: true,
+    aliases: ["deepseek-chat", "deepseek"]
+  }
+];
+var ALIAS_LOOKUP = MODEL_REGISTRY.reduce(
+  (accumulator, model) => {
+    accumulator[model.name.toLowerCase()] = model.name;
+    if (model.aliases) {
+      for (const alias of model.aliases) {
+        accumulator[alias.toLowerCase()] = model.name;
+      }
+    }
+    return accumulator;
+  },
+  {}
+);
+var DEFAULT_MODEL_NAME = MODEL_REGISTRY.find((model) => model.default)?.name ?? MODEL_REGISTRY[0].name;
+function listModels() {
+  return [...MODEL_REGISTRY];
+}
+function getModelConfig(modelName) {
+  if (!modelName) {
+    return MODEL_REGISTRY.find((model) => model.default) ?? MODEL_REGISTRY[0];
+  }
+  const normalized = normalizeModelName(modelName);
+  return MODEL_REGISTRY.find((model) => model.name === normalized);
+}
+function normalizeModelName(modelName) {
+  if (!modelName) {
+    return DEFAULT_MODEL_NAME;
+  }
+  const trimmed = modelName.trim();
+  if (!trimmed) {
+    return DEFAULT_MODEL_NAME;
+  }
+  const directMatch = ALIAS_LOOKUP[trimmed.toLowerCase()];
+  if (directMatch) {
+    return directMatch;
+  }
+  if (trimmed.includes("/")) {
+    return trimmed;
+  }
+  return `openai/${trimmed}`;
+}
+function isStreamingSupported(modelName) {
+  const config = getModelConfig(modelName);
+  return config ? config.supportsStreaming : true;
+}
+function isToolCallingSupported(modelName) {
+  const config = getModelConfig(modelName);
+  return config ? config.supportsTools : true;
+}
+
+// src/ai/tools.ts
+var WEBSEARCH_TOOL_NAME = "websearch";
+var WEBSEARCH_TOOL_DEFINITION = {
+  type: "function",
+  function: {
+    name: WEBSEARCH_TOOL_NAME,
+    description: "Search the web using the OpenPond search engine. Returns relevant results with titles, URLs, and text content.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of results to return (default: 5)"
+        }
+      },
+      required: ["query"]
+    }
+  }
+};
+function resolveToolset(tools, policy) {
+  if (!policy) {
+    return tools;
+  }
+  const resolved = tools ? [...tools] : [];
+  if (policy.webSearch) {
+    const alreadyIncluded = resolved.some(
+      (tool) => tool.type === "function" && tool.function?.name === WEBSEARCH_TOOL_NAME
+    );
+    if (!alreadyIncluded) {
+      resolved.push(materializeWebSearchTool(policy.webSearch));
+    }
+  }
+  return resolved.length > 0 ? resolved : void 0;
+}
+function materializeWebSearchTool(options) {
+  if (!options || Object.keys(options).length === 0) {
+    return WEBSEARCH_TOOL_DEFINITION;
+  }
+  const baseParameters = WEBSEARCH_TOOL_DEFINITION.function.parameters ?? {};
+  const baseProperties = baseParameters.properties ?? {};
+  const properties = { ...baseProperties };
+  if (options.limit !== void 0) {
+    const existingLimit = baseProperties["limit"];
+    const limitSchema = typeof existingLimit === "object" && existingLimit !== null ? { ...existingLimit } : {
+      type: "number",
+      description: "Maximum number of results to return (default: 5)"
+    };
+    limitSchema.default = options.limit;
+    properties.limit = limitSchema;
+  }
+  if (options.includeImages) {
+    properties.includeImages = {
+      type: "boolean",
+      description: "Whether to include representative images in results.",
+      default: true
+    };
+  }
+  return {
+    ...WEBSEARCH_TOOL_DEFINITION,
+    function: {
+      ...WEBSEARCH_TOOL_DEFINITION.function,
+      parameters: {
+        ...WEBSEARCH_TOOL_DEFINITION.function.parameters,
+        properties
+      }
+    }
+  };
+}
+
+// src/ai/messages.ts
+function flattenMessageContent(content, options = {}) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  const separator = options.separator ?? "";
+  const collected = [];
+  for (const part of content) {
+    const text = extractTextPart(part, options);
+    if (text) {
+      collected.push(text);
+    }
+  }
+  if (collected.length === 0) {
+    return void 0;
+  }
+  return collected.join(separator);
+}
+function ensureTextContent(message, options) {
+  const flattened = flattenMessageContent(message.content, options);
+  if (flattened !== void 0) {
+    return flattened;
+  }
+  throw new AIError(
+    options?.errorMessage ?? "Assistant response did not contain textual content."
+  );
+}
+function extractTextPart(part, options) {
+  if (!part || typeof part !== "object") {
+    return void 0;
+  }
+  if ("text" in part && typeof part.text === "string") {
+    return part.text;
+  }
+  if (options.includeUnknown) {
+    try {
+      return JSON.stringify(part);
+    } catch (error) {
+      return `[unserializable_part: ${String(error)}]`;
+    }
+  }
+  return void 0;
+}
+
+// src/ai/client.ts
+var CHAT_COMPLETIONS_PATH = "/v1/chat/completions";
+function createAIClient(config = {}) {
+  const resolved = resolveConfig(config);
+  return {
+    get config() {
+      return resolved;
+    },
+    async generateText(options) {
+      return generateText(options, config);
+    },
+    async streamText(options) {
+      return streamText(options, config);
+    },
+    listModels
+  };
+}
+async function generateText(options, clientConfig = {}) {
+  const resolved = resolveConfig(clientConfig);
+  const model = normalizeModelName(options.model ?? resolved.defaultModel);
+  const payload = buildRequestPayload(options, model, {
+    allowTools: isToolCallingSupported(model)
+  });
+  const headers = mergeHeaders(resolved.defaultHeaders, options.headers);
+  if (resolved.apiKey) {
+    headers.Authorization = `Bearer ${resolved.apiKey}`;
+  }
+  const endpoint = buildUrl(resolved.baseUrl, CHAT_COMPLETIONS_PATH);
+  const abortBundle = createAbortBundle(
+    options.abortSignal,
+    options.timeoutMs ?? resolved.timeoutMs
+  );
+  let response;
+  try {
+    response = await resolved.fetchImplementation(endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: abortBundle.signal
+    });
+  } catch (error) {
+    if (abortBundle.signal.aborted) {
+      throw toAbortError(abortBundle.signal.reason ?? error);
+    }
+    throw new AIFetchError("Failed to reach AI gateway", { cause: error });
+  } finally {
+    abortBundle.cleanup();
+  }
+  if (!response.ok) {
+    const errorBody = await safeParseJson(response);
+    throw new AIResponseError({
+      status: response.status,
+      statusText: response.statusText,
+      body: errorBody,
+      headers: collectHeaders(response.headers)
+    });
+  }
+  const data = await response.json();
+  const primaryChoice = data.choices.find(isPrimaryChoice);
+  if (!primaryChoice) {
+    throw new AIResponseError(
+      {
+        status: response.status,
+        statusText: response.statusText,
+        body: data
+      },
+      "Gateway response did not contain a valid choice"
+    );
+  }
+  const result = {
+    id: data.id,
+    model: data.model,
+    message: primaryChoice.message,
+    raw: data
+  };
+  if (primaryChoice.finish_reason !== void 0) {
+    result.finishReason = primaryChoice.finish_reason;
+  }
+  if (data.usage) {
+    result.usage = data.usage;
+  }
+  return result;
+}
+async function streamText(options, clientConfig = {}) {
+  const resolved = resolveConfig(clientConfig);
+  const model = normalizeModelName(options.model ?? resolved.defaultModel);
+  const streamExtras = buildStreamMetadataExtras(options);
+  const payload = buildRequestPayload(
+    options,
+    model,
+    {
+      allowTools: isToolCallingSupported(model)
+    },
+    streamExtras
+  );
+  payload.stream = true;
+  if (options.includeUsage) {
+    payload.stream_options = { include_usage: true };
+  }
+  const headers = mergeHeaders(resolved.defaultHeaders, options.headers);
+  if (resolved.apiKey) {
+    headers.Authorization = `Bearer ${resolved.apiKey}`;
+  }
+  const endpoint = buildUrl(resolved.baseUrl, CHAT_COMPLETIONS_PATH);
+  const abortBundle = createAbortBundle(
+    options.abortSignal,
+    options.timeoutMs ?? resolved.timeoutMs
+  );
+  let response;
+  try {
+    response = await resolved.fetchImplementation(endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: abortBundle.signal
+    });
+  } catch (error) {
+    if (abortBundle.signal.aborted) {
+      throw toAbortError(abortBundle.signal.reason ?? error);
+    }
+    throw new AIFetchError("Failed to reach AI gateway", { cause: error });
+  }
+  if (!response.ok) {
+    const errorBody = await safeParseJson(response);
+    abortBundle.cleanup();
+    throw new AIResponseError({
+      status: response.status,
+      statusText: response.statusText,
+      body: errorBody,
+      headers: collectHeaders(response.headers)
+    });
+  }
+  if (!response.body) {
+    abortBundle.cleanup();
+    throw new AIFetchError("Streaming response did not include a readable body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const handlers = options.handlers ?? {};
+  let finishedResolve;
+  let finishedReject;
+  const finished = new Promise((resolve4, reject) => {
+    finishedResolve = resolve4;
+    finishedReject = reject;
+  });
+  let settled = false;
+  const resolveStream = () => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    try {
+      handlers.onDone?.();
+      finishedResolve();
+    } catch (error) {
+      settled = false;
+      rejectStream(error);
+    }
+  };
+  const rejectStream = (reason) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    try {
+      handlers.onError?.(reason);
+    } catch (handlerError) {
+      reason = handlerError;
+    }
+    finishedReject(reason);
+  };
+  const abort = () => abortBundle.abort();
+  (async () => {
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          buffer += decoder.decode();
+          buffer = buffer.replace(/\r\n/g, "\n");
+          if (buffer.trim().length > 0) {
+            if (processStreamEventChunk(buffer, handlers)) {
+              break;
+            }
+          }
+          resolveStream();
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        buffer = buffer.replace(/\r\n/g, "\n");
+        let boundaryIndex;
+        while ((boundaryIndex = buffer.indexOf("\n\n")) !== -1) {
+          const chunk = buffer.slice(0, boundaryIndex);
+          buffer = buffer.slice(boundaryIndex + 2);
+          if (!chunk) {
+            continue;
+          }
+          if (processStreamEventChunk(chunk, handlers)) {
+            await reader.cancel().catch(() => void 0);
+            resolveStream();
+            return;
+          }
+        }
+      }
+    } catch (error) {
+      if (abortBundle.signal.aborted) {
+        rejectStream(toAbortError(abortBundle.signal.reason ?? error));
+      } else {
+        rejectStream(error);
+      }
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch (error) {
+      }
+      abortBundle.cleanup();
+    }
+  })().catch((error) => {
+    rejectStream(error);
+  });
+  return {
+    abort,
+    finished
+  };
+  function processStreamEventChunk(chunk, eventHandlers) {
+    const dataString = extractSseData(chunk);
+    if (dataString == null) {
+      return false;
+    }
+    const trimmed = dataString.trim();
+    if (trimmed === "[DONE]") {
+      return true;
+    }
+    let payload2;
+    try {
+      payload2 = JSON.parse(dataString);
+    } catch (error) {
+      rejectStream(new AIError("Failed to parse streaming payload", { cause: error }));
+      return true;
+    }
+    try {
+      handleStreamPayload(payload2, eventHandlers);
+    } catch (error) {
+      rejectStream(error);
+      return true;
+    }
+    return false;
+  }
+  function handleStreamPayload(payload2, eventHandlers) {
+    if (!payload2 || typeof payload2 !== "object") {
+      return;
+    }
+    if ("error" in payload2 && payload2.error) {
+      const message = typeof payload2.error === "string" ? payload2.error : payload2.error.message;
+      throw new AIError(message ?? "AI stream returned an error payload");
+    }
+    const structured = payload2;
+    if (Array.isArray(structured.choices)) {
+      for (const choice of structured.choices) {
+        if (!choice || typeof choice !== "object") {
+          continue;
+        }
+        const delta = choice.delta;
+        if (!delta || typeof delta !== "object") {
+          continue;
+        }
+        const deltaObject = delta;
+        const textDelta = extractDeltaText(deltaObject.content);
+        if (textDelta) {
+          eventHandlers.onTextDelta?.(textDelta);
+        }
+        const reasoningDelta = extractDeltaText(deltaObject.reasoning);
+        if (reasoningDelta) {
+          eventHandlers.onReasoningDelta?.(reasoningDelta);
+        }
+        if (deltaObject.tool_calls !== void 0) {
+          eventHandlers.onToolCallDelta?.(deltaObject.tool_calls);
+        }
+      }
+    }
+    if (structured.usage) {
+      eventHandlers.onUsage?.(structured.usage);
+    }
+  }
+  function extractDeltaText(value) {
+    if (!value) {
+      return void 0;
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return flattenMessageContent(value);
+    }
+    if (typeof value === "object" && value !== null && "content" in value && Array.isArray(value.content)) {
+      return flattenMessageContent(
+        value.content ?? []
+      );
+    }
+    return void 0;
+  }
+  function extractSseData(chunk) {
+    const lines = chunk.split("\n");
+    const dataLines = [];
+    for (const rawLine of lines) {
+      if (!rawLine) {
+        continue;
+      }
+      const match = /^data:(.*)$/.exec(rawLine);
+      if (!match) {
+        continue;
+      }
+      const value = match[1];
+      dataLines.push(value.startsWith(" ") ? value.slice(1) : value);
+    }
+    if (dataLines.length === 0) {
+      return null;
+    }
+    return dataLines.join("\n");
+  }
+}
+function buildStreamMetadataExtras(options) {
+  const streamConfig = {};
+  if (options.sendReasoning !== void 0) {
+    streamConfig.sendReasoning = options.sendReasoning;
+  }
+  if (options.includeUsage !== void 0) {
+    streamConfig.includeUsage = options.includeUsage;
+  }
+  if (Object.keys(streamConfig).length === 0) {
+    return void 0;
+  }
+  return {
+    openpond: {
+      stream: streamConfig
+    }
+  };
+}
+function buildRequestPayload(options, model, capabilities, metadataExtras) {
+  const payload = {
+    model,
+    messages: options.messages
+  };
+  const generation = options.generation ?? {};
+  assignIfDefined(payload, "temperature", generation.temperature);
+  assignIfDefined(payload, "top_p", generation.topP);
+  assignIfDefined(payload, "max_tokens", generation.maxTokens);
+  assignIfDefined(payload, "stop", generation.stop);
+  assignIfDefined(
+    payload,
+    "frequency_penalty",
+    generation.frequencyPenalty
+  );
+  assignIfDefined(payload, "presence_penalty", generation.presencePenalty);
+  assignIfDefined(payload, "response_format", generation.responseFormat);
+  const toolExecution = options.toolExecution;
+  const enableTools = toolExecution?.enableTools ?? true;
+  if (enableTools && capabilities.allowTools) {
+    const resolvedTools = resolveToolset(options.tools, toolExecution);
+    assignIfDefined(payload, "tools", resolvedTools);
+    assignIfDefined(payload, "tool_choice", options.toolChoice);
+  } else if (options.toolChoice && options.toolChoice !== "none") {
+    payload.tool_choice = "none";
+  }
+  const metadataPayload = buildMetadataPayload(
+    options.metadata,
+    toolExecution,
+    metadataExtras
+  );
+  if (metadataPayload) {
+    payload.metadata = metadataPayload;
+  }
+  return payload;
+}
+function assignIfDefined(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+function buildUrl(baseUrl, path7) {
+  const sanitizedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return `${sanitizedBase}${path7}`;
+}
+function createAbortBundle(upstreamSignal, timeoutMs) {
+  const controller = new AbortController();
+  const cleanupCallbacks = [];
+  if (upstreamSignal) {
+    if (upstreamSignal.aborted) {
+      controller.abort(upstreamSignal.reason);
+    } else {
+      const onAbort = () => controller.abort(upstreamSignal.reason);
+      upstreamSignal.addEventListener("abort", onAbort, { once: true });
+      cleanupCallbacks.push(
+        () => upstreamSignal.removeEventListener("abort", onAbort)
+      );
+    }
+  }
+  if (timeoutMs && timeoutMs > 0) {
+    const timeoutId = setTimeout(() => {
+      controller.abort(new Error("AI request timed out"));
+    }, timeoutMs);
+    cleanupCallbacks.push(() => clearTimeout(timeoutId));
+  }
+  return {
+    signal: controller.signal,
+    abort: () => controller.abort(),
+    cleanup: () => {
+      cleanupCallbacks.forEach((fn) => fn());
+    }
+  };
+}
+function collectHeaders(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function buildMetadataPayload(base2, toolExecution, extras) {
+  const metadata = base2 ? { ...base2 } : {};
+  if (extras) {
+    for (const [key, value] of Object.entries(extras)) {
+      if (value === void 0) {
+        continue;
+      }
+      if (key === "openpond" && typeof value === "object" && value !== null) {
+        const existing = {
+          ...metadata.openpond ?? {}
+        };
+        metadata.openpond = {
+          ...existing,
+          ...value
+        };
+      } else {
+        metadata[key] = value;
+      }
+    }
+  }
+  if (toolExecution) {
+    const openpond = {
+      ...metadata.openpond ?? {},
+      toolExecution
+    };
+    metadata.openpond = openpond;
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+async function safeParseJson(response) {
+  const contentType = response.headers.get("content-type");
+  if (!contentType || !contentType.includes("application/json")) {
+    return void 0;
+  }
+  try {
+    return await response.json();
+  } catch (error) {
+    return { error: "Failed to parse error body", cause: String(error) };
+  }
+}
+function isPrimaryChoice(choice) {
+  return choice.index === 0 || choice.message !== void 0;
+}
+function toAbortError(reason) {
+  if (reason instanceof AIAbortError) {
+    return reason;
+  }
+  if (reason instanceof Error) {
+    if (reason.name === "AbortError") {
+      return new AIAbortError(reason.message || "AI request aborted");
+    }
+    return new AIAbortError(reason.message);
+  }
+  return new AIAbortError(String(reason ?? "AI request aborted"));
+}
+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();
+function resolveTsconfig(projectRoot) {
+  const candidate = path5.join(projectRoot, "tsconfig.json");
+  if (fs2.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 ?? fs2.mkdtempSync(path5.join(tmpdir(), "opentool-"));
+  if (!fs2.existsSync(tempBase)) {
+    fs2.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 (!fs2.existsSync(packageJsonPath)) {
+      fs2.writeFileSync(packageJsonPath, JSON.stringify({ type: "module" }), "utf8");
+    }
+  }
+  const cleanup = () => {
+    if (options.outDir) {
+      return;
+    }
+    fs2.rmSync(tempBase, { recursive: true, force: true });
+  };
+  return { outDir: tempBase, cleanup };
+}
+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 (!fs2.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 (fs2.existsSync(tempDir)) {
+    fs2.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 (fs2.existsSync(tempDir)) {
+      fs2.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 (!fs2.existsSync(packagePath)) {
+    return {};
+  }
+  try {
+    const content = fs2.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 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 (!fs2.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 loadAndValidateTools(toolsDir, options = {}) {
+  const files = fs2.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 (fs2.existsSync(tempDir)) {
+    fs2.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 (!fs2.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 = normalizeInputSchema2(inputSchemaRaw);
+      const httpHandlersRaw = collectHttpHandlers2(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 = toHttpHandlerMap2(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 (fs2.existsSync(tempDir)) {
+      fs2.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_METHODS2.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 collectHttpHandlers2(module, filename) {
+  const handlers = [];
+  for (const method of HTTP_METHODS2) {
+    const handler = module?.[method];
+    if (typeof handler === "function") {
+      handlers.push({
+        method,
+        handler: async (request) => handler.call(module, request)
+      });
+    }
+  }
+  handlers.sort((a, b) => HTTP_METHODS2.indexOf(a.method) - HTTP_METHODS2.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 toHttpHandlerMap2(handlers) {
+  return handlers.reduce((acc, handler) => {
+    acc[handler.method.toUpperCase()] = handler.handler;
+    return acc;
+  }, {});
+}
+function normalizeInputSchema2(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 normalizeInputSchema2(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 (!isPlainObject2(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 = isPlainObject2(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 isPlainObject2(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/generate-metadata.ts
+async function generateMetadataCommand(options) {
+  const startTimestamp = timestamp();
+  console.log(`[${startTimestamp}] Generating OpenTool metadata...`);
+  try {
+    const result = await generateMetadata(options);
+    const endTimestamp = timestamp();
+    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 = timestamp();
+    console.error(`[${endTimestamp}] Metadata generation failed:`, error);
+    process.exit(1);
+  }
+}
+async function generateMetadata(options) {
+  const toolsDir = path5.resolve(options.input);
+  if (!fs2.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");
+  fs2.writeFileSync(outputPath, JSON.stringify(metadata, null, 2));
+  return {
+    metadata,
+    defaultsApplied,
+    tools,
+    outputPath
+  };
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+}
+
+export { AIAbortError, AIError, AIFetchError, AIResponseError, DEFAULT_BASE_URL, DEFAULT_CHAIN, DEFAULT_MODEL, DEFAULT_TIMEOUT_MS, DEFAULT_TOKENS, HEADER_PAYMENT_RESPONSE, HTTP_METHODS2 as HTTP_METHODS, PAYMENT_HEADERS, PAYMENT_SCHEMA_VERSION, PaymentRequiredError, WEBSEARCH_TOOL_DEFINITION, WEBSEARCH_TOOL_NAME, chains, createAIClient, createDevServer, createMcpAdapter, createPaymentRequiredBody, createPaymentResponseHeader, createStdioServer, cryptoAssetSchema, currencySchema, decimalStringSchema, definePayment, directPaymentPayloadSchema, directProofSchema, ensureTextContent, extractPaymentAttempts, facilitatorConfigSchema, flattenMessageContent, generateMetadata, generateMetadataCommand, generateText, getModelConfig, getPaymentContext, getRpcUrl, isStreamingSupported, isToolCallingSupported, listModels, loadAndValidateTools, normalizeModelName, paymentAmountSchema, paymentFailureSchema, paymentFieldSchema, paymentOptionSchema, paymentProofSchema, paymentRequiredResponse, paymentRequirementsSchema, paymentSchemaVersionSchema, paymentSuccessMetadataSchema, registry, requirePayment, resolveConfig, resolveRuntimePath, resolveToolset, responseToToolResponse, settlementTermsSchema, streamText, tokens, validateCommand, verifyPayment, wallet, walletToolkit, withPaymentRequirement, x402PaymentHeaderSchema, x402ProofSchema };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map