@elizaos/plugin-elizacloud 2.0.0-beta.1 → 2.0.3-beta.2

package/dist/cloud/index.js

@@ -15,16 +15,894 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cloud/base-url.ts
+import { normalizeCloudSiteUrl, resolveCloudApiBaseUrl } from "@elizaos/shared";
+var init_base_url = () => {};
+
+// src/cloud/x402-payment-handler.ts
+import { logger } from "@elizaos/core";
+function readString(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function readAmount(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  return null;
+}
+function normalizeRequirement(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const amount = readAmount(raw.amount);
+  const asset = readString(raw.asset);
+  const network = readString(raw.network);
+  const payTo = readString(raw.payTo);
+  if (!amount || !asset || !network || !payTo)
+    return null;
+  const scheme = readString(raw.scheme) ?? "exact";
+  return {
+    amount,
+    asset,
+    network,
+    payTo,
+    scheme,
+    expiresAt: readString(raw.expiresAt),
+    description: readString(raw.description)
+  };
+}
+function parseRequirementsArray(raw) {
+  if (!Array.isArray(raw))
+    return [];
+  const out = [];
+  for (const entry of raw) {
+    const normalized = normalizeRequirement(entry);
+    if (normalized)
+      out.push(normalized);
+  }
+  return out;
+}
+async function parseX402Response(response) {
+  const headerValue = response.headers.get("www-authenticate");
+  if (headerValue?.toLowerCase().startsWith("x402")) {
+    const jsonPart = headerValue.slice(4).trim();
+    if (jsonPart.length > 0) {
+      const parsed = JSON.parse(jsonPart);
+      const requirements2 = Array.isArray(parsed) ? parseRequirementsArray(parsed) : parseRequirementsArray(parsed.paymentRequirements ?? parsed.accepts);
+      if (requirements2.length > 0)
+        return requirements2;
+    }
+  }
+  const cloned = response.clone();
+  const text = await cloned.text();
+  if (text.length === 0)
+    return null;
+  const body = JSON.parse(text);
+  const requirements = parseRequirementsArray(body.paymentRequirements ?? body.accepts);
+  return requirements.length > 0 ? requirements : null;
+}
+
+class PaymentRequiredError extends Error {
+  code = "PAYMENT_REQUIRED";
+  requirements;
+  constructor(requirements, message) {
+    const text = message ?? `Eliza Cloud returned HTTP 402 — your credit balance can't cover this call. ${requirements.length} payment option(s) available.`;
+    super(text);
+    this.name = "PaymentRequiredError";
+    this.requirements = requirements;
+  }
+}
+async function requestPayment(runtime, requirements) {
+  if (requirements.length === 0) {
+    throw new Error("[x402] requestPayment called with no requirements — adapter bug");
+  }
+  const preferred = requirements[0];
+  logger.warn({
+    boundary: "elizacloud",
+    integration: "x402",
+    asset: preferred.asset,
+    network: preferred.network,
+    amount: preferred.amount,
+    runtimeId: runtime.agentId
+  }, `[x402] payment-required: ${preferred.amount} ${preferred.asset} on ${preferred.network} → ${preferred.payTo}${preferred.description ? ` (${preferred.description})` : ""}`);
+  return { status: "surfaced", requirement: preferred, txId: null };
+}
+
+// src/cloud/duffel-client.ts
+import { logger as logger2 } from "@elizaos/core";
+class DuffelConfigError extends Error {
+  code = "DUFFEL_NOT_CONFIGURED";
+  constructor(message) {
+    super(message);
+    this.name = "DuffelConfigError";
+  }
+}
+var DUFFEL_API_BASE_DEFAULT = "https://api.duffel.com";
+var DUFFEL_API_VERSION = "v2";
+var DEFAULT_CLOUD_RELAY_BASE = "http://127.0.0.1:31337";
+var NOOP_DUFFEL_SPAN = {
+  success() {},
+  failure() {}
+};
+function getDuffelApiBase() {
+  return process.env.LIFEOPS_DUFFEL_API_BASE?.trim() || DUFFEL_API_BASE_DEFAULT;
+}
+function resolveDirectFlag(env) {
+  const value = env.ELIZA_DUFFEL_DIRECT?.trim().toLowerCase();
+  return value === "1" || value === "true";
+}
+function resolveLocalApiBase(env) {
+  const port = env.ELIZA_API_PORT?.trim();
+  if (port && /^\d+$/.test(port)) {
+    return `http://127.0.0.1:${port}`;
+  }
+  return DEFAULT_CLOUD_RELAY_BASE;
+}
+function readDuffelConfigFromEnv(env = process.env) {
+  if (resolveDirectFlag(env)) {
+    const apiKey = env.DUFFEL_API_KEY?.trim();
+    if (!apiKey) {
+      throw new DuffelConfigError("Duffel direct mode requested but DUFFEL_API_KEY is not set.");
+    }
+    return { mode: "direct", apiKey, cloudRelayBaseUrl: null };
+  }
+  return {
+    mode: "cloud",
+    apiKey: null,
+    cloudRelayBaseUrl: resolveLocalApiBase(env)
+  };
+}
+var DIRECT_MODE_COST = {
+  totalUsd: 0,
+  creatorMarkupUsd: 0,
+  platformFeeUsd: 0,
+  markupPercent: null,
+  metered: false
+};
+function buildHeaders(apiKey) {
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    "Duffel-Version": DUFFEL_API_VERSION,
+    Accept: "application/json"
+  };
+}
+function mapOffer(raw) {
+  const cabinClass = raw.slices[0]?.fare_brand_name ?? null;
+  const slices = raw.slices.map((slice) => ({
+    origin: slice.origin.iata_code,
+    destination: slice.destination.iata_code,
+    duration: slice.duration,
+    segments: slice.segments.map((seg) => ({
+      origin: seg.origin.iata_code,
+      destination: seg.destination.iata_code,
+      departingAt: seg.departing_at,
+      arrivingAt: seg.arriving_at,
+      carrierIataCode: seg.operating_carrier.iata_code,
+      flightNumber: seg.flight_number ?? "",
+      duration: seg.duration
+    }))
+  }));
+  const passengers = raw.passengers.map((passenger, index) => ({
+    id: passenger.id?.trim() || `passenger_${index}`,
+    type: passenger.type?.trim() || "adult",
+    givenName: passenger.given_name?.trim() || null,
+    familyName: passenger.family_name?.trim() || null
+  }));
+  const paymentRequirements = raw.payment_requirements ? {
+    requiresInstantPayment: raw.payment_requirements.requires_instant_payment !== false,
+    priceGuaranteeExpiresAt: raw.payment_requirements.price_guarantee_expires_at ?? null,
+    paymentRequiredBy: raw.payment_requirements.payment_required_by ?? null
+  } : null;
+  return {
+    id: raw.id,
+    totalAmount: raw.total_amount,
+    totalCurrency: raw.total_currency,
+    passengerCount: passengers.length > 0 ? passengers.length : 1,
+    slices,
+    expiresAt: raw.expires_at,
+    cabinClass,
+    passengers,
+    paymentRequirements
+  };
+}
+function mapOrder(raw) {
+  return {
+    id: raw.id,
+    bookingReference: raw.booking_reference ?? null,
+    totalAmount: raw.total_amount,
+    totalCurrency: raw.total_currency,
+    slices: raw.slices.map((slice) => ({
+      origin: slice.origin.iata_code,
+      destination: slice.destination.iata_code,
+      duration: slice.duration,
+      segments: slice.segments.map((segment) => ({
+        origin: segment.origin.iata_code,
+        destination: segment.destination.iata_code,
+        departingAt: segment.departing_at,
+        arrivingAt: segment.arriving_at,
+        carrierIataCode: segment.operating_carrier.iata_code,
+        flightNumber: segment.flight_number ?? "",
+        duration: segment.duration
+      }))
+    })),
+    passengers: raw.passengers.map((passenger, index) => ({
+      id: passenger.id?.trim() || `passenger_${index}`,
+      givenName: passenger.given_name?.trim() || null,
+      familyName: passenger.family_name?.trim() || null
+    })),
+    paymentStatus: raw.payment_status ? {
+      awaitingPayment: raw.payment_status.awaiting_payment === true,
+      paymentRequiredBy: raw.payment_status.payment_required_by ?? null,
+      priceGuaranteeExpiresAt: raw.payment_status.price_guarantee_expires_at ?? null
+    } : null,
+    documents: (raw.documents ?? []).map((document) => ({
+      type: document.type ?? null,
+      uniqueIdentifier: document.unique_identifier ?? null
+    }))
+  };
+}
+function mapPayment(raw) {
+  return {
+    id: raw.id,
+    orderId: raw.order_id,
+    status: raw.status,
+    currency: raw.currency,
+    amount: raw.amount,
+    type: raw.type,
+    failureReason: raw.failure_reason ?? null,
+    createdAt: raw.created_at ?? null
+  };
+}
+function readRelayCost(envelope) {
+  if (envelope === null || typeof envelope !== "object" || !("_meta" in envelope)) {
+    throw new Error("Duffel cloud relay response missing _meta envelope. Update Eliza Cloud or set ELIZA_DUFFEL_DIRECT=1.");
+  }
+  const meta = envelope._meta;
+  const cost = meta?.cost;
+  if (!cost || typeof cost.total_usd !== "number" || typeof cost.creator_markup_usd !== "number" || typeof cost.platform_fee_usd !== "number") {
+    throw new Error("Duffel cloud relay returned malformed _meta.cost. Refusing to proceed without billing receipt.");
+  }
+  const totalUsd = cost.total_usd;
+  const platformFeeUsd = cost.platform_fee_usd;
+  const markupPercent = totalUsd > 0 ? platformFeeUsd / totalUsd : null;
+  return {
+    totalUsd,
+    creatorMarkupUsd: cost.creator_markup_usd,
+    platformFeeUsd,
+    markupPercent,
+    metered: true
+  };
+}
+async function duffelFetch(args) {
+  const { config, method, directPath, cloudRelayPath, body, operation } = args;
+  const isCloud = config.mode === "cloud";
+  const url = isCloud ? `${config.cloudRelayBaseUrl ?? ""}${cloudRelayPath}` : `${getDuffelApiBase()}${directPath}`;
+  const headers = isCloud ? { "Content-Type": "application/json", Accept: "application/json" } : buildHeaders(config.apiKey ?? "");
+  const span = NOOP_DUFFEL_SPAN;
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+      signal: AbortSignal.timeout(30000)
+    });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    logger2.error({
+      boundary: "elizacloud",
+      integration: "duffel",
+      operation,
+      mode: config.mode,
+      err: error instanceof Error ? error : undefined
+    }, `[elizacloud-duffel] Duffel ${operation} network error: ${msg}`);
+    span.failure({ error, errorKind: "network_error" });
+    throw new Error(`Duffel ${operation} failed: ${msg}`);
+  }
+  if (response.status === 402 && isCloud) {
+    const requirements = await parseX402Response(response);
+    logger2.warn({
+      boundary: "elizacloud",
+      integration: "duffel",
+      operation,
+      mode: config.mode,
+      statusCode: 402,
+      requirementCount: requirements?.length ?? 0
+    }, `[elizacloud-duffel] Duffel ${operation} returned 402 payment-required`);
+    span.failure({ statusCode: 402, errorKind: "payment_required" });
+    if (!requirements || requirements.length === 0) {
+      throw new PaymentRequiredError([], `Duffel ${operation} requires payment but the upstream did not advertise any payment options.`);
+    }
+    throw new PaymentRequiredError(requirements);
+  }
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => "");
+    const errorMsg = errorBody || `HTTP ${response.status}`;
+    logger2.warn({
+      boundary: "elizacloud",
+      integration: "duffel",
+      operation,
+      mode: config.mode,
+      statusCode: response.status
+    }, `[elizacloud-duffel] Duffel ${operation} HTTP error: ${errorMsg}`);
+    span.failure({ statusCode: response.status, errorKind: "http_error" });
+    throw new Error(`Duffel ${operation} failed (${response.status}): ${errorMsg}`);
+  }
+  const payload = await response.json();
+  span.success({ statusCode: response.status });
+  const cost = isCloud ? readRelayCost(payload) : DIRECT_MODE_COST;
+  return { data: payload, cost };
+}
+async function searchFlights(request, config) {
+  const resolvedConfig = config ?? readDuffelConfigFromEnv();
+  const passengerCount = Math.max(1, Math.round(request.passengers ?? 1));
+  const slices = [
+    {
+      origin: request.origin.toUpperCase().trim(),
+      destination: request.destination.toUpperCase().trim(),
+      departure_date: request.departureDate
+    }
+  ];
+  if (request.returnDate) {
+    slices.push({
+      origin: request.destination.toUpperCase().trim(),
+      destination: request.origin.toUpperCase().trim(),
+      departure_date: request.returnDate
+    });
+  }
+  const requestBody = {
+    data: {
+      slices,
+      passengers: Array.from({ length: passengerCount }, () => ({
+        type: "adult"
+      })),
+      cabin_class: "economy"
+    }
+  };
+  logger2.info({
+    boundary: "elizacloud",
+    integration: "duffel",
+    origin: request.origin,
+    destination: request.destination
+  }, `[elizacloud-duffel] Searching flights ${request.origin} → ${request.destination} on ${request.departureDate}`);
+  const { data: responseData, cost } = await duffelFetch({
+    config: resolvedConfig,
+    method: "POST",
+    directPath: "/air/offer_requests?return_offers=true",
+    cloudRelayPath: "/api/cloud/travel-providers/duffel/offer-requests",
+    body: requestBody,
+    operation: "offer_request"
+  });
+  const offers = responseData.data.offers.map(mapOffer);
+  logger2.info({
+    boundary: "elizacloud",
+    integration: "duffel",
+    offerRequestId: responseData.data.id,
+    offerCount: offers.length,
+    costUsd: cost.totalUsd
+  }, `[elizacloud-duffel] Duffel returned ${offers.length} offers for request ${responseData.data.id}`);
+  return {
+    offerRequestId: responseData.data.id,
+    offers,
+    cost
+  };
+}
+async function getOffer(id, config) {
+  const resolvedConfig = config ?? readDuffelConfigFromEnv();
+  if (!id || id.trim().length === 0) {
+    throw new Error("Duffel getOffer: offer id is required");
+  }
+  const { data: responseData } = await duffelFetch({
+    config: resolvedConfig,
+    method: "GET",
+    directPath: `/air/offers/${encodeURIComponent(id.trim())}`,
+    cloudRelayPath: `/api/cloud/travel-providers/duffel/offers/${encodeURIComponent(id.trim())}`,
+    operation: "offer_retrieve"
+  });
+  return mapOffer(responseData.data);
+}
+async function createOrder(request, config) {
+  const resolvedConfig = config ?? readDuffelConfigFromEnv();
+  if (request.selectedOffers.length !== 1) {
+    throw new Error("Duffel createOrder: exactly one selected offer is required");
+  }
+  if (request.passengers.length === 0) {
+    throw new Error("Duffel createOrder: at least one passenger is required");
+  }
+  const data = {
+    type: request.type,
+    selected_offers: [...request.selectedOffers],
+    passengers: request.passengers.map((passenger) => ({
+      id: passenger.id,
+      title: passenger.title,
+      gender: passenger.gender,
+      given_name: passenger.givenName,
+      family_name: passenger.familyName,
+      born_on: passenger.bornOn,
+      email: passenger.email,
+      phone_number: passenger.phoneNumber
+    }))
+  };
+  if (request.payment) {
+    data.payments = [
+      {
+        type: request.payment.type,
+        amount: request.payment.amount,
+        currency: request.payment.currency
+      }
+    ];
+  }
+  if (request.metadata && Object.keys(request.metadata).length > 0) {
+    data.metadata = request.metadata;
+  }
+  const { data: response } = await duffelFetch({
+    config: resolvedConfig,
+    method: "POST",
+    directPath: "/air/orders",
+    cloudRelayPath: "/api/cloud/travel-providers/duffel/orders",
+    body: { data },
+    operation: "order_create"
+  });
+  return mapOrder(response.data);
+}
+async function getOrder(orderId, config) {
+  const resolvedConfig = config ?? readDuffelConfigFromEnv();
+  if (!orderId || orderId.trim().length === 0) {
+    throw new Error("Duffel getOrder: order id is required");
+  }
+  const { data: response } = await duffelFetch({
+    config: resolvedConfig,
+    method: "GET",
+    directPath: `/air/orders/${encodeURIComponent(orderId.trim())}`,
+    cloudRelayPath: `/api/cloud/travel-providers/duffel/orders/${encodeURIComponent(orderId.trim())}`,
+    operation: "order_retrieve"
+  });
+  return mapOrder(response.data);
+}
+async function createPayment(args, config) {
+  const resolvedConfig = config ?? readDuffelConfigFromEnv();
+  if (args.orderId.trim().length === 0) {
+    throw new Error("Duffel createPayment: order id is required");
+  }
+  if (args.amount.trim().length === 0) {
+    throw new Error("Duffel createPayment: amount is required");
+  }
+  if (args.currency.trim().length === 0) {
+    throw new Error("Duffel createPayment: currency is required");
+  }
+  const { data: response } = await duffelFetch({
+    config: resolvedConfig,
+    method: "POST",
+    directPath: "/air/payments",
+    cloudRelayPath: "/api/cloud/travel-providers/duffel/payments",
+    body: {
+      data: {
+        order_id: args.orderId.trim(),
+        payment: {
+          type: "balance",
+          amount: args.amount.trim(),
+          currency: args.currency.trim().toUpperCase()
+        }
+      }
+    },
+    operation: "payment_create"
+  });
+  return mapPayment(response.data);
+}
+
+// src/cloud/lifeops-schedule-sync-client.ts
+init_base_url();
+var LIFEOPS_SCHEDULE_REQUEST_TIMEOUT_MS = 20000;
+
+class LifeOpsScheduleSyncClientError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "LifeOpsScheduleSyncClientError";
+  }
+}
+function normalizeOptionalString(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : null;
+}
+function normalizeLifeOpsScheduleSyncSecret(value) {
+  const trimmed = normalizeOptionalString(value);
+  if (!trimmed) {
+    return null;
+  }
+  return trimmed.toUpperCase() === "[REDACTED]" ? null : trimmed;
+}
+function resolveLifeOpsScheduleSyncConfig(config = {}) {
+  const remoteApiBase = normalizeOptionalString(config.remoteApiBase);
+  if (remoteApiBase) {
+    return {
+      configured: true,
+      mode: "remote",
+      baseUrl: remoteApiBase.replace(/\/+$/, ""),
+      accessToken: normalizeLifeOpsScheduleSyncSecret(config.remoteAccessToken) ?? normalizeLifeOpsScheduleSyncSecret(process.env.ELIZA_REMOTE_ACCESS_TOKEN)
+    };
+  }
+  const apiKey = normalizeLifeOpsScheduleSyncSecret(config.apiKey) ?? normalizeLifeOpsScheduleSyncSecret(process.env.ELIZAOS_CLOUD_API_KEY);
+  const agentId = normalizeLifeOpsScheduleSyncSecret(config.agentId) ?? normalizeLifeOpsScheduleSyncSecret(process.env.ELIZAOS_CLOUD_AGENT_ID);
+  if (!apiKey || !agentId) {
+    return {
+      configured: false,
+      mode: "none"
+    };
+  }
+  return {
+    configured: true,
+    mode: "cloud",
+    apiBaseUrl: resolveCloudApiBaseUrl(normalizeOptionalString(config.baseUrl) ?? process.env.ELIZAOS_CLOUD_BASE_URL),
+    apiKey,
+    agentId
+  };
+}
+function buildTimeoutSignal() {
+  return AbortSignal.timeout(LIFEOPS_SCHEDULE_REQUEST_TIMEOUT_MS);
+}
+async function readJsonResponse(response) {
+  if (!response.ok) {
+    let detail = `${response.status} ${response.statusText}`.trim();
+    const text = await response.text();
+    const trimmed = text.trim();
+    if (trimmed.length > 0) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        detail = parsed.message ?? parsed.error ?? trimmed;
+      } catch {
+        detail = trimmed.slice(0, 200);
+      }
+    }
+    throw new LifeOpsScheduleSyncClientError(response.status, detail);
+  }
+  return await response.json();
+}
+function resolveLifeOpsScheduleSyncSiteUrl(rawUrl) {
+  return normalizeCloudSiteUrl(rawUrl);
+}
+
+class LifeOpsScheduleSyncClient {
+  configSource;
+  constructor(configSource = resolveLifeOpsScheduleSyncConfig) {
+    this.configSource = configSource;
+  }
+  getConfig() {
+    return typeof this.configSource === "function" ? this.configSource() : this.configSource;
+  }
+  get configured() {
+    return this.getConfig().configured;
+  }
+  requireConfig() {
+    const config = this.getConfig();
+    if (!config.configured) {
+      throw new LifeOpsScheduleSyncClientError(409, "LifeOps schedule sync is not configured.");
+    }
+    return config;
+  }
+  resolvePath(pathname) {
+    const config = this.requireConfig();
+    const normalizedPath = pathname.replace(/^\/+/, "");
+    if (config.mode === "remote") {
+      return new URL(`api/lifeops/schedule/${normalizedPath}`, `${config.baseUrl.replace(/\/+$/, "")}/`).toString();
+    }
+    return new URL(`eliza/agents/${encodeURIComponent(config.agentId)}/lifeops/schedule/${normalizedPath}`, `${config.apiBaseUrl.replace(/\/+$/, "")}/`).toString();
+  }
+  requestHeaders(initHeaders) {
+    const config = this.requireConfig();
+    const headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    };
+    if (config.mode === "cloud") {
+      headers["X-API-Key"] = config.apiKey;
+    }
+    if (config.mode === "remote" && config.accessToken) {
+      headers.Authorization = `Bearer ${config.accessToken}`;
+    }
+    if (initHeaders instanceof Headers) {
+      for (const [key, value] of initHeaders.entries()) {
+        headers[key] = value;
+      }
+      return headers;
+    }
+    if (Array.isArray(initHeaders)) {
+      for (const [key, value] of initHeaders) {
+        headers[key] = value;
+      }
+      return headers;
+    }
+    return {
+      ...headers,
+      ...initHeaders ?? {}
+    };
+  }
+  async request(pathname, init) {
+    const response = await fetch(this.resolvePath(pathname), {
+      ...init,
+      headers: this.requestHeaders(init.headers),
+      signal: init.signal ?? buildTimeoutSignal()
+    });
+    return readJsonResponse(response);
+  }
+  async syncObservations(request) {
+    return this.request("observations", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async getMergedState(timezone, scope = "cloud") {
+    const query = new URLSearchParams({ timezone, scope });
+    return this.request(`merged-state?${query.toString()}`, {
+      method: "GET"
+    });
+  }
+}
+
+// src/cloud/lifeops-schedule-sync-contracts.ts
+var LIFEOPS_SCHEDULE_DEVICE_KINDS = [
+  "iphone",
+  "ipad",
+  "mac",
+  "watch",
+  "cloud",
+  "unknown"
+];
+var LIFEOPS_SCHEDULE_OBSERVATION_ORIGINS = [
+  "local_inference",
+  "device_sync"
+];
+var LIFEOPS_SCHEDULE_STATE_SCOPES = ["local", "cloud"];
+
+// src/cloud/managed-payment-clients.ts
+init_base_url();
+init_base_url();
+function normalizeElizaCloudApiKey(value) {
+  const trimmed = value?.trim();
+  if (!trimmed)
+    return null;
+  return trimmed.toUpperCase() === "[REDACTED]" ? null : trimmed;
+}
+function resolveEnvElizaCloudManagedClientConfig(env = typeof process === "undefined" ? {} : process.env) {
+  const apiKey = normalizeElizaCloudApiKey(env.ELIZAOS_CLOUD_API_KEY);
+  const baseUrl = env.ELIZAOS_CLOUD_BASE_URL;
+  return {
+    configured: Boolean(apiKey),
+    apiKey,
+    apiBaseUrl: resolveCloudApiBaseUrl(baseUrl),
+    siteUrl: normalizeCloudSiteUrl(baseUrl)
+  };
+}
+var PLAID_REQUEST_TIMEOUT_MS = 30000;
+var PAYPAL_REQUEST_TIMEOUT_MS = 30000;
+
+class PlaidManagedClientError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "PlaidManagedClientError";
+  }
+}
+
+class PaypalManagedClientError extends Error {
+  status;
+  fallback;
+  constructor(status, message, fallback = null) {
+    super(message);
+    this.status = status;
+    this.fallback = fallback;
+    this.name = "PaypalManagedClientError";
+  }
+}
+async function readPlaidJson(response) {
+  if (!response.ok) {
+    let detail = `${response.status} ${response.statusText}`.trim();
+    const text = await response.text();
+    if (text.trim().length > 0) {
+      try {
+        const parsed = JSON.parse(text);
+        detail = parsed.message ?? parsed.error ?? text.slice(0, 240);
+      } catch {
+        detail = text.slice(0, 240);
+      }
+    }
+    throw new PlaidManagedClientError(response.status, detail);
+  }
+  return await response.json();
+}
+async function readPaypalJson(response) {
+  if (!response.ok) {
+    let detail = `${response.status} ${response.statusText}`.trim();
+    let fallback = null;
+    const text = await response.text();
+    if (text.trim().length > 0) {
+      try {
+        const parsed = JSON.parse(text);
+        detail = parsed.message ?? parsed.error ?? text.slice(0, 240);
+        fallback = parsed.fallback ?? null;
+      } catch {
+        detail = text.slice(0, 240);
+      }
+    }
+    throw new PaypalManagedClientError(response.status, detail, fallback);
+  }
+  return await response.json();
+}
+
+class PlaidManagedClient {
+  configSource;
+  constructor(configSource = resolveEnvElizaCloudManagedClientConfig) {
+    this.configSource = configSource;
+  }
+  requireConfig() {
+    const config = this.configSource();
+    if (!config.apiKey) {
+      throw new PlaidManagedClientError(409, "Eliza Cloud is not connected.");
+    }
+    return { ...config, apiKey: config.apiKey };
+  }
+  get configured() {
+    return this.configSource().configured;
+  }
+  async createLinkToken() {
+    const config = this.requireConfig();
+    const response = await fetch(`${config.apiBaseUrl}/v1/eliza/plaid/link-token`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: "{}",
+      signal: AbortSignal.timeout(PLAID_REQUEST_TIMEOUT_MS)
+    });
+    return readPlaidJson(response);
+  }
+  async exchangePublicToken(args) {
+    const config = this.requireConfig();
+    const response = await fetch(`${config.apiBaseUrl}/v1/eliza/plaid/exchange`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ publicToken: args.publicToken }),
+      signal: AbortSignal.timeout(PLAID_REQUEST_TIMEOUT_MS)
+    });
+    return readPlaidJson(response);
+  }
+  async syncTransactions(args) {
+    const config = this.requireConfig();
+    const response = await fetch(`${config.apiBaseUrl}/v1/eliza/plaid/sync`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        accessToken: args.accessToken,
+        cursor: args.cursor ?? "",
+        count: args.count ?? 250
+      }),
+      signal: AbortSignal.timeout(PLAID_REQUEST_TIMEOUT_MS * 2)
+    });
+    return readPlaidJson(response);
+  }
+}
+
+class PaypalManagedClient {
+  configSource;
+  constructor(configSource = resolveEnvElizaCloudManagedClientConfig) {
+    this.configSource = configSource;
+  }
+  requireConfig() {
+    const config = this.configSource();
+    if (!config.apiKey) {
+      throw new PaypalManagedClientError(409, "Eliza Cloud is not connected.");
+    }
+    return { ...config, apiKey: config.apiKey };
+  }
+  get configured() {
+    return this.configSource().configured;
+  }
+  async buildAuthorizeUrl(args) {
+    const config = this.requireConfig();
+    const response = await fetch(`${config.apiBaseUrl}/v1/eliza/paypal/authorize`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ state: args.state }),
+      signal: AbortSignal.timeout(PAYPAL_REQUEST_TIMEOUT_MS)
+    });
+    return readPaypalJson(response);
+  }
+  async exchangeCode(args) {
+    const config = this.requireConfig();
+    const response = await fetch(`${config.apiBaseUrl}/v1/eliza/paypal/callback`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ code: args.code }),
+      signal: AbortSignal.timeout(PAYPAL_REQUEST_TIMEOUT_MS)
+    });
+    return readPaypalJson(response);
+  }
+  async refreshAccessToken(args) {
+    const config = this.requireConfig();
+    const response = await fetch(`${config.apiBaseUrl}/v1/eliza/paypal/refresh`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ refreshToken: args.refreshToken }),
+      signal: AbortSignal.timeout(PAYPAL_REQUEST_TIMEOUT_MS)
+    });
+    return readPaypalJson(response);
+  }
+  async searchTransactions(args) {
+    const config = this.requireConfig();
+    const response = await fetch(`${config.apiBaseUrl}/v1/eliza/paypal/transactions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(args),
+      signal: AbortSignal.timeout(PAYPAL_REQUEST_TIMEOUT_MS * 2)
+    });
+    return readPaypalJson(response);
+  }
+}
 export {
   validateCloudBaseUrl,
-  resolveCloudApiBaseUrl,
-  normalizeCloudSiteUrl,
+  searchFlights,
+  resolveLifeOpsScheduleSyncSiteUrl,
+  resolveLifeOpsScheduleSyncConfig,
+  resolveEnvElizaCloudManagedClientConfig,
+  resolveCloudApiBaseUrl2 as resolveCloudApiBaseUrl,
+  requestPayment,
+  readDuffelConfigFromEnv,
+  parseX402Response,
+  normalizeLifeOpsScheduleSyncSecret,
+  normalizeElizaCloudApiKey,
+  normalizeCloudSiteUrl2 as normalizeCloudSiteUrl,
+  normalizeCloudApiKey,
+  isCloudAuthApiKeyService,
+  getOrder,
+  getOffer,
+  createPayment,
+  createOrder,
   cloudLogin,
+  PlaidManagedClientError,
+  PlaidManagedClient,
+  PaypalManagedClientError,
+  PaypalManagedClient,
+  PaymentRequiredError,
+  LifeOpsScheduleSyncClientError,
+  LifeOpsScheduleSyncClient,
+  LIFEOPS_SCHEDULE_STATE_SCOPES,
+  LIFEOPS_SCHEDULE_OBSERVATION_ORIGINS,
+  LIFEOPS_SCHEDULE_DEVICE_KINDS,
   ElizaCloudClient,
+  DuffelConfigError,
   ConnectionMonitor,
   CloudRuntimeProxy,
   CloudManager,
   BackupScheduler
 };
 
-//# debugId=D795A73DE077BF4564756E2164756E21
+//# debugId=DEF1FE9ADA582A9064756E2164756E21