@probemesh/sdk 0.1.0

package/dist/chunk-TV42EZSI.js

@@ -0,0 +1,2157 @@
+import {
+  createProbeMeshCallAuditArtifact
+} from "./chunk-5Q3PDYIA.js";
+import {
+  verifyProviderCatalogPolicyBundleRuntime
+} from "./chunk-CXZOO3U4.js";
+import {
+  assertProviderCatalog,
+  findProviderCatalogMatches
+} from "./chunk-ZJOLPBJJ.js";
+import {
+  mergePaymentPreferences,
+  paymentSelectionToCost,
+  resolveProviderPaymentOption,
+  validatePaymentPreferences,
+  validatePaymentStrategy
+} from "./chunk-3H7UGVI6.js";
+import {
+  ProbeMeshError,
+  isProbeMeshError
+} from "./chunk-2ASMVLG4.js";
+
+// src/client.ts
+import { randomUUID } from "crypto";
+function createProbeMesh(options) {
+  validateClientOptions(options);
+  if (options.hosted) {
+    return createHostedProbeMeshClient(options.hosted);
+  }
+  const adapters = [...options.adapters];
+  return {
+    async call(request) {
+      validateCallRequest(request);
+      const callId = request.idempotencyKey ?? generateCallId();
+      const startedAt = /* @__PURE__ */ new Date();
+      const startTimeMs = Date.now();
+      const adapterSelection = selectAdapter(adapters, request);
+      const adapter = adapterSelection?.adapter;
+      const paymentSelection = adapterSelection?.paymentSelection;
+      const abortController = new AbortController();
+      if (!adapter) {
+        throw new ProbeMeshError({
+          code: "provider_unavailable",
+          message: `No adapter is available for capability "${request.capability}".`,
+          capability: request.capability,
+          callId
+        });
+      }
+      enforceBudget(
+        request.constraints,
+        adapter,
+        request.capability,
+        callId,
+        paymentSelection
+      );
+      try {
+        const result = await withLatencyLimit(
+          adapter.call(
+            {
+              ...request,
+              callId
+            },
+            {
+              callId,
+              startedAt,
+              signal: abortController.signal,
+              constraints: request.constraints,
+              providerPreferences: request.providerPreferences,
+              paymentPreferences: request.paymentPreferences,
+              paymentStrategy: request.paymentStrategy,
+              paymentSelection
+            }
+          ),
+          request,
+          adapter,
+          callId,
+          abortController
+        );
+        const normalizedResult = validateAdapterResult(
+          result,
+          adapter,
+          request.capability,
+          callId
+        );
+        const receiptRefs = normalizedResult.receiptRefs ?? [];
+        if (request.constraints?.requireReceipt && receiptRefs.length === 0) {
+          throw new ProbeMeshError({
+            code: "receipt_missing",
+            message: `Adapter "${adapter.id}" did not return a receipt for capability "${request.capability}".`,
+            capability: request.capability,
+            provider: adapter.id,
+            callId
+          });
+        }
+        return {
+          callId,
+          capability: request.capability,
+          data: normalizedResult.data,
+          provider: {
+            id: normalizedResult.provider?.id ?? adapter.id,
+            mode: normalizedResult.provider?.mode ?? adapter.mode ?? "local",
+            displayName: normalizedResult.provider?.displayName ?? adapter.displayName
+          },
+          cost: normalizedResult.cost ?? paymentSelectionToCost(paymentSelection) ?? pricingToCost(getPricing(adapter, request.capability)),
+          latencyMs: Date.now() - startTimeMs,
+          receiptRefs,
+          safety: normalizedResult.safety,
+          status: "completed"
+        };
+      } catch (error) {
+        if (isProbeMeshError(error)) {
+          throw error;
+        }
+        throw new ProbeMeshError({
+          code: "provider_unavailable",
+          message: `Adapter "${adapter.id}" failed while handling capability "${request.capability}".`,
+          capability: request.capability,
+          provider: adapter.id,
+          callId,
+          cause: error
+        });
+      }
+    },
+    async retry() {
+      throw new ProbeMeshError({
+        code: "invalid_request",
+        message: "ProbeMesh retry is only available for hosted clients."
+      });
+    }
+  };
+}
+function createHostedProbeMeshClient(options) {
+  const endpoint = new URL("/v1/calls", ensureTrailingSlash(options.baseUrl));
+  return {
+    async call(request) {
+      validateCallRequest(request);
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...options.apiKey ? {
+            authorization: `Bearer ${options.apiKey}`
+          } : {}
+        },
+        body: JSON.stringify(request)
+      });
+      const body = await readHostedJson(response);
+      if (!response.ok) {
+        throw hostedErrorToProbeMeshError(body, response.status);
+      }
+      return validateHostedResponse(body);
+    },
+    async retry(request) {
+      validateRetryRequest(request);
+      const retryEndpoint = new URL(
+        `/v1/calls/${encodeURIComponent(request.callId)}/retry`,
+        ensureTrailingSlash(options.baseUrl)
+      );
+      const response = await fetch(retryEndpoint, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...options.apiKey ? {
+            authorization: `Bearer ${options.apiKey}`
+          } : {}
+        },
+        body: JSON.stringify({
+          idempotencyKey: request.idempotencyKey
+        })
+      });
+      const body = await readHostedJson(response);
+      if (!response.ok) {
+        throw hostedErrorToProbeMeshError(body, response.status);
+      }
+      return validateHostedResponse(body);
+    }
+  };
+}
+function validateClientOptions(options) {
+  if (!options || typeof options !== "object") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "ProbeMesh client options must be an object."
+    });
+  }
+  const hasAdapters = options.adapters !== void 0;
+  const hasHosted = options.hosted !== void 0;
+  if (hasAdapters && hasHosted) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Use either adapters or hosted options, not both."
+    });
+  }
+  if (!hasAdapters && !hasHosted) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "ProbeMesh client requires adapters or hosted options."
+    });
+  }
+  if (hasAdapters && !Array.isArray(options.adapters)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "adapters must be an array when provided."
+    });
+  }
+  if (hasHosted) {
+    validateHostedOptions(options.hosted);
+  }
+}
+function validateHostedOptions(hosted) {
+  if (!hosted || typeof hosted !== "object") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "hosted options must be an object."
+    });
+  }
+  if (typeof hosted.baseUrl !== "string" || hosted.baseUrl.length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "hosted.baseUrl must be a non-empty string."
+    });
+  }
+  if (hosted.apiKey !== void 0 && typeof hosted.apiKey !== "string") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "hosted.apiKey must be a string when provided."
+    });
+  }
+}
+async function readHostedJson(response) {
+  const text = await response.text();
+  if (text.length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: `Hosted router returned invalid JSON with status ${response.status}.`,
+      cause: error
+    });
+  }
+}
+function validateHostedResponse(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "Hosted router response must be an object."
+    });
+  }
+  const response = body;
+  if (typeof response.callId !== "string" || typeof response.capability !== "string" || !("data" in response) || !response.provider || typeof response.provider !== "object" || typeof response.latencyMs !== "number" || !Array.isArray(response.receiptRefs) || response.status !== "completed") {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "Hosted router response does not match ProbeMesh call response shape."
+    });
+  }
+  if (response.safety !== void 0) {
+    validateHostedSafety(response.safety);
+  }
+  if (response.attempt !== void 0) {
+    validateHostedAttempt(response.attempt);
+  }
+  if (response.route !== void 0) {
+    validateHostedRoute(response.route);
+  }
+  return response;
+}
+function hostedErrorToProbeMeshError(body, statusCode) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return new ProbeMeshError({
+      code: "provider_unavailable",
+      message: `Hosted router returned HTTP ${statusCode}.`
+    });
+  }
+  const error = body;
+  return new ProbeMeshError({
+    code: normalizeHostedErrorCode(error.code),
+    message: error.message ?? `Hosted router returned HTTP ${statusCode}.`,
+    capability: error.capability,
+    provider: error.provider,
+    callId: error.callId,
+    receiptRefs: validateHostedReceiptRefs(error.receiptRefs),
+    safety: validateHostedSafety(error.safety),
+    timeline: validateHostedTimeline(error.timeline),
+    retrySafety: validateHostedRetrySafety(error.retrySafety),
+    attempt: validateHostedAttempt(error.attempt),
+    route: validateHostedRoute(error.route)
+  });
+}
+function normalizeHostedErrorCode(code) {
+  const knownCodes = /* @__PURE__ */ new Set([
+    "unauthorized",
+    "invalid_request",
+    "budget_exceeded",
+    "provider_unavailable",
+    "retry_not_available",
+    "payment_failed",
+    "receipt_missing",
+    "timeout_after_payment",
+    "charged_but_no_result",
+    "provider_timeout",
+    "invalid_provider_response"
+  ]);
+  return code && knownCodes.has(code) ? code : "provider_unavailable";
+}
+function ensureTrailingSlash(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+function validateAdapterResult(result, adapter, capability, callId) {
+  if (!result || typeof result !== "object") {
+    throw invalidProviderResponse(
+      adapter,
+      capability,
+      callId,
+      "Adapter result must be an object."
+    );
+  }
+  const candidate = result;
+  if (!("data" in candidate)) {
+    throw invalidProviderResponse(
+      adapter,
+      capability,
+      callId,
+      "Adapter result requires data."
+    );
+  }
+  if (candidate.cost !== void 0) {
+    validateCost(candidate.cost, adapter, capability, callId);
+  }
+  if (candidate.receiptRefs !== void 0) {
+    validateReceiptRefs(candidate.receiptRefs, adapter, capability, callId);
+  }
+  if (candidate.safety !== void 0) {
+    validateAdapterSafety(candidate.safety, adapter, capability, callId);
+  }
+  if (candidate.provider !== void 0 && (!candidate.provider || typeof candidate.provider !== "object")) {
+    throw invalidProviderResponse(
+      adapter,
+      capability,
+      callId,
+      "Adapter provider metadata must be an object when provided."
+    );
+  }
+  return {
+    data: candidate.data,
+    cost: candidate.cost,
+    receiptRefs: candidate.receiptRefs,
+    safety: candidate.safety,
+    provider: candidate.provider
+  };
+}
+function validateCost(cost, adapter, capability, callId) {
+  if (!cost || typeof cost !== "object") {
+    throw invalidProviderResponse(
+      adapter,
+      capability,
+      callId,
+      "Adapter cost must be an object when provided."
+    );
+  }
+  if (!Number.isFinite(cost.amountUsd) || cost.amountUsd < 0) {
+    throw invalidProviderResponse(
+      adapter,
+      capability,
+      callId,
+      "Adapter cost.amountUsd must be a non-negative number."
+    );
+  }
+}
+function validateAdapterSafety(safety, adapter, capability, callId) {
+  if (!isValidSafety(safety)) {
+    throw invalidProviderResponse(
+      adapter,
+      capability,
+      callId,
+      "Adapter safety metadata must match ProbeMeshCallSafety."
+    );
+  }
+}
+function validateHostedSafety(safety) {
+  if (safety === void 0) {
+    return void 0;
+  }
+  if (!isValidSafety(safety)) {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "Hosted router safety metadata does not match ProbeMeshCallSafety."
+    });
+  }
+  return safety;
+}
+function validateHostedReceiptRefs(receiptRefs) {
+  if (receiptRefs === void 0) {
+    return void 0;
+  }
+  if (!isValidReceiptRefs(receiptRefs)) {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "Hosted router error receiptRefs do not match ReceiptRef[]."
+    });
+  }
+  return receiptRefs;
+}
+function validateHostedTimeline(timeline) {
+  if (timeline === void 0) {
+    return void 0;
+  }
+  if (!timeline || typeof timeline !== "object" || Array.isArray(timeline) || typeof timeline.routeId !== "string" || !Array.isArray(timeline.events)) {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "Hosted router timeline does not match ProbeMeshCallTimeline."
+    });
+  }
+  return timeline;
+}
+function validateHostedRetrySafety(retrySafety) {
+  if (retrySafety === void 0) {
+    return void 0;
+  }
+  if (!retrySafety || typeof retrySafety !== "object" || Array.isArray(retrySafety) || typeof retrySafety.retryable !== "boolean" || typeof retrySafety.safeToAutoRetry !== "boolean" || !isRetrySafetyReason(
+    retrySafety.reason
+  )) {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "Hosted router retrySafety does not match ProbeMeshRetrySafety."
+    });
+  }
+  return retrySafety;
+}
+function validateHostedAttempt(attempt) {
+  if (attempt === void 0) {
+    return void 0;
+  }
+  if (!isValidAttempt(attempt)) {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "Hosted router attempt metadata does not match ProbeMeshAttemptMetadata."
+    });
+  }
+  return attempt;
+}
+function validateHostedRoute(route) {
+  if (route === void 0) {
+    return void 0;
+  }
+  if (!route || typeof route !== "object" || Array.isArray(route) || typeof route.routeId !== "string" || typeof route.mode !== "string" || route.selectedProviderId !== void 0 && typeof route.selectedProviderId !== "string" || route.explanation !== void 0 && !isValidRouteExplanation(
+    route.explanation
+  )) {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "Hosted router route metadata does not match ProbeMeshRouteMetadata."
+    });
+  }
+  return route;
+}
+function isValidRouteExplanation(explanation) {
+  if (!explanation || typeof explanation !== "object" || Array.isArray(explanation)) {
+    return false;
+  }
+  const candidate = explanation;
+  return Array.isArray(candidate.consideredProviders) && candidate.consideredProviders.every((provider) => typeof provider === "string") && (candidate.selectedProviderId === void 0 || typeof candidate.selectedProviderId === "string") && typeof candidate.fallbackUsed === "boolean" && typeof candidate.fallbackCount === "number" && typeof candidate.stopReason === "string" && Array.isArray(candidate.attempts) && candidate.attempts.every(
+    (attempt) => attempt && typeof attempt === "object" && !Array.isArray(attempt) && typeof attempt.providerId === "string" && typeof attempt.status === "string" && typeof attempt.reason === "string"
+  );
+}
+function isValidAttempt(attempt) {
+  if (!attempt || typeof attempt !== "object" || Array.isArray(attempt)) {
+    return false;
+  }
+  const candidate = attempt;
+  return typeof candidate.originalCallId === "string" && candidate.originalCallId.length > 0 && typeof candidate.attemptId === "string" && candidate.attemptId.length > 0 && typeof candidate.attemptNumber === "number" && Number.isInteger(candidate.attemptNumber) && candidate.attemptNumber > 0 && typeof candidate.isRetry === "boolean" && (candidate.previousAttemptId === void 0 || typeof candidate.previousAttemptId === "string");
+}
+function isValidSafety(safety) {
+  if (!safety || typeof safety !== "object" || Array.isArray(safety)) {
+    return false;
+  }
+  const candidate = safety;
+  return (candidate.paymentAttemptId === void 0 || typeof candidate.paymentAttemptId === "string") && isPaymentStatus(candidate.paymentStatus) && isSettlementStatus(candidate.settlementStatus) && isDeliveryStatus(candidate.deliveryStatus) && typeof candidate.moneyMayHaveMoved === "boolean";
+}
+function isValidReceiptRefs(receiptRefs) {
+  return Array.isArray(receiptRefs) && receiptRefs.every(
+    (receiptRef) => receiptRef && typeof receiptRef === "object" && !Array.isArray(receiptRef) && typeof receiptRef.type === "string" && typeof receiptRef.provider === "string" && typeof receiptRef.status === "string" && typeof receiptRef.ref === "string" && typeof receiptRef.timestamp === "string"
+  );
+}
+function isRetrySafetyReason(value) {
+  return value === "completed" || value === "not_retryable" || value === "money_may_have_moved" || value === "payment_failed_no_charge" || value === "no_payment_attempted" || value === "unknown_payment_state";
+}
+function isPaymentStatus(value) {
+  return value === "not_attempted" || value === "authorized" || value === "failed";
+}
+function isSettlementStatus(value) {
+  return value === "not_attempted" || value === "settled" || value === "failed";
+}
+function isDeliveryStatus(value) {
+  return value === "not_attempted" || value === "delivered" || value === "failed" || value === "missing";
+}
+function validateReceiptRefs(receiptRefs, adapter, capability, callId) {
+  if (!Array.isArray(receiptRefs)) {
+    throw invalidProviderResponse(
+      adapter,
+      capability,
+      callId,
+      "Adapter receiptRefs must be an array when provided."
+    );
+  }
+  for (const receiptRef of receiptRefs) {
+    if (!receiptRef || typeof receiptRef !== "object") {
+      throw invalidProviderResponse(
+        adapter,
+        capability,
+        callId,
+        "Adapter receiptRefs entries must be objects."
+      );
+    }
+    if (typeof receiptRef.type !== "string" || typeof receiptRef.provider !== "string" || typeof receiptRef.status !== "string" || typeof receiptRef.ref !== "string" || typeof receiptRef.timestamp !== "string") {
+      throw invalidProviderResponse(
+        adapter,
+        capability,
+        callId,
+        "Adapter receiptRefs entries require type, provider, status, ref, and timestamp strings."
+      );
+    }
+  }
+}
+function invalidProviderResponse(adapter, capability, callId, message) {
+  return new ProbeMeshError({
+    code: "invalid_provider_response",
+    message,
+    capability,
+    provider: adapter.id,
+    callId
+  });
+}
+async function withLatencyLimit(operation, request, adapter, callId, abortController) {
+  const maxLatencyMs = request.constraints?.maxLatencyMs;
+  if (maxLatencyMs === void 0) {
+    return operation;
+  }
+  let timeout;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => {
+          abortController.abort();
+          reject(
+            new ProbeMeshError({
+              code: "provider_timeout",
+              message: `Adapter "${adapter.id}" exceeded maxLatencyMs ${maxLatencyMs} for capability "${request.capability}".`,
+              capability: request.capability,
+              provider: adapter.id,
+              callId
+            })
+          );
+        }, maxLatencyMs);
+      })
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}
+function validateCallRequest(request) {
+  if (!request || typeof request !== "object") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "ProbeMesh call request must be an object."
+    });
+  }
+  const candidate = request;
+  if (typeof candidate.capability !== "string" || candidate.capability.trim().length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "ProbeMesh call request requires a non-empty capability."
+    });
+  }
+  if (!("input" in candidate)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `ProbeMesh call request for capability "${candidate.capability}" requires input.`,
+      capability: candidate.capability
+    });
+  }
+  validateConstraints(candidate.constraints, candidate.capability);
+  validateProviderPreferences(
+    candidate.providerPreferences,
+    candidate.capability
+  );
+  validatePaymentPreferences(candidate.paymentPreferences, candidate.capability);
+  validatePaymentStrategy(candidate.paymentStrategy, candidate.capability);
+}
+function validateRetryRequest(request) {
+  if (!request || typeof request !== "object") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "ProbeMesh retry request must be an object."
+    });
+  }
+  const candidate = request;
+  if (typeof candidate.callId !== "string" || candidate.callId.length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "ProbeMesh retry request requires a non-empty callId."
+    });
+  }
+  if (candidate.idempotencyKey !== void 0 && (typeof candidate.idempotencyKey !== "string" || candidate.idempotencyKey.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "ProbeMesh retry idempotencyKey must be a non-empty string when provided.",
+      callId: candidate.callId
+    });
+  }
+}
+function validateConstraints(constraints, capability) {
+  if (constraints === void 0) {
+    return;
+  }
+  if (!constraints || typeof constraints !== "object") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "constraints must be an object when provided.",
+      capability
+    });
+  }
+  validatePositiveNumber(constraints.maxCostUsd, "maxCostUsd", capability);
+  validatePositiveNumber(constraints.maxLatencyMs, "maxLatencyMs", capability);
+  if (constraints.minConfidence !== void 0 && (!Number.isFinite(constraints.minConfidence) || constraints.minConfidence < 0 || constraints.minConfidence > 1)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "minConfidence must be a number between 0 and 1 when provided.",
+      capability
+    });
+  }
+}
+function validateProviderPreferences(providerPreferences, capability) {
+  if (providerPreferences === void 0) {
+    return;
+  }
+  if (!providerPreferences || typeof providerPreferences !== "object") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "providerPreferences must be an object when provided.",
+      capability
+    });
+  }
+  validateStringArray(
+    providerPreferences.allowedProviders,
+    "allowedProviders",
+    capability
+  );
+  validateStringArray(
+    providerPreferences.blockedProviders,
+    "blockedProviders",
+    capability
+  );
+}
+function validatePositiveNumber(value, field, capability) {
+  if (value === void 0) {
+    return;
+  }
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${field} must be a positive number when provided.`,
+      capability
+    });
+  }
+}
+function validateStringArray(value, field, capability) {
+  if (value === void 0) {
+    return;
+  }
+  if (!Array.isArray(value) || value.some((provider) => typeof provider !== "string" || provider.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${field} must be an array of non-empty provider ids when provided.`,
+      capability
+    });
+  }
+}
+function selectAdapter(adapters, request) {
+  const allowedProviders = request.providerPreferences?.allowedProviders;
+  const blockedProviders = request.providerPreferences?.blockedProviders ?? [];
+  for (const adapter of adapters) {
+    if (!adapter.capabilities.includes(request.capability)) {
+      continue;
+    }
+    if (allowedProviders && !allowedProviders.includes(adapter.id)) {
+      continue;
+    }
+    if (blockedProviders.includes(adapter.id)) {
+      continue;
+    }
+    const resolution = resolveProviderPaymentOption({
+      providerId: adapter.id,
+      providerMode: adapter.mode ?? "local",
+      capabilities: adapter.capabilities,
+      capability: request.capability,
+      pricing: adapter.pricing,
+      paymentOptions: adapter.paymentOptions,
+      paymentPreferences: request.paymentPreferences,
+      paymentStrategy: request.paymentStrategy
+    });
+    if (resolution.selection) {
+      return {
+        adapter,
+        paymentSelection: resolution.selection
+      };
+    }
+  }
+  return void 0;
+}
+function enforceBudget(constraints, adapter, capability, callId, paymentSelection) {
+  if (constraints?.maxCostUsd === void 0) {
+    return;
+  }
+  const paymentCost = paymentSelectionToCost(paymentSelection);
+  if (paymentCost) {
+    if (paymentCost.amountUsd <= constraints.maxCostUsd) {
+      return;
+    }
+    throw new ProbeMeshError({
+      code: "budget_exceeded",
+      message: `Capability "${capability}" payment option "${paymentSelection?.optionId}" costs $${paymentCost.amountUsd.toFixed(
+        2
+      )}, which exceeds maxCostUsd $${constraints.maxCostUsd.toFixed(2)}.`,
+      capability,
+      provider: adapter.id,
+      callId
+    });
+  }
+  const pricing = getPricing(adapter, capability);
+  if (!pricing || pricing.amountUsd <= constraints.maxCostUsd) {
+    return;
+  }
+  throw new ProbeMeshError({
+    code: "budget_exceeded",
+    message: `Capability "${capability}" costs $${pricing.amountUsd.toFixed(
+      2
+    )}, which exceeds maxCostUsd $${constraints.maxCostUsd.toFixed(2)}.`,
+    capability,
+    provider: adapter.id,
+    callId
+  });
+}
+function getPricing(adapter, capability) {
+  if (!adapter.pricing) {
+    return void 0;
+  }
+  if (isSinglePricing(adapter.pricing)) {
+    return adapter.pricing;
+  }
+  return adapter.pricing[capability];
+}
+function isSinglePricing(pricing) {
+  return typeof pricing?.amountUsd === "number" && typeof pricing?.unit === "string";
+}
+function pricingToCost(pricing) {
+  if (!pricing) {
+    return void 0;
+  }
+  return {
+    amountUsd: pricing.amountUsd,
+    currency: pricing.currency ?? "USD",
+    unit: pricing.unit
+  };
+}
+function generateCallId() {
+  return `call_${randomUUID()}`;
+}
+
+// src/hostedRouter.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { createServer } from "http";
+var DEFAULT_PROVIDER_HEALTH_COOLDOWN_MS = 6e4;
+function createHostedRouter(options) {
+  const attemptStore = createAttemptStore();
+  const providerHealthStore = createProviderHealthStore();
+  const providerHealthOptions = resolveProviderHealthOptions(
+    options.providerHealth
+  );
+  const catalogPolicyOptions = resolveProviderCatalogPolicyOptions(
+    options.catalogPolicy,
+    options.adapters
+  );
+  return {
+    async handle(request, response) {
+      const route = parseHostedRoute(request);
+      if (!route) {
+        writeJson(response, 404, {
+          code: "provider_unavailable",
+          message: "Route not found.",
+          status: "failed"
+        });
+        return;
+      }
+      const routeId = `route_${randomUUID2()}`;
+      const timeline = createTimeline(routeId);
+      try {
+        assertAuthorized(request, options.apiKeys);
+        if (route.kind === "call") {
+          const body2 = await readJsonBody(request);
+          const callRequest = body2;
+          const attempt = createInitialAttempt(callRequest);
+          await executeHostedCall({
+            options,
+            response,
+            timeline,
+            attemptStore,
+            providerHealthStore,
+            providerHealthOptions,
+            catalogPolicyOptions,
+            originalRequest: callRequest,
+            callRequest,
+            attempt
+          });
+          return;
+        }
+        const body = await readOptionalJsonBody(request);
+        const retryRequest = validateRetryBody(route.callId, body);
+        await executeHostedRetry({
+          options,
+          response,
+          timeline,
+          attemptStore,
+          providerHealthStore,
+          providerHealthOptions,
+          catalogPolicyOptions,
+          retryRequest
+        });
+      } catch (error) {
+        emitPaymentAndReceiptTelemetry(options, timeline, {
+          callId: isProbeMeshError(error) ? error.callId : void 0,
+          capability: isProbeMeshError(error) ? error.capability : void 0,
+          provider: isProbeMeshError(error) ? error.provider : void 0,
+          safety: isProbeMeshError(error) ? error.safety : void 0,
+          receiptRefs: isProbeMeshError(error) ? error.receiptRefs : void 0,
+          attempt: isProbeMeshError(error) ? error.attempt : void 0
+        });
+        emitFailureTelemetry(options, timeline, error);
+        writeHostedError(response, error, timeline, retrySafetyForError(error));
+      }
+    }
+  };
+}
+function createAttemptStore() {
+  return {
+    attempts: /* @__PURE__ */ new Map(),
+    attemptCounts: /* @__PURE__ */ new Map()
+  };
+}
+function createProviderHealthStore() {
+  return {
+    records: /* @__PURE__ */ new Map()
+  };
+}
+function resolveProviderHealthOptions(options) {
+  const requestedCooldownMs = options?.cooldownMs;
+  const cooldownMs = typeof requestedCooldownMs === "number" && Number.isFinite(requestedCooldownMs) && requestedCooldownMs >= 0 ? requestedCooldownMs : DEFAULT_PROVIDER_HEALTH_COOLDOWN_MS;
+  return {
+    enabled: options?.enabled ?? true,
+    cooldownMs
+  };
+}
+function resolveProviderCatalogPolicyOptions(options, adapters) {
+  if (!options || options.enabled === false) {
+    return {
+      enabled: false,
+      status: options?.status ?? "ready"
+    };
+  }
+  assertProviderCatalog(options.catalog);
+  if (options.maxCostUsd !== void 0 && (typeof options.maxCostUsd !== "number" || !Number.isFinite(options.maxCostUsd) || options.maxCostUsd < 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Hosted provider catalog policy maxCostUsd must be a non-negative finite number."
+    });
+  }
+  validateStringArrayOption(
+    options.providerIds,
+    "Hosted provider catalog policy providerIds"
+  );
+  validateStringArrayOption(
+    options.blockedProviderIds,
+    "Hosted provider catalog policy blockedProviderIds"
+  );
+  if (options.requiredReceiptTypes !== void 0 && (!Array.isArray(options.requiredReceiptTypes) || options.requiredReceiptTypes.some((receiptType) => !isReceiptType(receiptType)))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Hosted provider catalog policy requiredReceiptTypes must contain known receipt types."
+    });
+  }
+  if (options.status !== void 0 && options.status !== "ready" && options.status !== "rejected") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: 'Hosted provider catalog policy status must be "ready" or "rejected".'
+    });
+  }
+  if (options.protocolMode !== void 0 && (typeof options.protocolMode !== "string" || options.protocolMode.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Hosted provider catalog policy protocolMode must be a non-empty string."
+    });
+  }
+  validatePaymentPreferences(options.paymentPreferences, "hosted catalog policy");
+  validatePaymentStrategy(options.paymentStrategy, "hosted catalog policy");
+  const bundlePolicy = createBundlePolicyOptions(options);
+  const bundleAdapterInventory = createAdapterInventory(adapters);
+  const bundleQueries = options.bundle?.queries;
+  const bundleVerification = options.bundle ? verifyProviderCatalogPolicyBundleRuntime({
+    bundle: options.bundle,
+    catalog: options.catalog,
+    catalogPolicy: bundlePolicy,
+    adapterInventory: bundleAdapterInventory,
+    queries: bundleQueries
+  }) : void 0;
+  if (bundleVerification && !bundleVerification.valid) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `Hosted provider catalog policy bundle does not match runtime inputs: ${formatBundleVerificationErrors(
+        bundleVerification.errors
+      )}`
+    });
+  }
+  return {
+    enabled: true,
+    catalog: options.catalog,
+    status: options.status ?? "ready",
+    protocolMode: options.protocolMode,
+    paymentPreferences: options.paymentPreferences,
+    paymentStrategy: options.paymentStrategy,
+    maxCostUsd: options.maxCostUsd,
+    requiredReceiptTypes: options.requiredReceiptTypes,
+    providerIds: options.providerIds,
+    blockedProviderIds: options.blockedProviderIds,
+    bundle: options.bundle,
+    bundlePolicy,
+    bundleQueries,
+    bundleAdapterInventory,
+    bundleAttestation: bundleVerification?.attestation
+  };
+}
+function createBundlePolicyOptions(options) {
+  const policy = {};
+  if (options.enabled !== void 0) {
+    policy.enabled = options.enabled;
+  }
+  if (options.status !== void 0) {
+    policy.status = options.status;
+  }
+  if (options.protocolMode !== void 0) {
+    policy.protocolMode = options.protocolMode;
+  }
+  if (options.paymentPreferences !== void 0) {
+    policy.paymentPreferences = options.paymentPreferences;
+  }
+  if (options.paymentStrategy !== void 0) {
+    policy.paymentStrategy = options.paymentStrategy;
+  }
+  if (options.maxCostUsd !== void 0) {
+    policy.maxCostUsd = options.maxCostUsd;
+  }
+  if (options.requiredReceiptTypes !== void 0) {
+    policy.requiredReceiptTypes = options.requiredReceiptTypes;
+  }
+  if (options.providerIds !== void 0) {
+    policy.providerIds = options.providerIds;
+  }
+  if (options.blockedProviderIds !== void 0) {
+    policy.blockedProviderIds = options.blockedProviderIds;
+  }
+  return Object.keys(policy).length > 0 ? policy : void 0;
+}
+function createAdapterInventory(adapters) {
+  return adapters.map((adapter) => ({
+    id: adapter.id,
+    capabilities: [...adapter.capabilities],
+    ...adapter.pricing !== void 0 ? { pricing: adapter.pricing } : {},
+    ...adapter.paymentOptions !== void 0 ? { paymentOptions: adapter.paymentOptions } : {}
+  }));
+}
+function formatBundleVerificationErrors(errors) {
+  return errors.map((error) => `${error.path}: ${error.message}`).join("; ");
+}
+function validateStringArrayOption(value, label) {
+  if (value !== void 0 && (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${label} must be an array of non-empty strings.`
+    });
+  }
+}
+function isReceiptType(value) {
+  return value === "payment_proof" || value === "settlement_confirmation" || value === "provider_delivery" || value === "provider_response_evidence" || value === "authorization_decision";
+}
+function parseHostedRoute(request) {
+  if (request.method !== "POST" || !request.url) {
+    return void 0;
+  }
+  const url = new URL(request.url, "http://localhost");
+  if (url.pathname === "/v1/calls") {
+    return {
+      kind: "call"
+    };
+  }
+  const retryMatch = url.pathname.match(/^\/v1\/calls\/(.+)\/retry$/);
+  if (retryMatch) {
+    return {
+      kind: "retry",
+      callId: decodeURIComponent(retryMatch[1])
+    };
+  }
+  return void 0;
+}
+async function executeHostedCall(options) {
+  const {
+    options: routerOptions,
+    response,
+    timeline,
+    attemptStore,
+    providerHealthStore,
+    providerHealthOptions,
+    catalogPolicyOptions,
+    originalRequest,
+    callRequest,
+    attempt
+  } = options;
+  const executableRequest = {
+    ...callRequest,
+    idempotencyKey: attempt.attemptId
+  };
+  const routePlan = createRoutePlan(
+    routerOptions.adapters,
+    executableRequest,
+    providerHealthStore,
+    providerHealthOptions,
+    catalogPolicyOptions
+  );
+  emitTelemetry(routerOptions, timeline, {
+    type: "call.requested",
+    callId: attempt.attemptId,
+    capability: executableRequest.capability,
+    attempt,
+    attestation: routePlan.attestation
+  });
+  if (routePlan.eligibleAdapters.length === 0) {
+    const error = createNoEligibleProviderError(executableRequest, routePlan);
+    const retrySafety2 = retrySafetyForError(error);
+    emitFailureTelemetry(
+      routerOptions,
+      timeline,
+      error,
+      attempt,
+      routePlan.attestation
+    );
+    await emitCallAuditArtifact(routerOptions, {
+      request: executableRequest,
+      error,
+      timeline,
+      retrySafety: retrySafety2,
+      attempt,
+      route: createRouteMetadata(
+        timeline.routeId,
+        routePlan.explanation,
+        void 0,
+        routePlan.attestation,
+        void 0,
+        routePlan.paymentStrategy
+      )
+    });
+    storeAttempt(attemptStore, {
+      originalRequest,
+      attempt,
+      outcome: "failed",
+      retrySafety: retrySafety2,
+      timeline
+    });
+    writeHostedError(
+      response,
+      error,
+      timeline,
+      retrySafety2,
+      attempt,
+      createRouteMetadata(
+        timeline.routeId,
+        routePlan.explanation,
+        void 0,
+        routePlan.attestation,
+        void 0,
+        routePlan.paymentStrategy
+      )
+    );
+    return;
+  }
+  let lastError;
+  for (const [index, candidate] of routePlan.eligibleAdapters.entries()) {
+    const { adapter, paymentSelection } = candidate;
+    markRouteAttempt(routePlan.explanation, adapter.id, {
+      status: "attempted",
+      reason: "eligible",
+      paymentSelection,
+      paymentStrategy: routePlan.paymentStrategy,
+      paymentOptionScore: paymentSelection.score,
+      paymentOptionScoreReasons: paymentSelection.scoreReasons
+    });
+    try {
+      const client = createProbeMesh({
+        adapters: createTimelineAdapters(
+          {
+            ...routerOptions,
+            adapters: [adapter]
+          },
+          timeline,
+          attempt,
+          routePlan.attestation
+        )
+      });
+      const result = await client.call({
+        ...executableRequest,
+        providerPreferences: {
+          allowedProviders: [adapter.id]
+        }
+      });
+      const selectedPayment = result.route?.paymentSelection ?? paymentSelection;
+      clearProviderHealth(
+        providerHealthStore,
+        providerHealthOptions,
+        result.capability,
+        adapter.id
+      );
+      markRouteAttempt(routePlan.explanation, adapter.id, {
+        status: "succeeded",
+        reason: "selected",
+        paymentEvidence: hasPaymentEvidence(result.safety, result.receiptRefs),
+        healthStatus: providerHealthOptions.enabled ? "healthy" : void 0,
+        paymentSelection: selectedPayment,
+        paymentStrategy: routePlan.paymentStrategy,
+        paymentOptionScore: selectedPayment?.score,
+        paymentOptionScoreReasons: selectedPayment?.scoreReasons
+      });
+      routePlan.explanation.selectedProviderId = result.provider.id;
+      routePlan.explanation.stopReason = "stopped_completed";
+      routePlan.explanation.fallbackUsed = routePlan.explanation.fallbackCount > 0;
+      emitTelemetry(routerOptions, timeline, {
+        type: "provider.selected",
+        callId: result.callId,
+        capability: result.capability,
+        provider: result.provider.id,
+        attempt,
+        attestation: routePlan.attestation
+      });
+      emitPaymentAndReceiptTelemetry(routerOptions, timeline, {
+        callId: result.callId,
+        capability: result.capability,
+        provider: result.provider.id,
+        safety: result.safety,
+        receiptRefs: result.receiptRefs,
+        attempt,
+        attestation: routePlan.attestation
+      });
+      emitTelemetry(routerOptions, timeline, {
+        type: "call.completed",
+        callId: result.callId,
+        capability: result.capability,
+        provider: result.provider.id,
+        status: "completed",
+        safety: result.safety,
+        attempt,
+        attestation: routePlan.attestation
+      });
+      const retrySafety2 = retrySafetyForCompletedCall();
+      const hostedResult = addHostedRouteMetadata(
+        result,
+        timeline.routeId,
+        timeline,
+        retrySafety2,
+        attempt,
+        routePlan.explanation,
+        routePlan.attestation,
+        selectedPayment,
+        routePlan.paymentStrategy
+      );
+      storeAttempt(attemptStore, {
+        originalRequest,
+        attempt,
+        outcome: "completed",
+        safety: hostedResult.safety,
+        receiptRefs: hostedResult.receiptRefs,
+        retrySafety: retrySafety2,
+        timeline
+      });
+      await emitCallAuditArtifact(routerOptions, {
+        request: executableRequest,
+        response: hostedResult,
+        timeline,
+        retrySafety: retrySafety2,
+        attempt,
+        route: hostedResult.route
+      });
+      writeJson(response, 200, hostedResult);
+      return;
+    } catch (error) {
+      const normalizedError2 = toHostedProbeMeshError(error);
+      const paymentEvidence = moneyMayHaveMoved(
+        normalizedError2.safety,
+        normalizedError2.receiptRefs
+      );
+      const retrySafety2 = retrySafetyForError(normalizedError2);
+      const healthRecord = shouldRememberProviderHealthFailure(
+        normalizedError2,
+        paymentEvidence,
+        retrySafety2
+      ) ? markProviderUnhealthy(
+        providerHealthStore,
+        providerHealthOptions,
+        executableRequest.capability,
+        adapter.id
+      ) : void 0;
+      lastError = normalizedError2;
+      markRouteAttempt(routePlan.explanation, adapter.id, {
+        status: "failed",
+        reason: paymentEvidence ? "stopped_payment_evidence" : "fallback_after_failure",
+        errorCode: normalizedError2.code,
+        paymentEvidence,
+        ...healthRecord ?? {},
+        message: normalizedError2.message
+      });
+      const canFallback = !paymentEvidence && retrySafety2.safeToAutoRetry && index < routePlan.eligibleAdapters.length - 1;
+      if (canFallback) {
+        routePlan.explanation.fallbackCount += 1;
+        routePlan.explanation.fallbackUsed = true;
+        continue;
+      }
+      routePlan.explanation.stopReason = paymentEvidence ? "stopped_payment_evidence" : retrySafety2.safeToAutoRetry ? "no_eligible_provider" : "stopped_not_retryable";
+      routePlan.explanation.fallbackUsed = routePlan.explanation.fallbackCount > 0;
+      break;
+    }
+  }
+  const normalizedError = lastError ?? createNoEligibleProviderError(executableRequest, routePlan);
+  const retrySafety = retrySafetyForError(normalizedError);
+  emitPaymentAndReceiptTelemetry(routerOptions, timeline, {
+    callId: normalizedError.callId,
+    capability: normalizedError.capability,
+    provider: normalizedError.provider,
+    safety: normalizedError.safety,
+    receiptRefs: normalizedError.receiptRefs,
+    attempt,
+    attestation: routePlan.attestation
+  });
+  emitFailureTelemetry(
+    routerOptions,
+    timeline,
+    normalizedError,
+    attempt,
+    routePlan.attestation
+  );
+  await emitCallAuditArtifact(routerOptions, {
+    request: executableRequest,
+    error: normalizedError,
+    timeline,
+    retrySafety,
+    attempt,
+    route: createRouteMetadata(
+      timeline.routeId,
+      routePlan.explanation,
+      void 0,
+      routePlan.attestation,
+      void 0,
+      routePlan.paymentStrategy
+    )
+  });
+  storeAttempt(attemptStore, {
+    originalRequest,
+    attempt,
+    outcome: "failed",
+    safety: normalizedError.safety,
+    receiptRefs: normalizedError.receiptRefs,
+    retrySafety,
+    timeline
+  });
+  writeHostedError(
+    response,
+    normalizedError,
+    timeline,
+    retrySafety,
+    attempt,
+    createRouteMetadata(
+      timeline.routeId,
+      routePlan.explanation,
+      void 0,
+      routePlan.attestation,
+      void 0,
+      routePlan.paymentStrategy
+    )
+  );
+}
+function createRoutePlan(adapters, request, providerHealthStore, providerHealthOptions, catalogPolicyOptions) {
+  const allowedProviders = request.providerPreferences?.allowedProviders;
+  const blockedProviders = request.providerPreferences?.blockedProviders ?? [];
+  const attempts = [];
+  const eligibleAdapters = [];
+  const plannedAt = /* @__PURE__ */ new Date();
+  const effectiveMaxCostUsd = strictestMaxCostUsd(
+    request.constraints?.maxCostUsd,
+    catalogPolicyOptions.maxCostUsd
+  );
+  const catalogPolicyPlan = createCatalogPolicyPlan(
+    adapters,
+    request,
+    catalogPolicyOptions,
+    effectiveMaxCostUsd
+  );
+  const paymentStrategy = request.paymentStrategy ?? catalogPolicyOptions.paymentStrategy;
+  const bundleVerification = verifyPolicyBundleCapability(
+    catalogPolicyOptions,
+    request.capability
+  );
+  const attestation = bundleVerification?.attestation;
+  const bundleBlocksCapability = attestation !== void 0 && !bundleVerification?.valid;
+  for (const adapter of adapters) {
+    const pricing = getPricing2(adapter, request.capability);
+    const paymentPreferences = mergePaymentPreferences(
+      catalogPolicyOptions.paymentPreferences,
+      request.paymentPreferences
+    );
+    const paymentResolution = resolveProviderPaymentOption({
+      providerId: adapter.id,
+      providerMode: adapter.mode ?? "hosted",
+      capabilities: adapter.capabilities,
+      capability: request.capability,
+      pricing: adapter.pricing,
+      paymentOptions: adapter.paymentOptions,
+      paymentPreferences,
+      paymentStrategy
+    });
+    const paymentSelection = paymentResolution.selection;
+    const cost = paymentSelectionToCost(paymentSelection) ?? pricingToCost2(pricing);
+    const catalogMatch = catalogPolicyPlan.matchesByProviderId.get(adapter.id);
+    const catalogEntry = catalogPolicyPlan.catalogEntryByProviderId.get(adapter.id);
+    const baseAttempt = {
+      providerId: adapter.id,
+      cost,
+      paymentSelection,
+      paymentStrategy,
+      paymentOptionScore: paymentSelection?.score,
+      paymentOptionScoreReasons: paymentSelection?.scoreReasons,
+      ...catalogRouteMetadata(catalogMatch, catalogEntry)
+    };
+    const healthMetadata = getProviderHealthMetadata(
+      providerHealthStore,
+      providerHealthOptions,
+      request.capability,
+      adapter.id,
+      plannedAt
+    );
+    if (!adapter.capabilities.includes(request.capability)) {
+      attempts.push({
+        ...baseAttempt,
+        status: "skipped",
+        reason: "skipped_capability_mismatch"
+      });
+      continue;
+    }
+    if (bundleBlocksCapability) {
+      attempts.push({
+        ...baseAttempt,
+        status: "skipped",
+        reason: "skipped_policy_bundle_uncovered",
+        attestation,
+        catalogPolicyReason: attestation?.reason ?? `Capability "${request.capability}" is not covered by the policy bundle.`
+      });
+      continue;
+    }
+    if (allowedProviders && !allowedProviders.includes(adapter.id)) {
+      attempts.push({
+        ...baseAttempt,
+        status: "skipped",
+        reason: "skipped_allowed_provider"
+      });
+      continue;
+    }
+    if (blockedProviders.includes(adapter.id)) {
+      attempts.push({
+        ...baseAttempt,
+        status: "skipped",
+        reason: "skipped_blocked_provider"
+      });
+      continue;
+    }
+    if (!paymentSelection) {
+      attempts.push({
+        ...baseAttempt,
+        status: "skipped",
+        reason: "skipped_payment_preferences",
+        paymentOptionReason: paymentResolution.reason,
+        message: paymentResolution.reason
+      });
+      continue;
+    }
+    if (effectiveMaxCostUsd !== void 0 && cost && cost.amountUsd > effectiveMaxCostUsd) {
+      attempts.push({
+        ...baseAttempt,
+        status: "skipped",
+        reason: "skipped_budget_exceeded",
+        budgetExceeded: true,
+        message: `Capability "${request.capability}" costs $${cost.amountUsd.toFixed(
+          2
+        )}, which exceeds maxCostUsd $${effectiveMaxCostUsd.toFixed(
+          2
+        )}.`
+      });
+      continue;
+    }
+    if (catalogPolicyPlan.enabled && !catalogMatch) {
+      attempts.push({
+        ...baseAttempt,
+        status: "skipped",
+        reason: "skipped_catalog_policy",
+        catalogPolicyReason: `Provider "${adapter.id}" does not match the hosted catalog policy for capability "${request.capability}".`
+      });
+      continue;
+    }
+    if (healthMetadata.healthStatus === "unhealthy") {
+      attempts.push({
+        ...baseAttempt,
+        ...healthMetadata,
+        status: "skipped",
+        reason: "skipped_unhealthy_provider",
+        message: `Provider "${adapter.id}" is cooling down after a recent safe pre-payment failure.`
+      });
+      continue;
+    }
+    attempts.push({
+      ...baseAttempt,
+      ...healthMetadata,
+      status: "considered",
+      reason: "eligible"
+    });
+    eligibleAdapters.push({
+      adapter,
+      paymentSelection
+    });
+  }
+  for (const match of bundleBlocksCapability ? [] : catalogPolicyPlan.missingAdapterMatches) {
+    attempts.push({
+      providerId: match.providerId,
+      cost: match.cost,
+      status: "skipped",
+      reason: "skipped_catalog_adapter_missing",
+      catalogArtifactId: match.entry.artifactId,
+      catalogStatus: match.entry.status,
+      catalogMatchReasons: match.reasons,
+      catalogPolicyReason: `Catalog provider "${match.providerId}" matched policy but has no registered adapter.`
+    });
+  }
+  return {
+    eligibleAdapters,
+    catalogPolicyPlan,
+    paymentStrategy,
+    attestation,
+    explanation: {
+      consideredProviders: attempts.map((attempt) => attempt.providerId),
+      fallbackUsed: false,
+      fallbackCount: 0,
+      stopReason: eligibleAdapters.length > 0 ? "eligible" : "no_eligible_provider",
+      attempts
+    }
+  };
+}
+function verifyPolicyBundleCapability(catalogPolicyOptions, capability) {
+  if (!catalogPolicyOptions.bundle || !catalogPolicyOptions.catalog || !catalogPolicyOptions.bundleAdapterInventory) {
+    return void 0;
+  }
+  return verifyProviderCatalogPolicyBundleRuntime({
+    bundle: catalogPolicyOptions.bundle,
+    catalog: catalogPolicyOptions.catalog,
+    catalogPolicy: catalogPolicyOptions.bundlePolicy,
+    adapterInventory: catalogPolicyOptions.bundleAdapterInventory,
+    queries: catalogPolicyOptions.bundleQueries,
+    capability
+  });
+}
+function createCatalogPolicyPlan(adapters, request, catalogPolicyOptions, effectiveMaxCostUsd) {
+  const emptyPlan = {
+    enabled: false,
+    effectiveMaxCostUsd,
+    matchesByProviderId: /* @__PURE__ */ new Map(),
+    missingAdapterMatches: [],
+    catalogEntryByProviderId: /* @__PURE__ */ new Map()
+  };
+  if (!catalogPolicyOptions.enabled || !catalogPolicyOptions.catalog) {
+    return emptyPlan;
+  }
+  const matches = findProviderCatalogMatches(catalogPolicyOptions.catalog, {
+    capability: request.capability,
+    protocolMode: catalogPolicyOptions.protocolMode,
+    paymentPreferences: mergePaymentPreferences(
+      catalogPolicyOptions.paymentPreferences,
+      request.paymentPreferences
+    ),
+    paymentStrategy: request.paymentStrategy ?? catalogPolicyOptions.paymentStrategy,
+    maxCostUsd: effectiveMaxCostUsd,
+    requiredReceiptTypes: catalogPolicyOptions.requiredReceiptTypes,
+    providerIds: catalogPolicyOptions.providerIds,
+    blockedProviderIds: catalogPolicyOptions.blockedProviderIds,
+    status: catalogPolicyOptions.status
+  });
+  const registeredAdapterIds = new Set(adapters.map((adapter) => adapter.id));
+  const matchesByProviderId = /* @__PURE__ */ new Map();
+  const missingAdapterMatches = [];
+  for (const match of matches) {
+    if (!matchesByProviderId.has(match.providerId)) {
+      matchesByProviderId.set(match.providerId, match);
+    }
+    if (!registeredAdapterIds.has(match.providerId) && requestAllowsProvider(request, match.providerId)) {
+      missingAdapterMatches.push(match);
+    }
+  }
+  return {
+    enabled: true,
+    effectiveMaxCostUsd,
+    matchesByProviderId,
+    missingAdapterMatches,
+    catalogEntryByProviderId: createCatalogEntryIndex(catalogPolicyOptions.catalog)
+  };
+}
+function createCatalogEntryIndex(catalog) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const entry of catalog.entries) {
+    if (!entries.has(entry.provider.id)) {
+      entries.set(entry.provider.id, entry);
+    }
+  }
+  return entries;
+}
+function requestAllowsProvider(request, providerId) {
+  const allowedProviders = request.providerPreferences?.allowedProviders;
+  const blockedProviders = request.providerPreferences?.blockedProviders ?? [];
+  return (!allowedProviders || allowedProviders.includes(providerId)) && !blockedProviders.includes(providerId);
+}
+function catalogRouteMetadata(match, entry) {
+  if (match) {
+    return {
+      catalogArtifactId: match.entry.artifactId,
+      catalogStatus: match.entry.status,
+      catalogMatchReasons: match.reasons
+    };
+  }
+  if (entry) {
+    return {
+      catalogArtifactId: entry.artifactId,
+      catalogStatus: entry.status
+    };
+  }
+  return {};
+}
+function strictestMaxCostUsd(requestMaxCostUsd, policyMaxCostUsd) {
+  if (requestMaxCostUsd === void 0) {
+    return policyMaxCostUsd;
+  }
+  if (policyMaxCostUsd === void 0) {
+    return requestMaxCostUsd;
+  }
+  return Math.min(requestMaxCostUsd, policyMaxCostUsd);
+}
+function createNoEligibleProviderError(request, routePlan) {
+  const budgetAttempt = routePlan.explanation.attempts.find(
+    (attempt) => attempt.reason === "skipped_budget_exceeded"
+  );
+  if (budgetAttempt) {
+    return new ProbeMeshError({
+      code: "budget_exceeded",
+      message: budgetAttempt.message ?? `No provider for capability "${request.capability}" fits maxCostUsd.`,
+      capability: request.capability,
+      provider: budgetAttempt.providerId,
+      callId: request.idempotencyKey
+    });
+  }
+  const uncoveredAttempt = routePlan.explanation.attempts.find(
+    (attempt) => attempt.reason === "skipped_policy_bundle_uncovered"
+  );
+  if (uncoveredAttempt) {
+    return new ProbeMeshError({
+      code: "provider_unavailable",
+      message: uncoveredAttempt.catalogPolicyReason ?? `Capability "${request.capability}" is not covered by the policy bundle.`,
+      capability: request.capability,
+      callId: request.idempotencyKey
+    });
+  }
+  const paymentAttempt = routePlan.explanation.attempts.find(
+    (attempt) => attempt.reason === "skipped_payment_preferences"
+  );
+  if (paymentAttempt) {
+    return new ProbeMeshError({
+      code: "provider_unavailable",
+      message: paymentAttempt.message ?? `No provider for capability "${request.capability}" matches paymentPreferences.`,
+      capability: request.capability,
+      provider: paymentAttempt.providerId,
+      callId: request.idempotencyKey
+    });
+  }
+  return new ProbeMeshError({
+    code: "provider_unavailable",
+    message: `No adapter is available for capability "${request.capability}".`,
+    capability: request.capability,
+    callId: request.idempotencyKey
+  });
+}
+function providerHealthKey(capability, providerId) {
+  return `${capability}\0${providerId}`;
+}
+function getProviderHealthMetadata(store, options, capability, providerId, now) {
+  if (!options.enabled) {
+    return {};
+  }
+  const key = providerHealthKey(capability, providerId);
+  const record = store.records.get(key);
+  if (!record) {
+    return {
+      healthStatus: "healthy"
+    };
+  }
+  if (Date.parse(record.cooldownUntil) <= now.getTime()) {
+    store.records.delete(key);
+    return {
+      healthStatus: "healthy"
+    };
+  }
+  return record;
+}
+function markProviderUnhealthy(store, options, capability, providerId) {
+  if (!options.enabled) {
+    return void 0;
+  }
+  const key = providerHealthKey(capability, providerId);
+  const previousRecord = store.records.get(key);
+  const failedAt = /* @__PURE__ */ new Date();
+  const record = {
+    healthStatus: "unhealthy",
+    lastFailureAt: failedAt.toISOString(),
+    cooldownUntil: new Date(
+      failedAt.getTime() + options.cooldownMs
+    ).toISOString(),
+    consecutiveFailures: (previousRecord?.consecutiveFailures ?? 0) + 1
+  };
+  store.records.set(key, record);
+  return record;
+}
+function clearProviderHealth(store, options, capability, providerId) {
+  if (!options.enabled) {
+    return;
+  }
+  store.records.delete(providerHealthKey(capability, providerId));
+}
+function shouldRememberProviderHealthFailure(error, paymentEvidence, retrySafety) {
+  return !paymentEvidence && retrySafety.safeToAutoRetry && (error.code === "provider_unavailable" || error.code === "provider_timeout");
+}
+function markRouteAttempt(explanation, providerId, updates) {
+  const routeAttempt = explanation.attempts.find(
+    (attempt) => attempt.providerId === providerId
+  );
+  if (!routeAttempt) {
+    return;
+  }
+  Object.assign(routeAttempt, updates);
+}
+function createRouteMetadata(routeId, explanation, selectedProviderId, attestation, paymentSelection, paymentStrategy) {
+  return {
+    routeId,
+    mode: "hosted",
+    selectedProviderId,
+    paymentStrategy,
+    paymentSelection,
+    explanation,
+    attestation
+  };
+}
+async function executeHostedRetry(options) {
+  const {
+    options: routerOptions,
+    response,
+    timeline,
+    attemptStore,
+    providerHealthStore,
+    providerHealthOptions,
+    catalogPolicyOptions,
+    retryRequest
+  } = options;
+  emitTelemetry(routerOptions, timeline, {
+    type: "retry.requested",
+    callId: retryRequest.callId
+  });
+  const sourceAttempt = attemptStore.attempts.get(retryRequest.callId);
+  if (!sourceAttempt) {
+    const retrySafety = notRetryableSafety();
+    const error = new ProbeMeshError({
+      code: "retry_not_available",
+      message: `No hosted attempt is available for callId "${retryRequest.callId}".`,
+      callId: retryRequest.callId,
+      retrySafety
+    });
+    emitBlockedRetry(routerOptions, timeline, error);
+    writeHostedError(response, error, timeline, retrySafety);
+    return;
+  }
+  if (!sourceAttempt.retrySafety.safeToAutoRetry) {
+    const error = new ProbeMeshError({
+      code: "retry_not_available",
+      message: `Hosted attempt "${retryRequest.callId}" is not safe to retry.`,
+      callId: sourceAttempt.attempt.attemptId,
+      receiptRefs: sourceAttempt.receiptRefs,
+      safety: sourceAttempt.safety,
+      retrySafety: sourceAttempt.retrySafety,
+      attempt: sourceAttempt.attempt
+    });
+    emitBlockedRetry(routerOptions, timeline, error);
+    writeHostedError(
+      response,
+      error,
+      timeline,
+      sourceAttempt.retrySafety,
+      sourceAttempt.attempt
+    );
+    return;
+  }
+  const retryAttempt = createRetryAttempt(
+    attemptStore,
+    sourceAttempt,
+    retryRequest.idempotencyKey
+  );
+  const retryCallRequest = {
+    ...sourceAttempt.originalRequest,
+    idempotencyKey: retryAttempt.attemptId
+  };
+  await executeHostedCall({
+    options: routerOptions,
+    response,
+    timeline,
+    attemptStore,
+    providerHealthStore,
+    providerHealthOptions,
+    catalogPolicyOptions,
+    originalRequest: sourceAttempt.originalRequest,
+    callRequest: retryCallRequest,
+    attempt: retryAttempt
+  });
+}
+function emitBlockedRetry(options, timeline, error) {
+  emitTelemetry(options, timeline, {
+    type: "retry.blocked",
+    callId: error.callId,
+    errorCode: error.code,
+    safety: error.safety,
+    attempt: error.attempt
+  });
+  emitFailureTelemetry(options, timeline, error, error.attempt);
+}
+function createInitialAttempt(callRequest) {
+  const attemptId = callRequest.idempotencyKey ?? generateCallId2();
+  return {
+    originalCallId: attemptId,
+    attemptId,
+    attemptNumber: 1,
+    isRetry: false
+  };
+}
+function createRetryAttempt(attemptStore, sourceAttempt, idempotencyKey) {
+  const originalCallId = sourceAttempt.attempt.originalCallId;
+  const attemptNumber = (attemptStore.attemptCounts.get(originalCallId) ?? 1) + 1;
+  const attemptId = idempotencyKey ?? `${originalCallId}:retry:${attemptNumber}`;
+  return {
+    originalCallId,
+    attemptId,
+    attemptNumber,
+    isRetry: true,
+    previousAttemptId: sourceAttempt.attempt.attemptId
+  };
+}
+function storeAttempt(attemptStore, record) {
+  attemptStore.attempts.set(record.attempt.attemptId, record);
+  attemptStore.attemptCounts.set(
+    record.attempt.originalCallId,
+    Math.max(
+      attemptStore.attemptCounts.get(record.attempt.originalCallId) ?? 0,
+      record.attempt.attemptNumber
+    )
+  );
+}
+function generateCallId2() {
+  return `call_${randomUUID2()}`;
+}
+function createTimeline(routeId) {
+  return {
+    routeId,
+    events: []
+  };
+}
+function createTimelineAdapters(options, timeline, attempt, attestation) {
+  return options.adapters.map((adapter) => ({
+    ...adapter,
+    call(request, context) {
+      emitTelemetry(options, timeline, {
+        type: "provider.attempted",
+        callId: context.callId,
+        capability: request.capability,
+        provider: adapter.id,
+        attempt,
+        attestation
+      });
+      return adapter.call(request, context);
+    }
+  }));
+}
+function assertAuthorized(request, apiKeys) {
+  if (!apiKeys || apiKeys.length === 0) {
+    return;
+  }
+  const authorization = request.headers.authorization;
+  const token = authorization?.startsWith("Bearer ") ? authorization.slice("Bearer ".length) : void 0;
+  if (!token || !apiKeys.includes(token)) {
+    throw new ProbeMeshError({
+      code: "unauthorized",
+      message: "Hosted router request requires a valid bearer token."
+    });
+  }
+}
+async function startHostedRouter(options) {
+  const router = createHostedRouter(options);
+  const server = createServer((request, response) => {
+    void router.handle(request, response);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port, options.host ?? "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : options.port;
+  const host = options.host ?? "127.0.0.1";
+  return {
+    server,
+    url: `http://${host}:${port}`,
+    close() {
+      return new Promise((resolve, reject) => {
+        server.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+    }
+  };
+}
+async function readJsonBody(request) {
+  const body = await readRawJsonBody(request);
+  if (body === void 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Hosted call request body is required."
+    });
+  }
+  return body;
+}
+async function readOptionalJsonBody(request) {
+  return await readRawJsonBody(request) ?? {};
+}
+async function readRawJsonBody(request) {
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const rawBody = Buffer.concat(chunks).toString("utf8");
+  if (rawBody.length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(rawBody);
+  } catch (error) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Hosted call request body must be valid JSON.",
+      cause: error
+    });
+  }
+}
+function validateRetryBody(callId, body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Hosted retry request body must be an object when provided.",
+      callId
+    });
+  }
+  const candidate = body;
+  if (candidate.idempotencyKey !== void 0 && (typeof candidate.idempotencyKey !== "string" || candidate.idempotencyKey.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Hosted retry idempotencyKey must be a non-empty string when provided.",
+      callId
+    });
+  }
+  return {
+    callId,
+    idempotencyKey: candidate.idempotencyKey
+  };
+}
+function addHostedRouteMetadata(response, routeId, timeline, retrySafety, attempt, explanation, attestation, paymentSelection, paymentStrategy) {
+  return {
+    ...response,
+    timeline,
+    retrySafety,
+    attempt,
+    route: createRouteMetadata(
+      routeId,
+      explanation ?? {
+        consideredProviders: [response.provider.id],
+        selectedProviderId: response.provider.id,
+        fallbackUsed: false,
+        fallbackCount: 0,
+        stopReason: "stopped_completed",
+        attempts: [
+          {
+            providerId: response.provider.id,
+            status: "succeeded",
+            reason: "selected",
+            paymentEvidence: hasPaymentEvidence(
+              response.safety,
+              response.receiptRefs
+            )
+          }
+        ]
+      },
+      response.provider.id,
+      attestation,
+      paymentSelection ?? response.route?.paymentSelection,
+      paymentStrategy
+    )
+  };
+}
+function writeHostedError(response, error, timeline, retrySafety, attempt, route) {
+  const normalizedError = toHostedProbeMeshError(error);
+  writeJson(response, statusCodeForError(normalizedError.code), {
+    ...normalizedError.toJSON(),
+    timeline,
+    retrySafety,
+    attempt: normalizedError.attempt ?? attempt,
+    route: normalizedError.route ?? route
+  });
+}
+function toHostedProbeMeshError(error) {
+  if (isProbeMeshError(error)) {
+    return error;
+  }
+  return new ProbeMeshError({
+    code: "provider_unavailable",
+    message: "Hosted router failed while handling the call.",
+    cause: error
+  });
+}
+function retrySafetyForCompletedCall() {
+  return {
+    retryable: false,
+    safeToAutoRetry: false,
+    reason: "completed"
+  };
+}
+function notRetryableSafety() {
+  return {
+    retryable: false,
+    safeToAutoRetry: false,
+    reason: "not_retryable"
+  };
+}
+function retrySafetyForError(error) {
+  if (!isProbeMeshError(error)) {
+    return {
+      retryable: true,
+      safeToAutoRetry: true,
+      reason: "no_payment_attempted"
+    };
+  }
+  if (error.code === "budget_exceeded" || error.code === "unauthorized" || error.code === "invalid_request" || error.code === "retry_not_available") {
+    return {
+      retryable: false,
+      safeToAutoRetry: false,
+      reason: "not_retryable"
+    };
+  }
+  if (moneyMayHaveMoved(error.safety, error.receiptRefs)) {
+    return {
+      retryable: false,
+      safeToAutoRetry: false,
+      reason: "money_may_have_moved"
+    };
+  }
+  if (error.code === "payment_failed" && error.safety?.moneyMayHaveMoved === false) {
+    return {
+      retryable: true,
+      safeToAutoRetry: true,
+      reason: "payment_failed_no_charge"
+    };
+  }
+  if ((error.code === "provider_unavailable" || error.code === "provider_timeout") && !hasPaymentEvidence(error.safety, error.receiptRefs)) {
+    return {
+      retryable: true,
+      safeToAutoRetry: true,
+      reason: "no_payment_attempted"
+    };
+  }
+  return {
+    retryable: true,
+    safeToAutoRetry: false,
+    reason: "unknown_payment_state"
+  };
+}
+function moneyMayHaveMoved(safety, receiptRefs) {
+  return safety?.moneyMayHaveMoved === true || receiptRefs?.some((receiptRef) => receiptRef.type === "payment_proof") === true;
+}
+function hasPaymentEvidence(safety, receiptRefs) {
+  return moneyMayHaveMoved(safety, receiptRefs);
+}
+function getPricing2(adapter, capability) {
+  if (!adapter.pricing) {
+    return void 0;
+  }
+  const pricing = adapter.pricing;
+  if (typeof pricing.amountUsd === "number" && typeof pricing.unit === "string") {
+    return pricing;
+  }
+  return adapter.pricing[capability];
+}
+function pricingToCost2(pricing) {
+  if (!pricing) {
+    return void 0;
+  }
+  return {
+    amountUsd: pricing.amountUsd,
+    currency: pricing.currency ?? "USD",
+    unit: pricing.unit
+  };
+}
+function emitFailureTelemetry(options, timeline, error, attempt, attestation) {
+  if (!isProbeMeshError(error)) {
+    emitTelemetry(options, timeline, {
+      type: "call.failed",
+      status: "failed",
+      errorCode: "provider_unavailable",
+      attempt,
+      attestation
+    });
+    return;
+  }
+  emitTelemetry(options, timeline, {
+    type: "call.failed",
+    callId: error.callId,
+    capability: error.capability,
+    provider: error.provider,
+    status: "failed",
+    errorCode: error.code,
+    safety: error.safety,
+    attempt: error.attempt ?? attempt,
+    attestation
+  });
+}
+async function emitCallAuditArtifact(options, details) {
+  if (!options.auditArtifacts || options.auditArtifacts.enabled === false || !options.auditArtifacts.onArtifact) {
+    return;
+  }
+  try {
+    const artifact = createProbeMeshCallAuditArtifact({
+      request: details.request,
+      response: details.response,
+      error: details.error,
+      timeline: details.timeline,
+      retrySafety: details.retrySafety,
+      attempt: details.attempt,
+      route: details.route
+    });
+    await options.auditArtifacts.onArtifact(artifact);
+  } catch {
+  }
+}
+function emitPaymentAndReceiptTelemetry(options, timeline, details) {
+  if (shouldEmitPaymentAttempted(details.safety, details.receiptRefs)) {
+    emitTelemetry(options, timeline, {
+      type: "payment.attempted",
+      callId: details.callId,
+      capability: details.capability,
+      provider: details.provider,
+      safety: details.safety,
+      attempt: details.attempt,
+      attestation: details.attestation
+    });
+  }
+  for (const receiptRef of details.receiptRefs ?? []) {
+    emitTelemetry(options, timeline, {
+      type: "receipt.recorded",
+      callId: details.callId,
+      capability: details.capability,
+      provider: receiptRef.provider,
+      receiptRef,
+      safety: details.safety,
+      attempt: details.attempt,
+      attestation: details.attestation
+    });
+  }
+}
+function shouldEmitPaymentAttempted(safety, receiptRefs) {
+  return safety?.paymentStatus === "authorized" || safety?.paymentStatus === "failed" || safety?.moneyMayHaveMoved === true || receiptRefs?.some((receiptRef) => receiptRef.type === "payment_proof") === true;
+}
+function emitTelemetry(options, timeline, event) {
+  const timelineEvent = {
+    ...event,
+    routeId: timeline.routeId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  timeline.events.push(timelineEvent);
+  options.onTelemetryEvent?.(timelineEvent);
+}
+function statusCodeForError(code) {
+  switch (code) {
+    case "unauthorized":
+      return 401;
+    case "invalid_request":
+      return 400;
+    case "retry_not_available":
+      return 409;
+    case "budget_exceeded":
+    case "receipt_missing":
+    case "invalid_provider_response":
+      return 422;
+    case "provider_timeout":
+    case "timeout_after_payment":
+      return 504;
+    case "provider_unavailable":
+    default:
+      return 503;
+  }
+}
+function writeJson(response, statusCode, body) {
+  response.statusCode = statusCode;
+  response.setHeader("content-type", "application/json");
+  response.end(JSON.stringify(body));
+}
+
+export {
+  createProbeMesh,
+  createHostedRouter,
+  startHostedRouter
+};
+//# sourceMappingURL=chunk-TV42EZSI.js.map