@byte_fluffy/nexra-sdk 0.1.0-alpha.6 → 0.1.0-alpha.7

package/dist/{chunk-BQQU5NJ7.js → chunk-3ZBQVBMA.js}

@@ -2123,6 +2123,8 @@ var image_generated_default = [
           properties: {
             prompt_extend: {
               type: "boolean",
+              title: "\u63D0\u793A\u8BCD\u6269\u5199",
+              description: "\u8BA9\u4E0A\u6E38\u4F18\u5316\u7F16\u8F91\u63D0\u793A\u8BCD\u3002",
               "x-ui": {
                 order: 2,
                 control: "switch"
@@ -3124,8 +3126,7 @@ var image_generated_default = [
                 "8:1",
                 "9:16",
                 "16:9",
-                "21:9",
-                "9:21"
+                "21:9"
               ],
               "x-ui": {
                 order: 2,
@@ -3144,8 +3145,7 @@ var image_generated_default = [
                   "8:1": "8:1",
                   "9:16": "9:16",
                   "16:9": "16:9",
-                  "21:9": "21:9",
-                  "9:21": "9:21"
+                  "21:9": "21:9"
                 }
               },
               default: "1:1",
@@ -3366,8 +3366,7 @@ var image_generated_default = [
                 "8:1",
                 "9:16",
                 "16:9",
-                "21:9",
-                "9:21"
+                "21:9"
               ],
               "x-ui": {
                 order: 2,
@@ -3386,8 +3385,7 @@ var image_generated_default = [
                   "8:1": "8:1",
                   "9:16": "9:16",
                   "16:9": "16:9",
-                  "21:9": "21:9",
-                  "9:21": "9:21"
+                  "21:9": "21:9"
                 }
               },
               default: "1:1",
@@ -6273,6 +6271,1206 @@ var generatedCatalog = Object.freeze([
   ...image_generated_default
 ]);
 
+// ../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);
+}
+
+// ../contracts/src/sandbox.ts
+var SANDBOX_OPERATIONS = [
+  { id: "text-to-speech", modality: "audio", label: "\u8BED\u97F3\u5408\u6210" },
+  { id: "text-to-music", modality: "audio", label: "\u97F3\u4E50\u751F\u6210" },
+  { id: "multimodal-to-video", modality: "video", label: "\u5168\u80FD\u53C2\u8003\u751F" },
+  { id: "text-to-video", modality: "video", label: "\u53C2\u8003\u751F\u6210\u89C6\u9891" },
+  { id: "image-to-video", modality: "video", label: "\u9996\u5C3E\u5E27\u751F\u6210\u89C6\u9891" },
+  { id: "text-to-image", modality: "image", label: "\u6587\u751F\u56FE" },
+  { id: "image-to-image", modality: "image", label: "\u56FE\u751F\u56FE" },
+  { id: "text-to-text", modality: "language", label: "\u5BF9\u8BDD\u751F\u6210" }
+];
+var sandboxObject = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+var obj = sandboxObject;
+var array = (v) => Array.isArray(v) ? v : [];
+function sandboxIdentity(slug) {
+  return slug === "google/veo-3-1-fast" ? "google/veo-3-1-fast-generate-001" : slug;
+}
+function sandboxModelModes(model) {
+  if (model.modality === "language") return ["text-to-text"];
+  if (model.modality === "audio") return model.capabilities.inputModes.includes("text-to-speech") ? ["text-to-speech"] : ["elevenlabs/music_v2", "minimax/music-2.6"].includes(model.slug) ? ["text-to-music"] : [];
+  if (model.slug === "heygen/heygen-avatar-video" || model.slug === "yadan/minimax-h3-local") return [];
+  const modes = model.capabilities.inputModes.filter((mode) => ["text-to-image", "image-to-image", "text-to-video", "image-to-video"].includes(mode)).filter((mode) => !(model.slug === "pixverse/baidu-vod-pc1" && mode === "image-to-video"));
+  if (model.capabilities.inputModes.includes("audio-to-video") && model.capabilities.inputModes.includes("video-to-video")) modes.push("multimodal-to-video");
+  return modes;
+}
+function sandboxOperations(models) {
+  return SANDBOX_OPERATIONS.filter((op) => new Set(models.filter((m) => m.modality === op.modality && sandboxModelModes(m).includes(op.id)).map((m) => sandboxIdentity(m.slug))).size >= 2);
+}
+function sandboxProperties(schema) {
+  const root = obj(schema.inputSchema.properties);
+  return { root, parameters: obj(obj(root.parameters).properties) };
+}
+function values(field) {
+  return Array.isArray(field.enum) ? field.enum : [];
+}
+function normalized(value) {
+  return String(value).toLowerCase();
+}
+function choose(field, requested, numeric = false) {
+  const options = values(field);
+  if (options.length) {
+    const exact = options.find((v) => normalized(v) === normalized(requested));
+    if (exact !== void 0) return exact;
+    if (numeric) {
+      const n = parseFloat(String(requested));
+      const ranked = options.filter((v) => Number.isFinite(parseFloat(String(v)))).sort((a, b) => Math.abs(parseFloat(String(a)) - n) - Math.abs(parseFloat(String(b)) - n));
+      if (ranked.length && Number.isFinite(n)) return ranked[0];
+    }
+    throw new Error(`\u4E0D\u652F\u6301 ${String(requested)}`);
+  }
+  const branches = array(field.anyOf).map(obj);
+  const range = branches.find((b) => b.type === "integer" || typeof b.minimum === "number") ?? field;
+  if (numeric) {
+    const n = Number(requested);
+    if (!Number.isFinite(n)) throw new Error("\u9700\u8981\u6709\u6548\u6570\u503C");
+    const bounded = Math.min(Number(range.maximum ?? n), Math.max(Number(range.minimum ?? n), n));
+    return range.type === "integer" || field.type === "integer" ? Math.round(bounded) : bounded;
+  }
+  return requested;
+}
+function applyFieldDefault(settings, fields, key, enabled = true) {
+  if (!enabled || settings[key] !== void 0 || !fields[key]) return;
+  const field = obj(fields[key]);
+  if (field.default === void 0) return;
+  const numeric = field.type === "integer" || typeof field.minimum === "number";
+  settings[key] = choose(field, field.default, numeric);
+}
+function urls(value) {
+  return array(value).map((v) => typeof v === "string" ? v : String(obj(v).url ?? "")).filter(Boolean);
+}
+function mediaRoles(schema) {
+  const { root } = sandboxProperties(schema);
+  if (root.content) return array(obj(obj(root.content).items).oneOf).flatMap((v) => array(obj(obj(obj(v).properties).role).enum)).filter((v) => typeof v === "string");
+  return array(obj(obj(root.images)["x-ui"]).roles).filter((v) => typeof v === "string");
+}
+function sandboxSupports(schema, feature) {
+  const { root } = sandboxProperties(schema);
+  if (feature === "last_frame") return schema.model !== "yadan/minimax-h3-local" && mediaRoles(schema).includes("last_frame");
+  if (feature === "reference_images") return mediaRoles(schema).includes("reference_image") || schema.model === "pixverse/baidu-vod-pc1";
+  if (feature === "videos") return mediaRoles(schema).includes("reference_video") || array(obj(obj(root.videos)["x-ui"]).roles).includes("reference_video");
+  if (feature === "audios") return mediaRoles(schema).includes("reference_audio") || !!root.audios && array(obj(obj(root.audios)["x-ui"]).accept).includes("url");
+  return false;
+}
+function sandboxVoiceKey(model) {
+  return `voice:${model}`;
+}
+function adaptSandboxInput(schema, mode, input) {
+  const { root, parameters } = sandboxProperties(schema);
+  const nested = !!root.input && !!root.parameters;
+  const fields = nested ? parameters : root;
+  const body = {};
+  const settings = nested ? {} : body;
+  for (const key of array(schema.inputSchema.required)) if (typeof key === "string" && obj(root[key]).default !== void 0) body[key] = obj(root[key]).default;
+  if (root.model) body.model = String(schema.defaults?.model ?? schema.model.split("/").at(-1));
+  const prompt = typeof input.prompt === "string" ? input.prompt.trim() : "";
+  if (!prompt) throw new Error("\u8BF7\u586B\u5199\u63D0\u793A\u8BCD\u6216\u6717\u8BFB\u6587\u672C");
+  if (nested) body.input = { messages: [{ role: "user", content: [{ text: prompt }, ...urls(input.images).map((image) => ({ image }))] }] };
+  else if (root.content) body.content = [{ type: "text", text: prompt }];
+  else body[root.prompt ? "prompt" : root.texts ? "texts" : "text"] = prompt;
+  if (schema.model === "yadan/minimax-h3-local" && !["first_frame", "reference_images", "videos", "audios"].some((key) => urls(input[key]).length)) throw new Error("H3 Local \u5F53\u524D\u63A5\u5165\u9700\u8981\u81F3\u5C11\u4E00\u4EFD\u53C2\u8003\u7D20\u6750");
+  const imageInput = urls(input.images);
+  const first = urls(input.first_frame);
+  if (mode === "image-to-image" && !imageInput.length) throw new Error("\u56FE\u751F\u56FE\u9700\u8981\u8F93\u5165\u56FE\u7247");
+  if (mode === "image-to-video" && first.length !== 1) throw new Error("\u9996\u5C3E\u5E27\u751F\u6210\u89C6\u9891\u9700\u8981\u4E00\u5F20\u9996\u5E27");
+  if (mode === "text-to-image" && imageInput.length) throw new Error("\u8BF7\u5207\u6362\u5230\u56FE\u751F\u56FE");
+  if (mode === "text-to-video" && first.length) throw new Error("\u8BF7\u5207\u6362\u5230\u9996\u5C3E\u5E27\u751F\u6210\u89C6\u9891");
+  if (!nested && mode === "image-to-image") {
+    if (root.imageUrl) {
+      if (imageInput.length > 1) throw new Error("\u6B64\u6A21\u578B\u53EA\u652F\u6301\u4E00\u5F20\u8F93\u5165\u56FE");
+      body.imageUrl = imageInput[0];
+    } else if (obj(root.image).type === "object") body.images = imageInput.map((url) => ({ url }));
+    else if (root.image) body.image = imageInput;
+    else if (root.images) body.images = imageInput;
+    else throw new Error("\u6A21\u578B\u6CA1\u6709\u53EF\u6620\u5C04\u7684\u56FE\u7247\u8F93\u5165");
+  }
+  const media = [];
+  for (const [key, role, type] of [["first_frame", "first_frame", "image_url"], ["last_frame", "last_frame", "image_url"], ["reference_images", "reference_image", "image_url"], ["videos", "reference_video", "video_url"], ["audios", "reference_audio", "audio_url"]]) {
+    const entries = urls(input[key]);
+    if (key !== "first_frame" && entries.length && !sandboxSupports(schema, key)) throw new Error(`\u6A21\u578B\u4E0D\u652F\u6301 ${key}`);
+    for (const url of entries) media.push({ key, role, type, url });
+  }
+  if (urls(input.last_frame).length && !first.length) throw new Error("\u5C3E\u5E27\u9700\u8981\u540C\u65F6\u63D0\u4F9B\u9996\u5E27");
+  if (first.length && (urls(input.reference_images).length || urls(input.videos).length || urls(input.audios).length)) throw new Error("\u9996\u5C3E\u5E27\u4E0E\u53C2\u8003\u7D20\u6750\u8BF7\u5206\u5F00\u8FD0\u884C");
+  if (root.content) body.content = [...array(body.content), ...media.map((m) => ({ type: m.type, [m.type]: { url: m.url }, role: m.role }))];
+  else for (const [key, type] of [["images", "image_url"], ["videos", "video_url"], ["audios", "audio_url"]]) {
+    const entries = media.filter((m) => m.type === type);
+    if (entries.length) body[key] = entries.map((m, i) => schema.model === "yadan/minimax-h3-local" ? { url: m.url } : schema.model === "pixverse/baidu-vod-pc1" ? { url: m.url, role: "subject", referenceName: `ref${i + 1}` } : { url: m.url, role: m.role });
+  }
+  if (schema.model === "pixverse/baidu-vod-pc1" && urls(input.reference_images).length) {
+    const names = urls(input.reference_images).map((_, i) => `@ref${i + 1}`);
+    if (!names.every((name) => prompt.includes(name))) throw new Error(`\u8BF7\u5728\u63D0\u793A\u8BCD\u4E2D\u5F15\u7528 ${names.join("\u3001")}`);
+  }
+  if (schema.model.startsWith("xai/grok-imagine-video")) body.mode = first.length ? "image-to-video" : urls(input.reference_images).length ? "reference-to-video" : "text-to-video";
+  const ratio = typeof input.aspect_ratio === "string" && input.aspect_ratio !== "default" ? input.aspect_ratio : void 0;
+  const resolution = typeof input.resolution === "string" && input.resolution !== "default" ? input.resolution : void 0;
+  const ratioKey = ["ratio", "aspect_ratio", "aspectRatio"].find((k) => fields[k]);
+  if (ratio && ratioKey && !(["kuaishou/baidu-vod-kling-v3", "pixverse/baidu-vod-p60", "bytedance/doubao-seedance-2-5-260628"].includes(schema.model) && first.length)) settings[ratioKey] = choose(obj(fields[ratioKey]), ratio);
+  if (first.length && schema.model === "bytedance/doubao-seedance-2-5-260628") settings.ratio = "adaptive";
+  if (resolution && fields.resolution) settings.resolution = choose(obj(fields.resolution), resolution);
+  else applyFieldDefault(settings, fields, "resolution");
+  applyFieldDefault(settings, fields, "duration", input.duration === void 0);
+  applyFieldDefault(settings, fields, "mode", settings.mode === void 0 && body.mode === void 0);
+  if (input.generate_audio === void 0) applyFieldDefault(settings, fields, fields.with_audio ? "with_audio" : "generate_audio");
+  if (fields.size && (ratio || resolution)) {
+    const [rw, rh] = (ratio ?? "1:1").split(":").map(Number);
+    if (!rw || !rh) throw new Error("\u65E0\u6548\u753B\u9762\u6BD4\u4F8B");
+    const edge = resolution ? parseFloat(resolution) * 1024 : 1024;
+    let w = Math.round(edge * Math.sqrt(rw / rh) / 16) * 16;
+    let h = Math.round(edge * Math.sqrt(rh / rw) / 16) * 16;
+    const max = schema.model.startsWith("openai/") ? 3840 : schema.model.includes("qwen-image-edit") || nested && mode === "image-to-image" ? 2048 : 4096;
+    if (Math.max(w, h) > max) {
+      const scale = max / Math.max(w, h);
+      w = Math.floor(w * scale / 16) * 16;
+      h = Math.floor(h * scale / 16) * 16;
+    }
+    settings.size = `${w}${nested ? "*" : "x"}${h}`;
+  }
+  if (input.duration !== void 0 && fields.duration) settings.duration = choose(obj(fields.duration), input.duration, true);
+  if (input.generate_audio !== void 0) {
+    const key = fields.generate_audio ? "generate_audio" : fields.with_audio ? "with_audio" : void 0;
+    if (!key) throw new Error("\u6A21\u578B\u4E0D\u652F\u6301\u63A7\u5236\u751F\u6210\u97F3\u9891");
+    settings[key] = input.generate_audio;
+  }
+  if (mode === "text-to-speech") {
+    const voice = input[sandboxVoiceKey(schema.model)] ?? obj(root.voice_id).default;
+    if (!voice) throw new Error("\u8BF7\u9009\u62E9\u6B64\u6A21\u578B\u7684\u97F3\u8272");
+    body.voice_id = voice;
+  }
+  if (mode === "text-to-music") {
+    body.instrumental = input.instrumental ?? true;
+    if (root.lyrics_optimizer && body.instrumental === false) body.lyrics_optimizer = true;
+  }
+  if (nested) body.parameters = settings;
+  return body;
+}
+function sandboxInputSchema(schemas, mode) {
+  const field = (title, type = "string", extra = {}) => ({ type, title, ...extra });
+  const properties = { prompt: field(mode === "text-to-speech" ? "\u6717\u8BFB\u6587\u672C" : "\u63D0\u793A\u8BCD", "string", { minLength: 1, "x-ui": { control: "textarea", order: 0 } }) };
+  const required = ["prompt"];
+  const mediaField = (title, maxItems) => field(title, "array", { items: { type: "object", properties: { url: { type: "string", minLength: 1 }, role: { type: "string" } }, required: ["url"] }, maxItems, "x-ui": { control: "media", accept: ["url"] } });
+  if (mode === "image-to-image") {
+    properties.images = mediaField("\u8F93\u5165\u56FE\u7247", 16);
+    required.push("images");
+    obj(properties.images).minItems = 1;
+  }
+  if (mode === "image-to-video") {
+    properties.first_frame = mediaField("\u9996\u5E27", 1);
+    required.push("first_frame");
+    obj(properties.first_frame).minItems = 1;
+  }
+  if (mode.endsWith("video")) {
+    for (const [key, title, max] of [["last_frame", "\u5C3E\u5E27", 1], ["reference_images", "\u53C2\u8003\u56FE\u7247", 9], ["videos", "\u53C2\u8003\u89C6\u9891", 3], ["audios", "\u53C2\u8003\u97F3\u9891", 3]]) {
+      if (key === "last_frame" && mode !== "image-to-video") continue;
+      if (key !== "last_frame" && mode === "image-to-video") continue;
+      if (new Set(schemas.map((s) => sandboxIdentity(s.model))).size >= 2 && schemas.every((s) => sandboxSupports(s, key))) properties[key] = mediaField(title, max);
+    }
+    properties.duration = field("\u76EE\u6807\u65F6\u957F\uFF08\u79D2\uFF09", "integer", { minimum: 1, maximum: 30 });
+  }
+  if (mode.endsWith("image") || mode.endsWith("video")) {
+    const fields = schemas.map((s) => {
+      const { root, parameters } = sandboxProperties(s);
+      return root.parameters ? parameters : root;
+    });
+    const ratios = ["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "21:9"].filter((r) => fields.every((p) => {
+      const k = ["ratio", "aspect_ratio", "aspectRatio"].find((k2) => p[k2]);
+      return !k || !values(obj(p[k])).length || values(obj(p[k])).includes(r);
+    }));
+    properties.aspect_ratio = field("\u753B\u9762\u6BD4\u4F8B", "string", { enum: ["default", ...ratios], default: "default", "x-ui": { optionLabels: { default: "\u5404\u6A21\u578B\u9ED8\u8BA4" } } });
+    const resolutions = (mode.endsWith("image") ? ["1K", "2K", "4K"] : ["480p", "540p", "720p", "768p", "1080p", "2K", "4K"]).filter((r) => fields.every((p) => !p.resolution || !values(obj(p.resolution)).length || values(obj(p.resolution)).some((v) => normalized(v) === r.toLowerCase())));
+    properties.resolution = field("\u6E05\u6670\u5EA6", "string", { enum: ["default", ...resolutions], default: "default", "x-ui": { optionLabels: { default: "\u5404\u6A21\u578B\u9ED8\u8BA4" } } });
+    if (schemas.length >= 2 && fields.every((p) => p.generate_audio || p.with_audio)) properties.generate_audio = field("\u751F\u6210\u58F0\u97F3", "boolean");
+  }
+  if (mode === "text-to-speech") for (const s of schemas) {
+    const voice = obj(sandboxProperties(s).root.voice_id);
+    properties[sandboxVoiceKey(s.model)] = { ...voice, title: `${s.model} \xB7 \u97F3\u8272`, "x-ui": { ...obj(voice["x-ui"]), resourceModel: s.model } };
+    required.push(sandboxVoiceKey(s.model));
+  }
+  if (mode === "text-to-text") {
+    properties.system = field("\u7CFB\u7EDF\u63D0\u793A\u8BCD", "string", { "x-ui": { control: "textarea" } });
+    properties.messages = field("\u5BF9\u8BDD\u5386\u53F2\uFF08\u53EF\u9009\uFF09", "array", { items: { type: "object", properties: { role: { type: "string", enum: ["user", "assistant"] }, content: { type: "string" } }, required: ["role", "content"], additionalProperties: false }, "x-ui": { control: "json" } });
+  }
+  if (mode === "text-to-music") properties.instrumental = field("\u7EAF\u97F3\u4E50", "boolean", { default: true });
+  const defaults = {};
+  for (const [key, value] of Object.entries(properties)) if (obj(value).default !== void 0) defaults[key] = obj(value).default;
+  return { model: schemas.map((s) => s.model).join(","), version: 1, dialect: "https://json-schema.org/draft/2020-12/schema", inputSchema: { type: "object", properties, required, additionalProperties: false }, outputSchema: {}, uiSchema: {}, defaults, examples: [] };
+}
+
+// ../contracts/src/ratio-display-order.ts
+function parseRatioParts(value) {
+  const matched = /^\s*(\d+(?:\.\d+)?)\s*:\s*(\d+(?:\.\d+)?)\s*$/.exec(value);
+  if (!matched) return void 0;
+  const w = Number(matched[1]);
+  const h = Number(matched[2]);
+  return w > 0 && h > 0 ? { w, h } : void 0;
+}
+function ratioDisplayOrderKey(value) {
+  const normalized2 = value.trim();
+  const parts = parseRatioParts(normalized2);
+  if (!parts) {
+    const auto = normalized2.toLowerCase() === "auto" ? 0 : 1;
+    return [0, auto, 0, 0, value];
+  }
+  if (parts.w === parts.h) return [1, 0, 0, 0, value];
+  const long = Math.max(parts.w, parts.h);
+  const short = Math.min(parts.w, parts.h);
+  const landscape = parts.w > parts.h ? 1 : 0;
+  return short === 1 ? [3, long, landscape, -short, value] : [2, long, landscape, -short, value];
+}
+function compareRatioDisplayOrder(a, b) {
+  const ka = ratioDisplayOrderKey(a);
+  const kb = ratioDisplayOrderKey(b);
+  for (let index = 0; index < ka.length; index += 1) {
+    if (ka[index] !== kb[index]) return ka[index] < kb[index] ? -1 : 1;
+  }
+  return 0;
+}
+function sortRatioDisplayOrder(values2) {
+  return [...values2].sort(compareRatioDisplayOrder);
+}
+var RATIO_SCHEMA_FIELDS = ["ratio", "aspect_ratio", "aspectRatio"];
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function orderSchemaRatioProperties(properties) {
+  if (!isPlainRecord(properties)) return properties;
+  let touched = false;
+  const next = { ...properties };
+  for (const field of RATIO_SCHEMA_FIELDS) {
+    const property = next[field];
+    if (!isPlainRecord(property)) continue;
+    const values2 = property.enum;
+    if (!Array.isArray(values2) || !values2.every((value) => typeof value === "string")) continue;
+    const ordered = sortRatioDisplayOrder(values2);
+    if (ordered.every((value, index) => value === values2[index])) continue;
+    const orderedProperty = { ...property, enum: ordered };
+    const ui = orderedProperty["x-ui"];
+    if (isPlainRecord(ui) && isPlainRecord(ui.optionLabels)) {
+      const labels = ui.optionLabels;
+      orderedProperty["x-ui"] = {
+        ...ui,
+        optionLabels: Object.fromEntries(ordered.map((value) => [value, labels[value] ?? value]))
+      };
+    }
+    next[field] = orderedProperty;
+    touched = true;
+  }
+  return touched ? next : properties;
+}
+
 // src/catalog/media-geometry.ts
 var RATIO_FIELDS = ["ratio", "aspect_ratio", "aspectRatio"];
 var QUALITY_FIELDS = ["quality"];
@@ -6310,12 +7508,12 @@ var PRO_TIER_SIZE_BY_RATIO = {
   "1.5K": { "1:1": "1.5K", "4:3": "1792x1344", "3:4": "1344x1792", "16:9": "2048x1152", "9:16": "1152x2048", "3:2": "1872x1248", "2:3": "1248x1872", "21:9": "2352x1008" },
   "2K": { "1:1": "2K", "4:3": "2368x1776", "3:4": "1776x2368", "16:9": "2816x1584", "9:16": "1584x2816", "3:2": "2496x1664", "2:3": "1664x2496", "21:9": "3136x1344" }
 };
-function isObject(value) {
+function isObject5(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function propertiesOf(schema) {
-  if (!isObject(schema)) return {};
-  return isObject(schema.properties) ? schema.properties : {};
+  if (!isObject5(schema)) return {};
+  return isObject5(schema.properties) ? schema.properties : {};
 }
 function stringList(value) {
   if (!Array.isArray(value)) return [];
@@ -6327,8 +7525,8 @@ function stringOptions(property) {
   return stringList(property.examples);
 }
 function optionLabelsOf(property, options, fallback) {
-  const ui = isObject(property["x-ui"]) ? property["x-ui"] : {};
-  const fromSchema = isObject(ui.optionLabels) ? ui.optionLabels : {};
+  const ui = isObject5(property["x-ui"]) ? property["x-ui"] : {};
+  const fromSchema = isObject5(ui.optionLabels) ? ui.optionLabels : {};
   const labels = {};
   for (const option of options) {
     const schemaLabel = fromSchema[option];
@@ -6356,10 +7554,10 @@ function collectTiers(property) {
 function locate(root, names) {
   const nested = propertiesOf(root.parameters);
   for (const field of names) {
-    if (isObject(root[field])) return { field, property: root[field] };
+    if (isObject5(root[field])) return { field, property: root[field] };
   }
   for (const field of names) {
-    if (isObject(nested[field])) return { field, nest: "parameters", property: nested[field] };
+    if (isObject5(nested[field])) return { field, nest: "parameters", property: nested[field] };
   }
   return void 0;
 }
@@ -6461,7 +7659,7 @@ function writeField(output, located, value) {
     return;
   }
   const current = output[located.nest];
-  const nested = isObject(current) ? { ...current } : {};
+  const nested = isObject5(current) ? { ...current } : {};
   nested[located.field] = value;
   output[located.nest] = nested;
 }
@@ -6471,16 +7669,16 @@ function readField(input, located) {
     return typeof value2 === "string" ? value2 : void 0;
   }
   const nested = input[located.nest];
-  if (!isObject(nested)) return void 0;
+  if (!isObject5(nested)) return void 0;
   const value = nested[located.field];
   return typeof value === "string" ? value : void 0;
 }
 function reverseLookup(table, size) {
-  const normalized = size.replaceAll("*", "x");
-  if (TIER_PATTERN.test(normalized)) return { resolution: displayTier(normalized), ratio: "1:1" };
+  const normalized2 = size.replaceAll("*", "x");
+  if (TIER_PATTERN.test(normalized2)) return { resolution: displayTier(normalized2), ratio: "1:1" };
   for (const [resolution, ratios] of Object.entries(table)) {
     for (const [ratio, mapped] of Object.entries(ratios)) {
-      if (mapped.replaceAll("*", "x") === normalized) return { resolution, ratio };
+      if (mapped.replaceAll("*", "x") === normalized2) return { resolution, ratio };
     }
   }
   return void 0;
@@ -6491,7 +7689,7 @@ function projectMediaGeometry(inputSchema) {
   const quality = inspected.quality ? fieldView(inspected.quality, stringOptions(inspected.quality.property), QUALITY_LABELS) : void 0;
   if (inspected.kind === "resolution-ratio" && inspected.resolution && inspected.ratio) {
     const resolutionOptions = stringOptions(inspected.resolution.property).map(displayTier);
-    const ratioOptions = stringOptions(inspected.ratio.property);
+    const ratioOptions = sortRatioDisplayOrder(stringOptions(inspected.ratio.property));
     return {
       kind: inspected.kind,
       resolution: fieldView(inspected.resolution, resolutionOptions, identityLabels(resolutionOptions)),
@@ -6500,12 +7698,12 @@ function projectMediaGeometry(inputSchema) {
     };
   }
   if (inspected.kind === "ratio-only" && inspected.ratio) {
-    const ratioOptions = stringOptions(inspected.ratio.property);
+    const ratioOptions = sortRatioDisplayOrder(stringOptions(inspected.ratio.property));
     return { kind: inspected.kind, ratio: ratioView(inspected.ratio, ratioOptions), ...quality ? { quality } : {} };
   }
   if ((inspected.kind === "pixel-size" || inspected.kind === "tier-size") && inspected.size && table) {
     const resolutionOptions = Object.keys(table);
-    const ratioOptions = [...new Set(Object.values(table).flatMap((ratios) => Object.keys(ratios)))];
+    const ratioOptions = sortRatioDisplayOrder([...new Set(Object.values(table).flatMap((ratios) => Object.keys(ratios)))]);
     return {
       kind: inspected.kind,
       resolution: {
@@ -6585,7 +7783,7 @@ function unifiedFromInput(input) {
 function applyMediaGeometry(inputSchema, input) {
   const inspected = inspect(inputSchema);
   const next = { ...input };
-  if (inspected.size?.nest === "parameters" && isObject(input.parameters)) {
+  if (inspected.size?.nest === "parameters" && isObject5(input.parameters)) {
     next.parameters = { ...input.parameters };
   }
   const nativeSize = inspected.size ? readField(next, inspected.size) : void 0;
@@ -6595,7 +7793,7 @@ function applyMediaGeometry(inputSchema, input) {
   );
   if (!shouldEncode) return next;
   const encoded = encodeMediaGeometry(inputSchema, unified);
-  if (isObject(encoded.parameters) && isObject(next.parameters)) {
+  if (isObject5(encoded.parameters) && isObject5(next.parameters)) {
     next.parameters = { ...next.parameters, ...encoded.parameters };
   } else {
     Object.assign(next, encoded);
@@ -6651,7 +7849,7 @@ var NexraWaitTimeoutError = class extends Error {
 };
 
 // src/generated/version.generated.ts
-var SDK_VERSION = "0.1.0-alpha.6";
+var SDK_VERSION = "0.1.0-alpha.7";
 
 // src/transport.ts
 var DEFAULT_BASE_URL = "https://api.nexra-ai.com/v1";
@@ -6723,9 +7921,9 @@ function jsonBody(value) {
     headers: { "content-type": "application/json" }
   };
 }
-function queryString(values) {
+function queryString(values2) {
   const params = new URLSearchParams();
-  for (const [key, value] of Object.entries(values)) {
+  for (const [key, value] of Object.entries(values2)) {
     if (value !== void 0) params.set(key, String(value));
   }
   const query = params.toString();
@@ -6761,8 +7959,8 @@ async function createApiError(response) {
   });
 }
 function isSafeMethod(method) {
-  const normalized = (method ?? "GET").toUpperCase();
-  return normalized === "GET" || normalized === "HEAD" || normalized === "OPTIONS";
+  const normalized2 = (method ?? "GET").toUpperCase();
+  return normalized2 === "GET" || normalized2 === "HEAD" || normalized2 === "OPTIONS";
 }
 function shouldRetryStatus(status) {
   return status === 408 || status === 409 || status === 429 || status >= 500;
@@ -6787,6 +7985,13 @@ var CatalogClient = class {
     this.transport = transport;
   }
   transport;
+  listPrices(signal) {
+    return this.transport.json(
+      "/catalog/prices",
+      { method: "GET", signal },
+      { retryable: true }
+    );
+  }
   quote(request, signal) {
     const spec = getModelSpec(request.modelId);
     const schema = spec?.operations.find((operation) => operation.operation === request.operation)?.inputSchema ?? spec?.operations[0]?.inputSchema;
@@ -6815,6 +8020,84 @@ function deepFreeze(value) {
 }
 
 export {
+  MEDIA_KINDS,
+  modelUploadRegion,
+  uploadedMediaUrl,
+  uploadedMediaInput,
+  USAGE_SOURCES,
+  USAGE_NORMALIZATION_STATUSES,
+  USAGE_RATING_STATUSES,
+  USAGE_GROUP_BYS,
+  USAGE_AMOUNT_KINDS,
+  TOKEN_METRICS,
+  MONEY_STRING_PATTERN,
+  USAGE_FILTER_SELECTION_LIMIT,
+  validateUsageFilters,
+  validateUsageSummaryQuery,
+  encodeUsageSummaryCursor,
+  parseUsageSummaryCursor,
+  encodeUsageKeysetCursor,
+  parseUsageKeysetCursor,
+  validateUsageDetailsQuery,
+  USAGE_ANOMALY_CATEGORIES,
+  validateUsageAnomaliesQuery,
+  validateUsageAnomalySummaryQuery,
+  ADMIN_USER_ROLES,
+  ADMIN_USER_STATUSES,
+  validateAdminUserListQuery,
+  encodeAdminUserCursor,
+  parseAdminUserCursor,
+  ADMIN_USER_ACTIVITY_KINDS,
+  isMoneyString,
+  validateAdminUserUpdate,
+  validateAdminUserApiKeyUpdate,
+  validateAdminWalletRechargeInput,
+  USAGE_FILTER_KINDS,
+  encodeUsageFilterCursor,
+  parseUsageFilterCursor,
+  validateUsageFilterOptionsQuery,
+  BILLING_CURRENCY,
+  WALLET_MAX_BALANCE_UNITS,
+  moneyToUnits,
+  moneyFromUnits,
+  multiplyMoney,
+  normalizeModelParameterSchema,
+  modelInputDefaults,
+  orderedSchemaProperties,
+  modelInputUi,
+  BILLING_METRICS,
+  BILLING_EXPORT_DIMENSIONS,
+  allocateDiscountedPriceLines,
+  validateNormalizedUsage,
+  evaluatePriceRule,
+  validatePriceRule,
+  validateMeteringContract,
+  assessUsageEvidence,
+  TASK_STATUSES,
+  taskReceipt,
+  taskResult,
+  isTerminalTaskStatus,
+  defaultProbeInterval,
+  defaultProbeTimeout,
+  classifyObservation,
+  availabilityStats,
+  availabilityBuckets,
+  rateProbeUsage,
+  probeCostExceeds,
+  SANDBOX_OPERATIONS,
+  sandboxObject,
+  sandboxIdentity,
+  sandboxModelModes,
+  sandboxOperations,
+  sandboxProperties,
+  sandboxSupports,
+  sandboxVoiceKey,
+  adaptSandboxInput,
+  sandboxInputSchema,
+  ratioDisplayOrderKey,
+  compareRatioDisplayOrder,
+  sortRatioDisplayOrder,
+  orderSchemaRatioProperties,
   NexraApiError,
   NexraTaskError,
   NexraWaitTimeoutError,