@byte_fluffy/nexra-sdk 0.1.0-alpha.52 → 0.1.0-alpha.53

package/dist/index.js

@@ -1,489 +1,37 @@
+import {
+  AssetsClient,
+  ModelsClient,
+  NexraClient,
+  NexraTranscriptionError,
+  TasksClient,
+  TranscriptionClient,
+  VoicesClient,
+  createNexra,
+  verifyWebhook
+} from "./chunk-RBKLCJ3H.js";
 import {
   ceilDecimal,
   multiplyDecimal
 } from "./chunk-FCH5IQP5.js";
 import {
   CatalogClient,
-  HttpTransport,
   NexraApiError,
   NexraTaskError,
   NexraWaitTimeoutError,
   applyMediaGeometry,
-  applyNoWatermark,
   decodeMediaGeometry,
   encodeMediaGeometry,
   formatModelDisplayName,
   getModelSpec,
-  jsonBody,
   listModelSpecs,
-  parseServerSentEvents,
-  projectMediaGeometry,
-  queryString,
-  sleep
-} from "./chunk-V3KBU3J5.js";
+  projectMediaGeometry
+} from "./chunk-LWJWWD7Z.js";
 import {
   MEDIA_KINDS,
   TASK_STATUSES,
-  createTaskRequest,
   extractUpstreamErrorMessage,
   isTerminalTaskStatus
-} from "./chunk-LEZWVFQH.js";
-
-// 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
-    });
-  }
-  certifyForSeedance(asset, request = {}, signal) {
-    const assetId = typeof asset === "string" ? asset : asset.id;
-    return this.transport.json(
-      `/assets/${encodeURIComponent(assetId)}/certifications/seedance`,
-      {
-        method: "POST",
-        ...jsonBody(request),
-        signal
-      },
-      { retryable: false }
-    );
-  }
-  getSeedanceCertification(asset, signal) {
-    const assetId = typeof asset === "string" ? asset : asset.id;
-    return this.transport.json(
-      `/assets/${encodeURIComponent(assetId)}/certifications/seedance`,
-      { signal }
-    );
-  }
-  async waitForSeedanceCertification(asset, options = {}) {
-    const pollIntervalMs = positiveInteger(options.pollIntervalMs ?? 2e3, "pollIntervalMs");
-    const timeoutMs = positiveInteger(options.timeoutMs ?? 3e5, "timeoutMs");
-    const deadline = Date.now() + timeoutMs;
-    while (true) {
-      const certification = await this.getSeedanceCertification(asset, options.signal);
-      if (certification.status !== "processing") return certification;
-      if (Date.now() >= deadline) {
-        throw new Error("Timed out waiting for Seedance Asset certification");
-      }
-      await wait(Math.min(pollIntervalMs, Math.max(1, deadline - Date.now())), options.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 positiveInteger(value, name) {
-  if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`${name} must be a positive integer`);
-  return value;
-}
-async function wait(milliseconds, signal) {
-  if (signal?.aborted) throw signal.reason;
-  await new Promise((resolve, reject) => {
-    const timer = setTimeout(resolve, milliseconds);
-    signal?.addEventListener("abort", () => {
-      clearTimeout(timer);
-      reject(signal.reason);
-    }, { once: true });
-  });
-}
-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
-function withModelDisplayName(model) {
-  return { ...model, displayName: formatModelDisplayName(model.displayName, model.slug ? { modelId: model.slug } : void 0) };
-}
-var ModelsClient = class {
-  constructor(transport) {
-    this.transport = transport;
-  }
-  transport;
-  async search(params = {}, signal) {
-    const page = await this.transport.json(
-      `/models${queryString({
-        q: params.query,
-        modality: params.modality,
-        operation: params.operation,
-        category: params.category,
-        limit: params.limit,
-        cursor: params.cursor
-      })}`,
-      { signal }
-    );
-    return { ...page, data: page.data.map(withModelDisplayName) };
-  }
-  async get(model, signal) {
-    const detail = await this.transport.json(`/models/${encodeURIComponent(model)}`, {
-      signal
-    });
-    return {
-      ...withModelDisplayName(detail),
-      ...detail.familyVersions ? { familyVersions: detail.familyVersions.map(withModelDisplayName) } : {}
-    };
-  }
-  schema(model, signal) {
-    return this.transport.json(
-      `/models/${encodeURIComponent(model)}/schema`,
-      { signal }
-    );
-  }
-  resources(model, resource, signal) {
-    return this.transport.json(
-      `/models/${encodeURIComponent(model)}/resources/${encodeURIComponent(resource)}`,
-      { signal }
-    );
-  }
-};
-
-// src/voices.ts
-var VoicesClient = class {
-  constructor(transport) {
-    this.transport = transport;
-  }
-  transport;
-  async list(signal) {
-    const response = await this.transport.json("/voices", { signal });
-    return response.data;
-  }
-  get(voiceId, signal) {
-    return this.transport.json(`/voices/${encodeURIComponent(voiceId)}`, { signal });
-  }
-  create(request, options) {
-    if (!options.idempotencyKey.trim()) throw new TypeError("Idempotency-Key is required");
-    return this.transport.json("/voices", {
-      method: "POST",
-      ...jsonBody(request),
-      headers: { "content-type": "application/json", "idempotency-key": options.idempotencyKey },
-      signal: options.signal
-    }, { retryable: true });
-  }
-};
-
-// 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/tasks.ts
-var TasksClient = class {
-  constructor(transport, assets) {
-    this.transport = transport;
-    this.assets = assets;
-  }
-  transport;
-  assets;
-  async create(model, input, options = {}) {
-    const schema = getModelSpec(model)?.operations[0]?.inputSchema;
-    const mapped = schema && input && typeof input === "object" && !Array.isArray(input) ? applyNoWatermark(schema, applyMediaGeometry(schema, input)) : input;
-    const normalizedInput = await normalizeTaskInput(mapped, this.assets, options.signal);
-    const body = createTaskRequest(model, normalizedInput, {
-      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)) {
-          const task = event.payload?.task;
-          const deliveryPreparing = task && typeof task === "object" && !Array.isArray(task) && task.deliveryStatus === "preparing";
-          if (!deliveryPreparing) 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, input, options = {}) {
-    const task = await this.create(model, input, 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;
-  voices;
-  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);
-    this.voices = new VoicesClient(transport);
-  }
-  run(model, input, options = {}) {
-    return this.tasks.run(model, input, 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;
-}
+} from "./chunk-V3F6VPMP.js";
 export {
   AssetsClient,
   CatalogClient,
@@ -492,9 +40,11 @@ export {
   NexraApiError,
   NexraClient,
   NexraTaskError,
+  NexraTranscriptionError,
   NexraWaitTimeoutError,
   TASK_STATUSES,
   TasksClient,
+  TranscriptionClient,
   VoicesClient,
   applyMediaGeometry,
   ceilDecimal,

package/dist/{json-Cz0MkWQn.d.ts → json-dnsDzk-s.d.ts}

@@ -8,4 +8,4 @@ interface CursorPage<T> {
     nextCursor?: string;
 }
 
-export type { CursorPage as C, JsonValue as J, JsonObject as a, JsonPrimitive as b };
+export type { CursorPage as C, JsonObject as J, JsonPrimitive as a, JsonValue as b };

package/dist/language.d.ts

@@ -1,9 +1,9 @@
 import { APICallError, LanguageModelV4 } from '@ai-sdk/provider';
 import { NexraLanguageProtocol } from './catalog.js';
 export { NexraLanguageModelBinding } from './catalog.js';
-import { F as FetchLike } from './media-geometry-COln1N_2.js';
-import { N as NexraError } from './errors-DJZuAKoO.js';
-import './json-Cz0MkWQn.js';
+import { F as FetchLike } from './media-geometry-B92BvuQL.js';
+import { N as NexraError } from './errors-BXPUVOh7.js';
+import './json-dnsDzk-s.js';
 
 type NativeErrorContext = {
     url: string;