@byte_fluffy/nexra-sdk 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1428 @@
+import {
+  CatalogClient,
+  HttpTransport,
+  NexraApiError,
+  NexraTaskError,
+  NexraWaitTimeoutError,
+  getModelSpec,
+  jsonBody,
+  listModelSpecs,
+  queryString,
+  sleep
+} from "./chunk-ADKRTC6X.js";
+import {
+  ceilDecimal,
+  multiplyDecimal
+} from "./chunk-FCH5IQP5.js";
+
+// ../contracts/src/assets.ts
+var MEDIA_KINDS = [
+  "image",
+  "video",
+  "audio",
+  "document",
+  "archive",
+  "other"
+];
+
+// ../contracts/src/uploaded-media.ts
+function modelUploadRegion(regions) {
+  return regions.length > 0 && regions.every((region) => /^cn(?:-|$)/.test(region.trim().toLowerCase())) ? "cn" : "global";
+}
+function uploadedMediaUrl(value, region) {
+  if (!value.startsWith("https://")) return value;
+  try {
+    const url = new URL(value);
+    if (url.username || url.password || url.port || !["tos.nexra-ai.com", "tos2.nexra-ai.com", "upload.nexra-ai.com"].includes(url.hostname) || !url.pathname.startsWith("/user-assets/") || url.pathname === "/user-assets/") return value;
+    url.hostname = region === "cn" ? "tos.nexra-ai.com" : "tos2.nexra-ai.com";
+    return url.href;
+  } catch {
+    return value;
+  }
+}
+function uploadedMediaInput(input, region) {
+  const visit = (value) => {
+    if (typeof value === "string") return uploadedMediaUrl(value, region);
+    if (Array.isArray(value)) return value.map(visit);
+    if (value !== null && typeof value === "object") {
+      return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        ["text", "texts", "prompt", "negative_prompt", "negativePrompt"].includes(key) ? item : visit(item)
+      ]));
+    }
+    return value;
+  };
+  return visit(input);
+}
+
+// ../contracts/src/admin-usage.ts
+var USAGE_SOURCES = ["provider", "estimated", "reconciled"];
+var USAGE_NORMALIZATION_STATUSES = [
+  "normalized",
+  "partial",
+  "invalid",
+  "missing"
+];
+var USAGE_RATING_STATUSES = [
+  "billed",
+  "unsettled",
+  "billing_failed",
+  "unpriced",
+  "usage_missing"
+];
+var USAGE_GROUP_BYS = [
+  "minute",
+  "hour",
+  "day",
+  "month",
+  "user",
+  "apiKey",
+  "provider",
+  "channel",
+  "model",
+  "operation"
+];
+var USAGE_AMOUNT_KINDS = ["sale", "cost", "gross"];
+var TOKEN_METRICS = [
+  "input_tokens",
+  "cached_input_tokens",
+  "cache_write_tokens",
+  "cache_creation_5m_input_tokens",
+  "cache_creation_1h_input_tokens",
+  "cache_read_input_tokens",
+  "output_tokens"
+];
+var MONEY_STRING_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d{1,8})?$/;
+var USAGE_FILTER_SELECTION_LIMIT = 200;
+function validateUsageFilters(value) {
+  if (!isObject(value)) throw new Error("Usage filters must be an object");
+  const filters = value;
+  const start = Date.parse(String(filters.start));
+  const end = Date.parse(String(filters.end));
+  if (!Number.isFinite(start)) throw new Error("filters.start must be an ISO-8601 instant");
+  if (!Number.isFinite(end)) throw new Error("filters.end must be an ISO-8601 instant");
+  if (start >= end) throw new Error("filters.end must be after filters.start ([start, end) window)");
+  if (filters.timeZoneOffsetMinutes !== void 0 && (!Number.isSafeInteger(filters.timeZoneOffsetMinutes) || filters.timeZoneOffsetMinutes < -720 || filters.timeZoneOffsetMinutes > 840)) {
+    throw new Error("filters.timeZoneOffsetMinutes must be an integer between -720 and 840");
+  }
+  for (const key of ["userIds", "apiKeyIds", "providerIds", "channelIds", "modelIds", "operations", "requestStatuses"]) {
+    const list = filters[key];
+    if (list !== void 0 && (!isStringArray(list) || list.length > USAGE_FILTER_SELECTION_LIMIT)) {
+      throw new Error(`filters.${key} must be at most ${USAGE_FILTER_SELECTION_LIMIT} non-empty strings`);
+    }
+  }
+  if (filters.upstreamModelId !== void 0 && (typeof filters.upstreamModelId !== "string" || filters.upstreamModelId === "")) {
+    throw new Error("filters.upstreamModelId must be a non-empty string");
+  }
+  for (const key of ["usageSources", "normalizationStatuses", "ratingStatuses"]) {
+    const list = filters[key];
+    if (list === void 0) continue;
+    if (!isStringArray(list)) throw new Error(`filters.${key} must be an array of non-empty strings`);
+    const allowed = key === "usageSources" ? USAGE_SOURCES : key === "normalizationStatuses" ? USAGE_NORMALIZATION_STATUSES : USAGE_RATING_STATUSES;
+    if (list.some((item) => !allowed.includes(item))) {
+      throw new Error(`filters.${key} contains an unsupported status`);
+    }
+  }
+}
+function validateUsageSummaryQuery(value) {
+  if (!isObject(value)) throw new Error("Usage summary query must be an object");
+  validateUsageFilters(value.filters);
+  if (!Array.isArray(value.groupBy) || value.groupBy.length === 0) {
+    throw new Error("groupBy must be a non-empty array");
+  }
+  const timeGranularities = value.groupBy.filter(
+    (key) => ["minute", "hour", "day", "month"].includes(String(key))
+  );
+  if (timeGranularities.length > 1) {
+    throw new Error("groupBy accepts at most one time granularity");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of value.groupBy) {
+    if (!USAGE_GROUP_BYS.includes(String(key))) {
+      throw new Error(`groupBy contains an unsupported key: ${String(key)}`);
+    }
+    if (seen.has(String(key))) throw new Error("groupBy contains duplicate keys");
+    seen.add(String(key));
+  }
+  if (!Number.isSafeInteger(value.limit) || value.limit < 1 || value.limit > 500) {
+    throw new Error("limit must be an integer between 1 and 500");
+  }
+  if (value.cursor !== void 0 && (typeof value.cursor !== "string" || value.cursor === "")) {
+    throw new Error("cursor must be a non-empty string");
+  }
+}
+var CURSOR_PREFIX = "v1.offset.";
+function encodeUsageSummaryCursor(offset) {
+  return `${CURSOR_PREFIX}${offset}`;
+}
+function parseUsageSummaryCursor(value) {
+  if (!value.startsWith(CURSOR_PREFIX)) return null;
+  const offset = Number(value.slice(CURSOR_PREFIX.length));
+  return Number.isSafeInteger(offset) && offset >= 0 ? offset : null;
+}
+var KEYSET_CURSOR_PREFIX = "v1.key.";
+function encodeUsageKeysetCursor(receivedAt, requestId) {
+  return `${KEYSET_CURSOR_PREFIX}${encodeURIComponent(receivedAt)}|${encodeURIComponent(requestId)}`;
+}
+function parseUsageKeysetCursor(value) {
+  if (!value.startsWith(KEYSET_CURSOR_PREFIX)) return null;
+  const parts = value.slice(KEYSET_CURSOR_PREFIX.length).split("|");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) return null;
+  let receivedAt;
+  let requestId;
+  try {
+    receivedAt = decodeURIComponent(parts[0]);
+    requestId = decodeURIComponent(parts[1]);
+  } catch {
+    return null;
+  }
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(requestId)) {
+    return null;
+  }
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?Z$/.test(receivedAt) || !Number.isFinite(Date.parse(receivedAt))) return null;
+  if (new Date(receivedAt).toISOString().slice(0, 19) !== receivedAt.slice(0, 19)) return null;
+  return { receivedAt, requestId };
+}
+function validateUsageDetailsQuery(value) {
+  if (!isObject(value)) throw new Error("Usage details query must be an object");
+  validateUsageFilters(value.filters);
+  if (!Number.isSafeInteger(value.limit) || value.limit < 1 || value.limit > 200) {
+    throw new Error("limit must be an integer between 1 and 200");
+  }
+  if (value.cursor !== void 0 && (typeof value.cursor !== "string" || value.cursor === "")) {
+    throw new Error("cursor must be a non-empty string");
+  }
+}
+var USAGE_ANOMALY_CATEGORIES = [
+  "usage_missing",
+  "normalization_failed",
+  "unpriced",
+  "dimension_mismatch",
+  "settlement_failed"
+];
+function validateUsageAnomaliesQuery(value) {
+  if (!isObject(value)) throw new Error("Usage anomalies query must be an object");
+  validateUsageFilters(value.filters);
+  if (value.categories !== void 0) {
+    if (!isStringArray(value.categories) || value.categories.some((item) => !USAGE_ANOMALY_CATEGORIES.includes(item))) {
+      throw new Error("categories contains an unsupported anomaly category");
+    }
+  }
+  if (!Number.isSafeInteger(value.limit) || value.limit < 1 || value.limit > 200) {
+    throw new Error("limit must be an integer between 1 and 200");
+  }
+  if (value.cursor !== void 0 && (typeof value.cursor !== "string" || value.cursor === "")) {
+    throw new Error("cursor must be a non-empty string");
+  }
+}
+function validateUsageAnomalySummaryQuery(value) {
+  if (!isObject(value)) throw new Error("Usage anomaly summary query must be an object");
+  validateUsageFilters(value.filters);
+  if (value.breakdowns !== void 0) {
+    if (!Array.isArray(value.breakdowns) || value.breakdowns.length > 2 || value.breakdowns.some((item) => !["provider", "channel", "model"].includes(String(item)))) {
+      throw new Error("breakdowns accepts at most two of provider, channel, model");
+    }
+  }
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === "string" && item !== "");
+}
+
+// ../contracts/src/admin-users.ts
+var ADMIN_USER_ROLES = ["admin", "dealer", "user"];
+var ADMIN_USER_STATUSES = ["active", "banned"];
+function validateAdminUserListQuery(value) {
+  if (!isObject2(value)) throw new Error("User list query must be an object");
+  if (value.query !== void 0 && (typeof value.query !== "string" || value.query.trim() === "" || value.query.length > 320)) {
+    throw new Error("query must be a non-empty string of at most 320 characters");
+  }
+  if (value.role !== void 0 && !ADMIN_USER_ROLES.includes(String(value.role))) {
+    throw new Error("role is not supported");
+  }
+  if (value.status !== void 0 && !ADMIN_USER_STATUSES.includes(String(value.status))) {
+    throw new Error("status is not supported");
+  }
+  if (!Number.isSafeInteger(value.limit) || value.limit < 1 || value.limit > 200) {
+    throw new Error("limit must be an integer between 1 and 200");
+  }
+  if (value.cursor !== void 0 && (typeof value.cursor !== "string" || value.cursor === "")) {
+    throw new Error("cursor must be a non-empty string");
+  }
+}
+var USER_CURSOR_PREFIX = "v1.user.";
+function encodeAdminUserCursor(cursor) {
+  return `${USER_CURSOR_PREFIX}${encodeURIComponent(cursor.createdAt)}|${encodeURIComponent(cursor.userId)}`;
+}
+function parseAdminUserCursor(value) {
+  try {
+    if (!value.startsWith(USER_CURSOR_PREFIX)) return null;
+    const parts = value.slice(USER_CURSOR_PREFIX.length).split("|");
+    if (parts.length !== 2) return null;
+    const [encodedCreatedAt, encodedUserId] = parts;
+    if (!encodedCreatedAt || !encodedUserId) return null;
+    const createdAt = decodeURIComponent(encodedCreatedAt);
+    const userId = decodeURIComponent(encodedUserId);
+    return Number.isFinite(Date.parse(createdAt)) && userId !== "" ? { createdAt, userId } : null;
+  } catch {
+    return null;
+  }
+}
+var ADMIN_USER_ACTIVITY_KINDS = ["ledger", "recharge", "hold", "audit"];
+function isMoneyString(value) {
+  return MONEY_STRING_PATTERN.test(value);
+}
+function validateAdminUserUpdate(value) {
+  if (!isObject2(value)) throw new Error("User update must be an object");
+  if (typeof value.reason !== "string" || value.reason.trim() === "" || value.reason.length > 500) {
+    throw new Error("reason is required (at most 500 characters)");
+  }
+  if (value.role !== void 0 && !ADMIN_USER_ROLES.includes(String(value.role))) {
+    throw new Error("role is not supported");
+  }
+  if (value.status !== void 0 && !ADMIN_USER_STATUSES.includes(String(value.status))) {
+    throw new Error("status is not supported");
+  }
+  if (value.qpsLimit !== void 0 && (!Number.isSafeInteger(value.qpsLimit) || value.qpsLimit < 1 || value.qpsLimit > 1e5)) {
+    throw new Error("qpsLimit must be an integer between 1 and 100000");
+  }
+  if (value.role === void 0 && value.status === void 0 && value.qpsLimit === void 0) {
+    throw new Error("At least one of role, status, or qpsLimit is required");
+  }
+}
+function validateAdminUserApiKeyUpdate(value) {
+  if (!isObject2(value)) throw new Error("API key update must be an object");
+  if (typeof value.reason !== "string" || value.reason.trim() === "" || value.reason.length > 500) {
+    throw new Error("reason is required (at most 500 characters)");
+  }
+  if (value.revoked !== void 0 && typeof value.revoked !== "boolean") {
+    throw new Error("revoked must be a boolean");
+  }
+  if (value.rateLimitPerSecond !== void 0 && value.rateLimitPerSecond !== null && (!Number.isSafeInteger(value.rateLimitPerSecond) || value.rateLimitPerSecond < 1 || value.rateLimitPerSecond > 1e5)) {
+    throw new Error("rateLimitPerSecond must be an integer between 1 and 100000, or null");
+  }
+  if (value.revoked === void 0 && value.rateLimitPerSecond === void 0) {
+    throw new Error("At least one of revoked or rateLimitPerSecond is required");
+  }
+}
+function validateAdminWalletRechargeInput(value) {
+  if (!isObject2(value)) throw new Error("Wallet recharge must be an object");
+  if (typeof value.userId !== "string" || value.userId === "") {
+    throw new Error("userId is required");
+  }
+  if (value.currency !== "CNY") {
+    throw new Error("currency must be CNY");
+  }
+  if (typeof value.amount !== "string" || !isMoneyString(value.amount) || value.amount.startsWith("-") || Number(value.amount) <= 0) {
+    throw new Error("amount must be a positive decimal string");
+  }
+  if ((value.amount.split(".")[0]?.length ?? 0) > 12) {
+    throw new Error("amount exceeds the 12-digit integer limit of the wallet balance");
+  }
+  if (typeof value.externalOrderId !== "string" || value.externalOrderId.trim() === "" || value.externalOrderId.trim().length > 240) {
+    throw new Error("externalOrderId is required (at most 240 characters)");
+  }
+  if (typeof value.reason !== "string" || value.reason.trim() === "" || value.reason.length > 500) {
+    throw new Error("reason is required (at most 500 characters)");
+  }
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../contracts/src/usage-filter-options.ts
+var USAGE_FILTER_KINDS = ["model", "user", "apiKey", "provider", "channel", "operation"];
+var MODEL_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function validId(kind, id) {
+  return typeof id === "string" && id.length > 0 && id.length <= 128 && !/[\s,|]/u.test(id) && (kind === "user" || kind === "operation" || MODEL_ID.test(id));
+}
+function encodeUsageFilterCursor(kind, query, id) {
+  return `usage-filter-v1|${kind}|${encodeURIComponent(query)}|${encodeURIComponent(id)}`;
+}
+function parseUsageFilterCursor(value, kind, query) {
+  try {
+    const parts = value.split("|");
+    if (parts.length !== 4 || parts[0] !== "usage-filter-v1" || parts[1] !== kind || decodeURIComponent(parts[2]) !== query) return null;
+    const id = decodeURIComponent(parts[3]);
+    return validId(kind, id) ? id : null;
+  } catch {
+    return null;
+  }
+}
+function validateUsageFilterOptionsQuery(kind, value) {
+  if (!value || typeof value !== "object") throw new Error("\u7B5B\u9009\u67E5\u8BE2\u683C\u5F0F\u4E0D\u6B63\u786E");
+  const query = value;
+  if (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 100) throw new Error("\u4E00\u6B21\u6700\u591A\u67E5\u8BE2 100 \u9879");
+  if (query.query !== void 0 && (typeof query.query !== "string" || !query.query.trim() || query.query.length > 320)) throw new Error("\u641C\u7D22\u5185\u5BB9\u5FC5\u987B\u4E3A 1 \u81F3 320 \u4E2A\u5B57\u7B26");
+  if (query.ids !== void 0) {
+    if (!Array.isArray(query.ids) || !query.ids.length || query.ids.length > query.limit || query.ids.some((id) => !validId(kind, id))) throw new Error("\u8BF7\u8F93\u5165\u6709\u6548\u7684\u5185\u90E8 ID\uFF0C\u4E00\u6B21\u6700\u591A 100 \u9879");
+    if (query.query !== void 0 || query.cursor !== void 0) throw new Error("ID \u786E\u8BA4\u4E0D\u80FD\u540C\u65F6\u4F7F\u7528\u641C\u7D22\u6216\u5206\u9875");
+  }
+  if (query.cursor !== void 0 && (typeof query.cursor !== "string" || query.cursor.length > 4096 || !parseUsageFilterCursor(query.cursor, kind, query.query ?? ""))) throw new Error("\u5206\u9875\u6E38\u6807\u4E0E\u5F53\u524D\u7B5B\u9009\u4E0D\u5339\u914D");
+}
+
+// ../contracts/src/money.ts
+var MONEY_SCALE = 100000000n;
+var BILLING_CURRENCY = "CNY";
+var WALLET_MAX_BALANCE_UNITS = 99999999999999999999n;
+function moneyToUnits(value) {
+  if (!/^-?\d+(\.\d{1,8})?$/.test(value)) throw new Error("Invalid money amount");
+  const negative = value.startsWith("-");
+  const [whole = "0", fraction = ""] = (negative ? value.slice(1) : value).split(".");
+  const units = BigInt(whole) * MONEY_SCALE + BigInt(fraction.padEnd(8, "0"));
+  return negative ? -units : units;
+}
+function moneyFromUnits(value) {
+  const negative = value < 0n;
+  const absolute = negative ? -value : value;
+  const fraction = (absolute % MONEY_SCALE).toString().padStart(8, "0").replace(/0+$/, "");
+  return `${negative ? "-" : ""}${absolute / MONEY_SCALE}${fraction ? `.${fraction}` : ""}`;
+}
+function multiplyMoney(value, multiplier, ...additionalMultipliers) {
+  let product = moneyToUnits(value);
+  if (product < 0n) throw new Error("Money amount must be non-negative");
+  let divisor = 1n;
+  for (const multiplierValue of [multiplier, ...additionalMultipliers]) {
+    const factor = moneyToUnits(multiplierValue);
+    if (factor <= 0n) throw new Error("Money multiplier must be positive");
+    product *= factor;
+    divisor *= MONEY_SCALE;
+  }
+  return moneyFromUnits((product + divisor / 2n) / divisor);
+}
+
+// ../contracts/src/model-schema.ts
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function normalizeModelParameterSchema(source) {
+  const result = structuredClone(source);
+  const input = object(result.input);
+  const properties = object(input.properties);
+  const ui = object(result.ui);
+  const fields = object(ui.fields);
+  const defaults = object(result.defaults);
+  const order = Array.isArray(ui.order) ? ui.order : [];
+  for (const [key, value] of Object.entries(properties)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const position = order.indexOf(key);
+    const decoration = {
+      ...position >= 0 ? { order: position } : {},
+      ...object(fields[key]),
+      ...object(value["x-ui"])
+    };
+    if (Object.keys(decoration).length) value["x-ui"] = decoration;
+    if (key in defaults) value.default = defaults[key];
+  }
+  delete result.ui;
+  delete result.defaults;
+  return result;
+}
+function modelInputDefaults(input) {
+  return Object.fromEntries(Object.entries(object(input.properties)).flatMap(([key, value]) => {
+    const field = object(value);
+    return "default" in field ? [[key, structuredClone(field.default)]] : [];
+  }));
+}
+function orderedSchemaProperties(schema) {
+  const rank = (value) => {
+    const order = object(object(value)["x-ui"]).order;
+    return typeof order === "number" ? order : Number.MAX_SAFE_INTEGER;
+  };
+  return Object.entries(object(schema.properties)).sort(([, a], [, b]) => rank(a) - rank(b));
+}
+function modelInputUi(input) {
+  const entries = orderedSchemaProperties(input);
+  return {
+    order: entries.map(([key]) => key),
+    fields: Object.fromEntries(entries.flatMap(([key, value]) => {
+      const { order: _order, ...ui } = object(object(value)["x-ui"]);
+      return Object.keys(ui).length ? [[key, ui]] : [];
+    }))
+  };
+}
+
+// ../contracts/src/pricing.ts
+var BILLING_METRICS = [
+  "requests",
+  "input_tokens",
+  "cached_input_tokens",
+  "cache_write_tokens",
+  "cache_creation_5m_input_tokens",
+  "cache_creation_1h_input_tokens",
+  "cache_read_input_tokens",
+  "output_tokens",
+  "input_characters",
+  "input_utf8_bytes",
+  "input_images",
+  "output_images",
+  "input_audio_seconds",
+  "output_audio_seconds",
+  "input_video_seconds",
+  "output_video_seconds",
+  "provider_credits",
+  "web_search_requests"
+];
+var BILLING_EXPORT_DIMENSIONS = [
+  "resolution",
+  "duration",
+  "layer_decomposition",
+  "with_audio",
+  "has_input_video",
+  "hd",
+  "prompt_extend",
+  "modality",
+  "tier",
+  "quality",
+  "image_count",
+  "input_token_tier",
+  "input_modality",
+  "service_tier",
+  "inference_geo",
+  "speed",
+  "region_scope",
+  "has_reference_image",
+  "mode"
+];
+function allocateDiscountedPriceLines(lines, saleAmount) {
+  const moneyPattern = /^(?:0|[1-9]\d*)(?:\.\d{1,8})?$/;
+  if (!moneyPattern.test(saleAmount) || lines.some((line) => !moneyPattern.test(line.amount))) {
+    throw new Error("Sale allocation requires non-negative eight-decimal money");
+  }
+  const target = priceScaled(saleAmount);
+  const weights = lines.map((line) => priceScaled(line.amount));
+  const total = weights.reduce((sum, amount) => sum + amount, 0n);
+  if (target > total) throw new Error("Discounted sale amount exceeds the frozen line total");
+  const allocations = weights.map((weight) => total === 0n ? 0n : target * weight / total);
+  let remainder = target - allocations.reduce((sum, amount) => sum + amount, 0n);
+  return lines.map((line, index) => {
+    let amount = allocations[index];
+    if (weights[index] > 0n && remainder > 0n) {
+      amount += 1n;
+      remainder -= 1n;
+    }
+    return { ...line, discountedAmount: scaledMoney(amount) };
+  });
+}
+function validateNormalizedUsage(value) {
+  if (!isObject3(value) || value.schemaVersion !== 1 || !Array.isArray(value.components)) {
+    throw new Error("Normalized usage must use the metered v1 envelope");
+  }
+  if (value.billingEvidenceComplete !== void 0 && typeof value.billingEvidenceComplete !== "boolean") {
+    throw new Error("billingEvidenceComplete must be boolean");
+  }
+  if (value.components.length === 0 || value.components.length > 64) {
+    throw new Error("Normalized usage must contain between 1 and 64 components");
+  }
+  const identities = /* @__PURE__ */ new Set();
+  for (const [index, raw] of value.components.entries()) {
+    if (!isObject3(raw) || !BILLING_METRICS.includes(raw.metric)) {
+      throw new Error(`Usage component ${index} has an unsupported billing metric`);
+    }
+    if (typeof raw.quantity !== "number" || !Number.isFinite(raw.quantity) || raw.quantity < 0) {
+      throw new Error(`Usage component ${index} quantity must be non-negative`);
+    }
+    if (raw.dimensions !== void 0 && (!isObject3(raw.dimensions) || Object.values(raw.dimensions).some((item) => !isPrimitive(item)))) {
+      throw new Error(`Usage component ${index} dimensions must contain only scalar values`);
+    }
+    const identity = `${String(raw.metric)}:${stableDimensions(raw.dimensions)}`;
+    if (identities.has(identity)) {
+      throw new Error(`Usage component ${index} duplicates a metric and dimension set`);
+    }
+    identities.add(identity);
+  }
+}
+function evaluatePriceRule(ruleValue, usageValue) {
+  validatePriceRule(ruleValue);
+  validateNormalizedUsage(usageValue);
+  const rule = ruleValue;
+  const usage = usageValue;
+  if (usage.billingEvidenceComplete === false) {
+    return { status: "incomplete", amount: "0", lines: [], issues: [{ code: "missing_usage", metric: "input_tokens", componentIndex: 0 }] };
+  }
+  const lines = [];
+  const issues = [];
+  let total = 0n;
+  for (const [componentIndex, component] of usage.components.entries()) {
+    const metricRates = rule.rates.filter((rate2) => rate2.metric === component.metric);
+    if (metricRates.length === 0) continue;
+    const matching = metricRates.filter((rate2) => dimensionsMatch(
+      rate2.dimensions,
+      component.dimensions
+    ));
+    if (matching.length === 0) {
+      if (component.quantity === 0) continue;
+      issues.push({ code: "dimension_mismatch", metric: component.metric, componentIndex });
+      continue;
+    }
+    const specificity = Math.max(...matching.map((rate2) => Object.keys(rate2.dimensions ?? {}).length));
+    const selected = matching.filter((rate2) => Object.keys(rate2.dimensions ?? {}).length === specificity);
+    if (selected.length !== 1) {
+      if (component.quantity === 0) continue;
+      issues.push({ code: "ambiguous_rate", metric: component.metric, componentIndex });
+      continue;
+    }
+    const rate = selected[0];
+    const amount = rateAmount(component.quantity, rate);
+    total += amount;
+    lines.push({
+      metric: component.metric,
+      quantity: component.quantity,
+      unitSize: rate.unitSize,
+      unitPrice: rate.unitPrice,
+      rounding: rate.rounding,
+      includedQuantity: rate.includedQuantity ?? 0,
+      ...rate.dimensions ? { dimensions: { ...rate.dimensions } } : {},
+      amount: scaledMoney(amount),
+      ...component.evidence ? { evidence: structuredClone(component.evidence) } : {}
+    });
+  }
+  return {
+    status: issues.length === 0 ? "rated" : "incomplete",
+    amount: scaledMoney(total),
+    lines,
+    issues
+  };
+}
+function validatePriceRule(value) {
+  if (!isObject3(value) || value.schemaVersion !== 1 || value.type !== "metered") {
+    throw new Error("Price rule must use the metered v1 envelope");
+  }
+  if (!Array.isArray(value.rates) || value.rates.length === 0 || value.rates.length > 32) {
+    throw new Error("Price rule must contain between 1 and 32 rates");
+  }
+  const identities = /* @__PURE__ */ new Set();
+  for (const [index, raw] of value.rates.entries()) {
+    if (!isObject3(raw) || !BILLING_METRICS.includes(raw.metric)) {
+      throw new Error(`Price rate ${index} has an unsupported billing metric`);
+    }
+    if (!Number.isSafeInteger(raw.unitSize) || raw.unitSize <= 0) {
+      throw new Error(`Price rate ${index} unitSize must be a positive integer`);
+    }
+    if (typeof raw.unitPrice !== "string" || !/^(?:0|[1-9]\d*)(?:\.\d{1,8})?$/.test(raw.unitPrice)) {
+      throw new Error(`Price rate ${index} unitPrice must be a non-negative decimal string`);
+    }
+    if (!["proportional", "ceil"].includes(String(raw.rounding))) {
+      throw new Error(`Price rate ${index} has an unsupported rounding mode`);
+    }
+    if (raw.includedQuantity !== void 0 && (typeof raw.includedQuantity !== "number" || !Number.isFinite(raw.includedQuantity) || raw.includedQuantity < 0)) {
+      throw new Error(`Price rate ${index} includedQuantity must be non-negative`);
+    }
+    if (raw.dimensions !== void 0 && (!isObject3(raw.dimensions) || Object.values(raw.dimensions).some((item) => !isPrimitive(item)))) {
+      throw new Error(`Price rate ${index} dimensions must contain only scalar values`);
+    }
+    const identity = `${String(raw.metric)}:${stableDimensions(raw.dimensions)}`;
+    if (identities.has(identity)) {
+      throw new Error(`Price rate ${index} duplicates a metric and dimension set`);
+    }
+    identities.add(identity);
+  }
+}
+function isObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPrimitive(value) {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+function stableDimensions(value) {
+  if (!isObject3(value)) return "";
+  return Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${JSON.stringify(item)}`).join(",");
+}
+var MONEY_SCALE2 = 100000000n;
+function dimensionsMatch(expected, actual) {
+  return Object.entries(expected ?? {}).every(([key, value]) => actual?.[key] === value);
+}
+function rateAmount(quantity, rate) {
+  const quantityFraction = subtractFractions(
+    numberFraction(quantity),
+    numberFraction(rate.includedQuantity ?? 0)
+  );
+  if (quantityFraction.numerator <= 0n) return 0n;
+  const price = priceScaled(rate.unitPrice);
+  const unitDenominator = quantityFraction.denominator * BigInt(rate.unitSize);
+  if (rate.rounding === "ceil") {
+    const units = divideCeil(quantityFraction.numerator, unitDenominator);
+    return units * price;
+  }
+  return divideHalfUp(quantityFraction.numerator * price, unitDenominator);
+}
+function priceScaled(value) {
+  const [whole = "0", fraction = ""] = value.split(".");
+  return BigInt(whole) * MONEY_SCALE2 + BigInt((fraction + "00000000").slice(0, 8));
+}
+function scaledMoney(value) {
+  const whole = value / MONEY_SCALE2;
+  const fraction = (value % MONEY_SCALE2).toString().padStart(8, "0").replace(/0+$/, "");
+  return fraction ? `${whole}.${fraction}` : whole.toString();
+}
+function numberFraction(value) {
+  const [mantissa, exponentText] = value.toString().toLowerCase().split("e");
+  const exponent = exponentText ? Number(exponentText) : 0;
+  const [whole = "0", fraction = ""] = mantissa.split(".");
+  const digits = `${whole}${fraction}`.replace(/^\+/, "");
+  const decimalPlaces = fraction.length - exponent;
+  if (decimalPlaces <= 0) {
+    return { numerator: BigInt(digits) * 10n ** BigInt(-decimalPlaces), denominator: 1n };
+  }
+  return { numerator: BigInt(digits), denominator: 10n ** BigInt(decimalPlaces) };
+}
+function subtractFractions(left, right) {
+  return {
+    numerator: left.numerator * right.denominator - right.numerator * left.denominator,
+    denominator: left.denominator * right.denominator
+  };
+}
+function divideCeil(numerator, denominator) {
+  return (numerator + denominator - 1n) / denominator;
+}
+function divideHalfUp(numerator, denominator) {
+  return (numerator * 2n + denominator) / (denominator * 2n);
+}
+
+// ../contracts/src/metering.ts
+function validateMeteringContract(value) {
+  if (!isObject4(value) || value.schemaVersion !== 1 || !isMeteringKind(value.kind)) {
+    throw new Error("Metering contract must use schemaVersion 1 and a supported kind");
+  }
+  if (!Array.isArray(value.metrics) || value.metrics.length === 0 || value.metrics.length > BILLING_METRICS.length) {
+    throw new Error("Metering contract must contain supported metrics");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value.metrics) {
+    if (!isObject4(entry) || !BILLING_METRICS.includes(entry.metric)) {
+      throw new Error("Metering contract has an unsupported metric");
+    }
+    if (typeof entry.requirement !== "string" || !["required", "conditional", "informational"].includes(entry.requirement)) {
+      throw new Error("Metering metric has an unsupported requirement");
+    }
+    if (seen.has(String(entry.metric))) throw new Error("Metering contract duplicates a metric");
+    seen.add(String(entry.metric));
+    if (entry.requirement === "conditional") {
+      if (typeof entry.whenFeature !== "string" || !entry.whenFeature.trim()) {
+        throw new Error("Conditional metric requires whenFeature");
+      }
+    } else if ("whenFeature" in entry) {
+      throw new Error("Only conditional metrics may declare whenFeature");
+    }
+  }
+}
+function assessUsageEvidence(contract, usage, features = {}) {
+  const result = {
+    kind: "unknown",
+    evidenceStatus: "invalid",
+    expectedMetrics: [],
+    observedMetrics: [],
+    missingMetrics: [],
+    issues: []
+  };
+  if (contract === void 0 || contract === null) {
+    result.issues.push("contract_unknown");
+    return result;
+  }
+  try {
+    validateMeteringContract(contract);
+  } catch (error) {
+    result.issues.push(`contract_invalid:${errorMessage(error)}`);
+    return result;
+  }
+  result.kind = contract.kind;
+  for (const entry of contract.metrics) {
+    if (entry.requirement === "required") result.expectedMetrics.push(entry.metric);
+    if (entry.requirement === "conditional") {
+      const feature = entry.whenFeature;
+      if (!Object.hasOwn(features, feature) || typeof features[feature] !== "boolean") {
+        result.issues.push(`condition_unknown:${feature}`);
+      } else if (features[feature]) {
+        result.expectedMetrics.push(entry.metric);
+      }
+    }
+  }
+  if (result.issues.length > 0) return result;
+  let explicitlyIncomplete = false;
+  if (usage !== void 0 && usage !== null) {
+    try {
+      if (!isObject4(usage) || usage.schemaVersion !== 1 || !Array.isArray(usage.components)) {
+        throw new Error("Normalized usage must use the metered v1 envelope");
+      }
+      if (usage.billingEvidenceComplete !== void 0 && typeof usage.billingEvidenceComplete !== "boolean") {
+        throw new Error("billingEvidenceComplete must be boolean");
+      }
+      if (usage.components.length > 0) validateNormalizedUsage(usage);
+      const observed = /* @__PURE__ */ new Set();
+      for (const component of usage.components) {
+        if (!component.metric.endsWith("_seconds") && component.metric !== "provider_credits" && !Number.isSafeInteger(component.quantity)) {
+          throw new Error(`Quantity for ${component.metric} must be a safe integer`);
+        }
+        if (Object.values(component.dimensions ?? {}).some((value) => typeof value === "number" && !Number.isFinite(value))) {
+          throw new Error("Usage dimensions must contain finite numeric values");
+        }
+        observed.add(component.metric);
+      }
+      result.observedMetrics = [...observed];
+      explicitlyIncomplete = usage.billingEvidenceComplete === false;
+    } catch (error) {
+      result.issues.push(`usage_invalid:${errorMessage(error)}`);
+      return result;
+    }
+  }
+  result.missingMetrics = result.expectedMetrics.filter((metric) => !result.observedMetrics.includes(metric));
+  if (explicitlyIncomplete) result.issues.push("billing_evidence_incomplete");
+  result.evidenceStatus = result.expectedMetrics.length === 0 ? "not_expected" : result.missingMetrics.length === result.expectedMetrics.length ? "missing" : result.missingMetrics.length > 0 || explicitlyIncomplete ? "partial" : "complete";
+  return result;
+}
+function isObject4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isMeteringKind(value) {
+  return value === "token" || value === "non_token" || value === "mixed";
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ../contracts/src/tasks.ts
+var TASK_STATUSES = [
+  "queued",
+  "running",
+  "succeeded",
+  "failed",
+  "cancelling",
+  "cancelled"
+];
+function taskReceipt(task) {
+  return { id: task.id, status: task.status };
+}
+function taskResult(task) {
+  return {
+    id: task.id,
+    model: task.model,
+    status: task.status,
+    ...task.assets.length ? { assets: task.assets } : {},
+    ...task.requestId ? { requestId: task.requestId } : {},
+    ...task.output !== void 0 ? { output: task.output } : {},
+    ...task.error ? { error: task.error } : {},
+    ...task.deliveryStatus ? { deliveryStatus: task.deliveryStatus } : {},
+    ...task.settlement ? { settlement: task.settlement } : {}
+  };
+}
+function isTerminalTaskStatus(status) {
+  return status === "succeeded" || status === "failed" || status === "cancelled";
+}
+
+// ../contracts/src/monitoring.ts
+function defaultProbeInterval(kind, model) {
+  if (/music/i.test(model)) return 172800;
+  if (kind === "audio" && /sound/i.test(model)) return 86400;
+  return ["language", "embedding", "audio"].includes(kind) ? 3600 : 86400;
+}
+function defaultProbeTimeout(kind) {
+  return ["video", "world"].includes(kind) ? 1800 : ["image", "audio"].includes(kind) ? 300 : 120;
+}
+function classifyObservation(status, httpStatus, code = "") {
+  if (/cancel|client_disconnect|invalid_input|validation_error/i.test(code) || status === "cancelled")
+    return "excluded";
+  if (httpStatus === 429) return "rate_limited";
+  if (httpStatus === 403 && /geo|region|location|country/i.test(code))
+    return "restricted";
+  if (/auth|api.?key|balance|credit|quota_exhaust|model.*(not.?found|not.?exist)|invalid_model/i.test(
+    code
+  ))
+    return "failure";
+  if ([400, 413, 422].includes(httpStatus ?? 0)) return "excluded";
+  if (status === "failed" || status === "rejected" || httpStatus !== null && httpStatus >= 400 || /error|incomplete|truncat/i.test(code))
+    return "failure";
+  return status === "succeeded" ? "success" : "excluded";
+}
+var sampleCount = (items) => items.reduce((n, x) => n + (x.count ?? 1), 0);
+function availabilityStats(items) {
+  const success = sampleCount(items.filter((x) => x.result === "success")), failure = sampleCount(items.filter((x) => x.result === "failure"));
+  return {
+    success,
+    failure,
+    excluded: sampleCount(items.filter((x) => x.result === "excluded")),
+    rateLimited: sampleCount(items.filter((x) => x.result === "rate_limited")),
+    restricted: sampleCount(items.filter((x) => x.result === "restricted")),
+    rate: success + failure ? success / (success + failure) : null
+  };
+}
+function availabilityBuckets(items, end, hours, intervalSeconds, core = false) {
+  const endMs = end.getTime(), first = Math.floor(endMs / 36e5) * 36e5 - (hours - 1) * 36e5;
+  const sorted = items.filter(
+    (x) => Number.isFinite(Date.parse(x.at)) && Date.parse(x.at) <= endMs
+  ).slice().sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+  const grace = Math.min(3600, Math.max(300, intervalSeconds * 0.1)) * 1e3;
+  let cursor = 0;
+  let prior;
+  return Array.from({ length: hours }, (_, i) => {
+    const start = first + i * 36e5, stop = Math.min(start + 36e5, endMs);
+    const valid = [];
+    while (cursor < sorted.length && (Date.parse(sorted[cursor].at) < stop || i === hours - 1 && Date.parse(sorted[cursor].at) === endMs)) {
+      const item = sorted[cursor++];
+      if (item.result !== "success" && item.result !== "failure") continue;
+      prior = item;
+      if (Date.parse(item.at) >= start) valid.push(item);
+    }
+    const s = sampleCount(valid.filter((x) => x.result === "success")), f = sampleCount(valid) - s;
+    const fresh = prior && stop - Date.parse(prior.at) <= intervalSeconds * 1e3 + grace;
+    const state = valid.length ? s && f ? "mixed" : s ? "success" : "failure" : !core && fresh ? prior.result : "unknown";
+    const expected = core ? Math.ceil((stop - start) / 3e4) : null;
+    return {
+      start: new Date(start).toISOString(),
+      end: new Date(stop).toISOString(),
+      state,
+      evidence: valid.length ? "measured" : !core && fresh ? "carried" : prior ? "expired" : "none",
+      businessSuccess: sampleCount(
+        valid.filter((x) => x.source === "business" && x.result === "success")
+      ),
+      businessFailure: sampleCount(
+        valid.filter((x) => x.source === "business" && x.result === "failure")
+      ),
+      probeSuccess: sampleCount(
+        valid.filter((x) => x.source === "probe" && x.result === "success")
+      ),
+      probeFailure: sampleCount(
+        valid.filter((x) => x.source === "probe" && x.result === "failure")
+      ),
+      coreSuccess: sampleCount(
+        valid.filter((x) => x.source === "core" && x.result === "success")
+      ),
+      coreFailure: sampleCount(
+        valid.filter((x) => x.source === "core" && x.result === "failure")
+      ),
+      latestAt: prior?.at ?? null,
+      expectedSamples: expected,
+      incomplete: expected !== null && sampleCount(valid) < expected
+    };
+  });
+}
+function rateProbeUsage(price, usage) {
+  if (!usage || !Array.isArray(usage.components) || !usage.components.length)
+    return void 0;
+  try {
+    validatePriceRule(price);
+    const metrics = new Set(
+      usage.components.flatMap(
+        (c) => c && typeof c === "object" && !Array.isArray(c) && typeof c.metric === "string" ? [c.metric] : []
+      )
+    );
+    if (price.rates.some(
+      (r) => !/^cache|cached_|web_search/.test(r.metric) && !metrics.has(r.metric)
+    ))
+      return void 0;
+    const e = evaluatePriceRule(price, usage);
+    return e.status === "rated" && e.lines.length > 0 ? e.amount : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function probeCostExceeds(actual, limit) {
+  const units = (value) => {
+    if (!/^\d+(\.\d{1,8})?$/.test(value)) throw new Error("invalid_probe_cost");
+    const [whole, fraction = ""] = value.split(".");
+    return BigInt(whole) * 100000000n + BigInt(fraction.padEnd(8, "0"));
+  };
+  return units(actual) > units(limit);
+}
+
+// src/assets.ts
+var AssetsClient = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async upload(file, options = {}) {
+    const name = options.name ?? (isFile(file) ? file.name : void 0);
+    const headers = new Headers({
+      "content-type": file.type || "application/octet-stream",
+      "x-nexra-asset-kind": options.kind ?? inferKind(file.type)
+    });
+    if (name) headers.set("x-nexra-file-name", encodeURIComponent(name));
+    return this.transport.json(
+      "/assets",
+      {
+        method: "POST",
+        body: file,
+        headers,
+        signal: options.signal
+      },
+      { retryable: false }
+    );
+  }
+  import(request, signal) {
+    return this.transport.json("/assets/import", {
+      method: "POST",
+      ...jsonBody(request),
+      signal
+    });
+  }
+  get(assetId, signal) {
+    return this.transport.json(`/assets/${encodeURIComponent(assetId)}`, {
+      signal
+    });
+  }
+  download(asset, signal) {
+    const assetId = typeof asset === "string" ? asset : asset.id;
+    return this.transport.response(`/assets/${encodeURIComponent(assetId)}/content`, {
+      signal
+    });
+  }
+  async stream(asset, signal) {
+    const response = await this.download(asset, signal);
+    if (!response.body) throw new Error("Asset response did not contain a body stream");
+    return response.body;
+  }
+};
+function inferKind(mimeType) {
+  if (mimeType.startsWith("image/")) return "image";
+  if (mimeType.startsWith("video/")) return "video";
+  if (mimeType.startsWith("audio/")) return "audio";
+  if (mimeType.startsWith("text/") || mimeType === "application/pdf") return "document";
+  if (mimeType.includes("zip") || mimeType.includes("tar")) return "archive";
+  return "other";
+}
+function isFile(value) {
+  return typeof File !== "undefined" && value instanceof File;
+}
+
+// src/models.ts
+var ModelsClient = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  search(params = {}, signal) {
+    return this.transport.json(
+      `/models${queryString({
+        q: params.query,
+        modality: params.modality,
+        operation: params.operation,
+        category: params.category,
+        limit: params.limit,
+        cursor: params.cursor
+      })}`,
+      { signal }
+    );
+  }
+  get(model, signal) {
+    return this.transport.json(`/models/${encodeURIComponent(model)}`, {
+      signal
+    });
+  }
+  schema(model, signal) {
+    return this.transport.json(
+      `/models/${encodeURIComponent(model)}/schema`,
+      { signal }
+    );
+  }
+};
+
+// src/input.ts
+async function normalizeTaskInput(input, assets, signal) {
+  const normalized = await normalizeValue(input, assets, signal, /* @__PURE__ */ new WeakSet());
+  if (!isPlainObject(normalized)) {
+    throw new TypeError("Task input must be a JSON object");
+  }
+  return normalized;
+}
+async function normalizeValue(value, assets, signal, ancestors) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("Task input numbers must be finite");
+    return value;
+  }
+  if (value instanceof URL) return value.toString();
+  if (typeof Blob !== "undefined" && value instanceof Blob) {
+    const uploaded = await assets.upload(value, { signal });
+    return { assetId: uploaded.id };
+  }
+  if (isMediaAsset(value)) {
+    return { assetId: value.id };
+  }
+  if (isAssetReference(value)) return { assetId: value.assetId };
+  if (Array.isArray(value)) {
+    assertNotCircular(value, ancestors);
+    const normalized = await Promise.all(
+      value.map((item) => normalizeValue(item, assets, signal, ancestors))
+    );
+    ancestors.delete(value);
+    return normalized;
+  }
+  if (isPlainObject(value)) {
+    assertNotCircular(value, ancestors);
+    const normalized = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (item === void 0) continue;
+      normalized[key] = await normalizeValue(item, assets, signal, ancestors);
+    }
+    ancestors.delete(value);
+    return normalized;
+  }
+  throw new TypeError(`Task input contains a non-serializable ${typeof value} value`);
+}
+function assertNotCircular(value, ancestors) {
+  if (ancestors.has(value)) throw new TypeError("Task input cannot contain circular references");
+  ancestors.add(value);
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isAssetReference(value) {
+  return isPlainObject(value) && typeof value.assetId === "string";
+}
+function isMediaAsset(value) {
+  return isPlainObject(value) && typeof value.id === "string" && typeof value.kind === "string" && typeof value.status === "string" && typeof value.source === "string";
+}
+
+// src/sse.ts
+async function* parseServerSentEvents(response) {
+  if (!response.body) throw new Error("SSE response did not contain a body");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let current = emptyEvent();
+  while (true) {
+    const { value, done } = await reader.read();
+    buffer += decoder.decode(value, { stream: !done });
+    const lines = buffer.split(/\r?\n/);
+    buffer = done ? "" : lines.pop() ?? "";
+    for (const line of lines) {
+      if (line === "") {
+        const event = buildEvent(current);
+        current = emptyEvent();
+        if (event) yield event;
+        continue;
+      }
+      if (line.startsWith(":")) continue;
+      const separator = line.indexOf(":");
+      const field = separator === -1 ? line : line.slice(0, separator);
+      let content = separator === -1 ? "" : line.slice(separator + 1);
+      if (content.startsWith(" ")) content = content.slice(1);
+      if (field === "data") current.data.push(content);
+      else if (field === "event") current.event = content;
+      else if (field === "id") current.id = content;
+      else if (field === "retry") current.retry = Number(content);
+    }
+    if (done) {
+      const event = buildEvent(current);
+      if (event) yield event;
+      return;
+    }
+  }
+}
+function emptyEvent() {
+  return { data: [] };
+}
+function buildEvent(pending) {
+  if (pending.data.length === 0) return void 0;
+  return {
+    id: pending.id,
+    event: pending.event,
+    retry: Number.isFinite(pending.retry) ? pending.retry : void 0,
+    data: pending.data.join("\n")
+  };
+}
+
+// src/tasks.ts
+var TasksClient = class {
+  constructor(transport, assets) {
+    this.transport = transport;
+    this.assets = assets;
+  }
+  transport;
+  assets;
+  async create(model, options) {
+    const input = await normalizeTaskInput(options.input, this.assets, options.signal);
+    const body = {
+      model,
+      input,
+      quoteToken: options.quoteToken,
+      submittedAt: options.submittedAt,
+      metadata: options.metadata,
+      callback_url: options.callback_url,
+      webhook: options.webhook,
+      schemaVersion: options.schemaVersion
+    };
+    const idempotencyKey = options.idempotencyKey ?? crypto.randomUUID();
+    return this.transport.json(
+      "/tasks",
+      {
+        method: "POST",
+        ...jsonBody(body),
+        headers: {
+          ...jsonBody(body).headers,
+          "idempotency-key": idempotencyKey
+        },
+        signal: options.signal
+      },
+      { retryable: true }
+    );
+  }
+  get(taskId, signal) {
+    return this.transport.json(`/tasks/${encodeURIComponent(taskId)}`, {
+      signal
+    });
+  }
+  list(params = {}, signal) {
+    return this.transport.json(
+      `/tasks${queryString({
+        status: params.status,
+        model: params.model,
+        limit: params.limit,
+        cursor: params.cursor
+      })}`,
+      { signal }
+    );
+  }
+  cancel(taskId, signal) {
+    return this.transport.json(
+      `/tasks/${encodeURIComponent(taskId)}/cancel`,
+      { method: "POST", signal },
+      { retryable: true }
+    );
+  }
+  async *watch(taskId, options = {}) {
+    let lastEventId = options.lastEventId;
+    let reconnects = 0;
+    let reconnectDelay = 500;
+    const maxReconnects = options.maxReconnects ?? 5;
+    while (true) {
+      const headers = new Headers({ accept: "text/event-stream" });
+      if (lastEventId) headers.set("last-event-id", lastEventId);
+      const response = await this.transport.response(
+        `/tasks/${encodeURIComponent(taskId)}/events`,
+        { headers, signal: options.signal },
+        { retryable: false }
+      );
+      let reachedTerminalState = false;
+      for await (const serverEvent of parseServerSentEvents(response)) {
+        if (serverEvent.id) lastEventId = serverEvent.id;
+        if (serverEvent.retry !== void 0) reconnectDelay = serverEvent.retry;
+        const event = JSON.parse(serverEvent.data);
+        yield event;
+        if (event.status && isTerminalTaskStatus(event.status)) {
+          reachedTerminalState = true;
+        }
+      }
+      if (reachedTerminalState) return;
+      if (reconnects >= maxReconnects) return;
+      reconnects += 1;
+      await sleep(reconnectDelay, options.signal);
+    }
+  }
+  async wait(taskId, options = {}) {
+    const timeoutController = new AbortController();
+    const timeoutMs = options.timeoutMs;
+    const timeout = timeoutMs ? setTimeout(() => timeoutController.abort("nexra_wait_timeout"), timeoutMs) : void 0;
+    const signal = combineSignals(options.signal, timeoutMs ? timeoutController.signal : void 0);
+    try {
+      const current = await this.get(taskId, signal);
+      if (isTerminalTaskStatus(current.status) && current.deliveryStatus !== "preparing") return current;
+      try {
+        for await (const event of this.watch(taskId, {
+          signal,
+          lastEventId: options.lastEventId,
+          maxReconnects: options.maxReconnects
+        })) {
+          await options.onEvent?.(event);
+        }
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        if (error instanceof NexraApiError && ![405, 406, 501].includes(error.status)) {
+          throw error;
+        }
+      }
+      while (true) {
+        const task = await this.get(taskId, signal);
+        if (isTerminalTaskStatus(task.status) && task.deliveryStatus !== "preparing") return task;
+        await sleep(options.pollIntervalMs ?? 1e3, signal);
+      }
+    } catch (error) {
+      if (timeoutController.signal.aborted && timeoutMs) {
+        throw new NexraWaitTimeoutError(taskId, timeoutMs);
+      }
+      throw error;
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+  }
+  async run(model, options) {
+    const task = await this.create(model, options);
+    let completed;
+    try {
+      completed = await this.wait(task.id, options);
+    } catch (error) {
+      if (options.cancelOnAbort && options.signal?.aborted) {
+        await this.cancel(task.id).catch(() => void 0);
+      }
+      throw error;
+    }
+    if (completed.status !== "succeeded") {
+      throw new NexraTaskError(completed);
+    }
+    return {
+      taskId: completed.id,
+      output: completed.output,
+      assets: completed.assets ?? [],
+      task: completed
+    };
+  }
+};
+function combineSignals(first, second) {
+  const signals = [first, second].filter((signal) => Boolean(signal));
+  if (signals.length === 0) return void 0;
+  if (signals.length === 1) return signals[0];
+  return AbortSignal.any(signals);
+}
+
+// src/client.ts
+var NexraClient = class {
+  assets;
+  catalog;
+  models;
+  tasks;
+  constructor(options = {}) {
+    const transport = new HttpTransport(options);
+    this.assets = new AssetsClient(transport);
+    this.catalog = new CatalogClient(transport);
+    this.models = new ModelsClient(transport);
+    this.tasks = new TasksClient(transport, this.assets);
+  }
+  run(model, options) {
+    return this.tasks.run(model, options);
+  }
+};
+function createNexra(options = {}) {
+  return new NexraClient(options);
+}
+
+// src/webhooks.ts
+async function verifyWebhook(request, secret, options = {}) {
+  const webhookId = request.headers.get("nexra-webhook-id");
+  const timestamp = request.headers.get("nexra-webhook-timestamp");
+  const signatureHeader = request.headers.get("nexra-webhook-signature");
+  if (!webhookId || !timestamp || !signatureHeader) return false;
+  const timestampSeconds = Number(timestamp);
+  if (!Number.isFinite(timestampSeconds)) return false;
+  const nowSeconds = Math.floor((options.now ?? /* @__PURE__ */ new Date()).getTime() / 1e3);
+  if (Math.abs(nowSeconds - timestampSeconds) > (options.toleranceSeconds ?? 300)) {
+    return false;
+  }
+  const body = await request.clone().text();
+  const signedPayload = `${webhookId}.${timestamp}.${body}`;
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const digest = new Uint8Array(
+    await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(signedPayload))
+  );
+  const expected = toBase64Url(digest);
+  const signatures = signatureHeader.split(" ").flatMap((part) => part.split(",")).map((part) => part.trim()).filter((part) => part.startsWith("v1=")).map((part) => part.slice(3));
+  return signatures.some((signature) => timingSafeEqual(signature, expected));
+}
+function toBase64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function timingSafeEqual(left, right) {
+  if (left.length !== right.length) return false;
+  let difference = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    difference |= left.charCodeAt(index) ^ right.charCodeAt(index);
+  }
+  return difference === 0;
+}
+export {
+  ADMIN_USER_ACTIVITY_KINDS,
+  ADMIN_USER_ROLES,
+  ADMIN_USER_STATUSES,
+  AssetsClient,
+  BILLING_CURRENCY,
+  BILLING_EXPORT_DIMENSIONS,
+  BILLING_METRICS,
+  CatalogClient,
+  HttpTransport,
+  MEDIA_KINDS,
+  MONEY_STRING_PATTERN,
+  ModelsClient,
+  NexraApiError,
+  NexraClient,
+  NexraTaskError,
+  NexraWaitTimeoutError,
+  TASK_STATUSES,
+  TOKEN_METRICS,
+  TasksClient,
+  USAGE_AMOUNT_KINDS,
+  USAGE_ANOMALY_CATEGORIES,
+  USAGE_FILTER_KINDS,
+  USAGE_FILTER_SELECTION_LIMIT,
+  USAGE_GROUP_BYS,
+  USAGE_NORMALIZATION_STATUSES,
+  USAGE_RATING_STATUSES,
+  USAGE_SOURCES,
+  WALLET_MAX_BALANCE_UNITS,
+  allocateDiscountedPriceLines,
+  assessUsageEvidence,
+  availabilityBuckets,
+  availabilityStats,
+  ceilDecimal,
+  classifyObservation,
+  createNexra,
+  defaultProbeInterval,
+  defaultProbeTimeout,
+  encodeAdminUserCursor,
+  encodeUsageFilterCursor,
+  encodeUsageKeysetCursor,
+  encodeUsageSummaryCursor,
+  evaluatePriceRule,
+  getModelSpec,
+  isMoneyString,
+  isTerminalTaskStatus,
+  jsonBody,
+  listModelSpecs,
+  modelInputDefaults,
+  modelInputUi,
+  modelUploadRegion,
+  moneyFromUnits,
+  moneyToUnits,
+  multiplyDecimal,
+  multiplyMoney,
+  normalizeModelParameterSchema,
+  orderedSchemaProperties,
+  parseAdminUserCursor,
+  parseUsageFilterCursor,
+  parseUsageKeysetCursor,
+  parseUsageSummaryCursor,
+  probeCostExceeds,
+  queryString,
+  rateProbeUsage,
+  sleep,
+  taskReceipt,
+  taskResult,
+  uploadedMediaInput,
+  uploadedMediaUrl,
+  validateAdminUserApiKeyUpdate,
+  validateAdminUserListQuery,
+  validateAdminUserUpdate,
+  validateAdminWalletRechargeInput,
+  validateMeteringContract,
+  validateNormalizedUsage,
+  validatePriceRule,
+  validateUsageAnomaliesQuery,
+  validateUsageAnomalySummaryQuery,
+  validateUsageDetailsQuery,
+  validateUsageFilterOptionsQuery,
+  validateUsageFilters,
+  validateUsageSummaryQuery,
+  verifyWebhook
+};