@byte_fluffy/nexra-sdk 0.1.0-alpha.3 → 0.1.0-alpha.30

package/dist/voices-Cl4ygZHV.d.ts

@@ -0,0 +1,345 @@
+import { c as AssetUploadOptions, d as MediaAsset, A as AssetImportRequest, g as AssetCertificationRequest, h as AssetCertification, i as AssetCertificationWaitOptions } from './assets-Cusrjj7_.js';
+import { H as HttpTransport, v as NexraSettlement } from './media-geometry-DAVFGry1.js';
+import { J as JsonValue, a as JsonObject, C as CursorPage } from './json-Cz0MkWQn.js';
+
+type PublicUpstreamUnavailableReason = "no_response" | "not_retained" | "unsupported_capture" | "error_not_emitted" | "size_limit";
+/** Network errors retain unknown codes from older or newer servers. */
+type NexraError = {
+    code: string;
+    message: string;
+    param?: string;
+};
+type PublicErrorContext = {
+    nexraRequestId?: string;
+    nexraHttpStatus?: number;
+};
+type PublicErrorFields = PublicErrorContext & {
+    nexraError?: NexraError;
+    upstreamHttpStatus?: number;
+    upstreamRequestId?: string;
+    upstreamError?: JsonValue;
+    upstreamRedacted?: true;
+    upstreamTruncated?: true;
+    upstreamUnavailableReason?: PublicUpstreamUnavailableReason;
+    upstreamFormat?: "sse" | "decoded";
+    upstreamEvent?: string;
+};
+type PublicError = PublicErrorFields & {
+    nexraError: NexraError;
+};
+type ApiErrorPayload = PublicError;
+
+declare class AssetsClient {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    upload(file: Blob, options?: AssetUploadOptions): Promise<MediaAsset>;
+    import(request: AssetImportRequest, signal?: AbortSignal): Promise<MediaAsset>;
+    get(assetId: string, signal?: AbortSignal): Promise<MediaAsset>;
+    certifyForSeedance(asset: MediaAsset | string, request?: AssetCertificationRequest, signal?: AbortSignal): Promise<AssetCertification>;
+    getSeedanceCertification(asset: MediaAsset | string, signal?: AbortSignal): Promise<AssetCertification>;
+    waitForSeedanceCertification(asset: MediaAsset | string, options?: AssetCertificationWaitOptions): Promise<AssetCertification>;
+    download(asset: MediaAsset | string, signal?: AbortSignal): Promise<Response>;
+    stream(asset: MediaAsset | string, signal?: AbortSignal): Promise<ReadableStream<Uint8Array>>;
+}
+
+interface CreateTaskOptions {
+    quoteToken?: string;
+    submittedAt?: string;
+    metadata?: JsonObject;
+    callback_url?: string;
+    /** @deprecated Use callback_url; do not supply both. */
+    webhook?: TaskWebhookConfig;
+    schemaVersion?: number;
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+interface WatchTaskOptions {
+    signal?: AbortSignal;
+    lastEventId?: string;
+    maxReconnects?: number;
+}
+interface WaitTaskOptions extends WatchTaskOptions {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    onEvent?: (event: TaskEvent) => void | Promise<void>;
+}
+interface RunTaskOptions extends CreateTaskOptions, WaitTaskOptions {
+    cancelOnAbort?: boolean;
+}
+declare class TasksClient {
+    private readonly transport;
+    private readonly assets;
+    constructor(transport: HttpTransport, assets: AssetsClient);
+    create<TOutput = JsonValue, TInput = Record<string, unknown>>(model: string, input: TInput, options?: CreateTaskOptions): Promise<TaskReceipt>;
+    get<TOutput = JsonValue>(taskId: string, signal?: AbortSignal): Promise<TaskResult<TOutput>>;
+    list<TOutput = JsonValue>(params?: TaskListParams, signal?: AbortSignal): Promise<CursorPage<TaskResult<TOutput>>>;
+    cancel<TOutput = JsonValue>(taskId: string, signal?: AbortSignal): Promise<TaskReceipt>;
+    watch(taskId: string, options?: WatchTaskOptions): AsyncGenerator<TaskEvent>;
+    wait<TOutput = JsonValue>(taskId: string, options?: WaitTaskOptions): Promise<TaskResult<TOutput>>;
+    run<TOutput = JsonValue, TInput = Record<string, unknown>>(model: string, input: TInput, options?: RunTaskOptions): Promise<RunResult<TOutput>>;
+}
+
+interface VerifyWebhookOptions {
+    toleranceSeconds?: number;
+    now?: Date;
+}
+/** @deprecated Only verifies legacy signed webhooks, not callback_url notifications. */
+declare function verifyWebhook(request: Request, secret: string, options?: VerifyWebhookOptions): Promise<boolean>;
+
+type TaskPage<TOutput = JsonValue> = CursorPage<TaskResult<TOutput>>;
+
+declare const TASK_STATUSES: readonly ["queued", "running", "succeeded", "failed", "cancelling", "cancelled"];
+type TaskStatus = (typeof TASK_STATUSES)[number];
+type TerminalTaskStatus = "succeeded" | "failed" | "cancelled";
+interface TaskProgress {
+    percent?: number;
+    stage?: string;
+    message?: string;
+}
+type TaskError = NexraError;
+interface TaskUsage {
+    components: Array<{
+        name: string;
+        quantity: number;
+        unit: string;
+    }>;
+    metadata?: JsonObject;
+}
+interface TaskCost {
+    amount: string;
+    currency: string;
+}
+interface TaskQueueSnapshot {
+    phase: "waiting_capacity" | "waiting_channel" | "dispatch_pending";
+    since: string;
+    deadlineAt?: string;
+    cancelable: boolean;
+}
+interface TaskTiming {
+    submittedAt: string;
+    providerSubmittedAt?: string;
+    providerCompletedAt?: string;
+    /** First public terminal response; background media may still be preparing. */
+    firstResponseAt?: string;
+    /** Background media ready response; absent while preparing or after persistence failure. */
+    secondResponseAt?: string;
+    storedAt?: string;
+    persistPolicy?: "terminal" | "background";
+    deliveryStatus?: "preparing" | "ready" | "failed";
+    preparationMs: number | null;
+    generationMs: number | null;
+    /** Background: elapsed persistence stage until assets are ready; terminal: measured transfer. Null when unfinished or unavailable. */
+    storageMs: number | null;
+    /** First-response time outside measured preparation/generation and any pre-response storage; not a separately instrumented stage. */
+    responseOverheadMs?: number | null;
+    /** Start of in-progress background persistence, when a worker has claimed the output. */
+    storageStartedAt?: string;
+    /** Background persistence elapsed time from first response to durable asset readiness. */
+    persistMs?: number | null;
+    totalMs: number | null;
+    /** Incident-only estimate of service readiness; actual public response remains in totalMs. */
+    correction?: {
+        incidentId: string;
+        outputReadyAt: string;
+        serviceReadyMs: number;
+        deploymentDelayMs: number;
+    };
+    startSource: "client" | "server";
+    /** Server clock reading taken when this snapshot was built; lets clients anchor live timers to server time. */
+    observedAt?: string;
+}
+/** Repository/console read model. HTTP clients receive TaskReceipt or TaskResult. */
+interface Task<TOutput = JsonValue> extends PublicErrorFields {
+    id: string;
+    /** Original platform request ID, shared with request history. */
+    requestId?: string;
+    /** Public Run ID, when this Task belongs to a shared-input run. */
+    runId?: string;
+    model: string;
+    operation: string;
+    schemaVersion: number;
+    /** Model request parameters; native-managed tasks retain the upstream field structure. */
+    input?: JsonObject;
+    status: TaskStatus;
+    /** Present only while an asynchronous Task is queued. */
+    queue?: TaskQueueSnapshot;
+    /** Persistence policy frozen when the Task is created. Background is limited to video Tasks. */
+    persistPolicy?: "terminal" | "background";
+    /**
+     * Regional media availability. "preparing" means the task result is delivered
+     * with provider media URLs while Nexra persists them to its own object storage
+     * in the background; "ready" means persisted URLs; "failed" means background
+     * persistence exhausted its retries and the provider URLs have expired.
+     * Execution/billing remain terminal regardless of this value.
+     */
+    deliveryStatus?: "preparing" | "ready" | "failed";
+    progress?: TaskProgress;
+    /** Native-managed tasks preserve the final response shape and media URLs; catalog models may normalize model identifiers. */
+    output?: TOutput;
+    assets: MediaAsset[];
+    error?: PublicError;
+    usage?: TaskUsage;
+    cost?: TaskCost;
+    /** Customer billing state; absent on older servers. */
+    billingStatus?: "pending" | "succeeded" | "failed" | "refunded" | "unavailable";
+    /** Final customer sale settlement. Provider procurement cost is never exposed here. */
+    settlement?: NexraSettlement;
+    /**
+     * Caller-supplied business data, returned unchanged; never sent to the provider.
+     * The platform extracts the reserved string keys `callerUrl` (caller origin,
+     * https URL) and `endUserId` (opaque end-user identifier) into dedicated
+     * attribution columns for support diagnostics; their values are not validated
+     * beyond format checks and remain unchanged inside `metadata`.
+     */
+    metadata?: JsonObject;
+    timing?: TaskTiming;
+    /** Server-side Task record creation time (ISO 8601 UTC). */
+    createdAt: string;
+    /** Latest Task record update, not the generation completion time (ISO 8601 UTC). */
+    updatedAt: string;
+    /** First worker execution start; absent while queued or cancelled before execution. */
+    startedAt?: string;
+    /**
+     * Terminal succeeded/failed/cancelled time. Synchronously persisted tasks
+     * (default) reach succeeded only after required asset storage; background-
+     * persisted tasks are declared succeeded at result delivery while storage
+     * continues, signalled by `deliveryStatus` and the task timing second response.
+     */
+    completedAt?: string;
+    /** @deprecated Reserved; no Task expiry policy is currently enforced. Not a media URL expiry. */
+    expiresAt?: string;
+}
+/** POST /tasks returns acceptance only, including for idempotent replays. */
+type TaskReceipt = Pick<Task, "id" | "status"> & PublicErrorContext;
+/** Public Task result; platform diagnostics and business tags live in RequestDetails. */
+type TaskResult<TOutput = JsonValue> = Pick<Task<TOutput>, "id" | "model" | "status"> & Partial<Pick<Task<TOutput>, "output" | "assets" | "persistPolicy" | "deliveryStatus" | "settlement" | "queue">> & PublicErrorFields;
+/** Platform request details, used by both managed Tasks and native proxy requests. */
+interface RequestDetails extends PublicErrorFields {
+    id: string;
+    nexraRequestId?: string;
+    taskId: string | null;
+    method: string;
+    path: string;
+    protocol?: string;
+    accessMode?: string | null;
+    model: string | null;
+    operation: string | null;
+    status: string;
+    /** Linked Task lifecycle when this request accepted a Task; HTTP `status` stays accepted. */
+    taskStatus?: string | null;
+    persistPolicy?: "terminal" | "background";
+    deliveryStatus?: Task["deliveryStatus"];
+    errorCode: string | null;
+    /** HTTP duration, never substituted with asynchronous task duration. */
+    durationMs: number | null;
+    timing?: TaskTiming;
+    cost?: TaskCost;
+    billingStatus?: Task["billingStatus"];
+    settlement?: NexraSettlement;
+    metadata?: JsonObject;
+    /** Caller-asserted origin extracted from metadata.callerUrl; diagnostics display only. */
+    callerUrl?: string | null;
+    /** Caller-asserted end-user identifier extracted from metadata.endUserId; diagnostics display only. */
+    endUserId?: string | null;
+    /** Name of the API key that authenticated this request; diagnostics display only. */
+    apiKeyName?: string | null;
+    /** Latest known execution update; omitted when not observed. */
+    updatedAt?: string;
+    runId?: string;
+    schemaVersion?: number;
+    createdAt?: string;
+    startedAt?: string;
+    completedAt?: string;
+    input: JsonObject | null;
+    /** Present only on single-request reads (`includeOutput`). */
+    output?: JsonValue | null;
+    /** Output media with durable TOS URLs; present only on `includeOutput`. */
+    assets?: MediaAsset[];
+    receivedAt: string;
+    finishedAt: string | null;
+}
+type TaskEventType = "state" | "progress" | "preview" | "log" | "usage" | "warning" | "result";
+interface TaskEvent {
+    id: string;
+    taskId: string;
+    sequence: number;
+    type: TaskEventType;
+    status?: TaskStatus;
+    progress?: TaskProgress;
+    asset?: MediaAsset;
+    message?: string;
+    payload?: JsonObject;
+    occurredAt: string;
+}
+/** @deprecated Use CreateTaskRequest.callback_url. Kept for existing callers. */
+type TaskWebhookConfig = JsonObject & Readonly<{
+    url: string;
+    /** Shared HMAC secret used to verify Nexra callback signatures. */
+    secret: string;
+    events?: Array<"completed">;
+}>;
+type CreateTaskControls = Readonly<{
+    /** @internal Console telemetry only: browser send time before uploads, not execution time. */
+    submittedAt?: string;
+    model: string;
+    /** Signed Nexra quote used to lock this input to a sale-price revision. */
+    quoteToken?: string;
+    /** Optional business identifiers such as orderId, available in request details. Do not include secrets. */
+    metadata?: JsonObject;
+    /** Platform completion callback, independent of provider callback support. Never sent upstream. */
+    callback_url?: string;
+    /** @deprecated Use callback_url; do not supply both. */
+    webhook?: TaskWebhookConfig;
+    /** @deprecated Compatibility check only; the server resolves the current contract. */
+    schemaVersion?: number;
+}>;
+/** Public Nexra Task request. Category parameters are top-level fields; `input`
+ * is deliberately not an envelope. Persistent Task records still retain their
+ * own `input` snapshot after the HTTP boundary separates control fields. */
+type CreateTaskRequest<TInput extends JsonObject = JsonObject> = TInput & CreateTaskControls;
+interface TaskListParams {
+    status?: TaskStatus;
+    model?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface RunResult<TOutput = JsonValue> {
+    taskId: string;
+    output: TOutput;
+    assets: MediaAsset[];
+    usage?: TaskUsage;
+    cost?: TaskCost;
+    task: TaskResult<TOutput>;
+}
+declare function isTerminalTaskStatus(status: TaskStatus): status is TerminalTaskStatus;
+
+type Voice = Readonly<{
+    id: string;
+    provider: "elevenlabs";
+    source: "design" | "clone";
+    sourceTaskId?: string;
+    previewId?: string;
+    name: string;
+    status: "processing" | "active" | "verification_required" | "failed" | "expired" | "deleted";
+    previewUrl?: string;
+    requiresVerification?: boolean;
+    createdAt: string;
+    expiresAt?: string;
+}>;
+type CreateVoiceRequest = Readonly<{
+    name: string;
+    source: Readonly<{
+        kind: "design";
+        taskId: string;
+        previewId: string;
+    }> | Readonly<{
+        kind: "clone";
+        samples: readonly string[];
+    }>;
+}>;
+type VoiceCreation = Readonly<{
+    taskId: string;
+    voice: Voice;
+}>;
+
+export { AssetsClient as A, verifyWebhook as B, type CreateVoiceRequest as C, type NexraError as N, type PublicErrorFields as P, type RunTaskOptions as R, TasksClient as T, type Voice as V, type WaitTaskOptions as W, type VoiceCreation as a, type RunResult as b, type TaskResult as c, type ApiErrorPayload as d, type CreateTaskOptions as e, type CreateTaskRequest as f, type PublicError as g, type PublicErrorContext as h, type RequestDetails as i, TASK_STATUSES as j, type TaskCost as k, type TaskError as l, type TaskEvent as m, type TaskEventType as n, type TaskListParams as o, type TaskPage as p, type TaskProgress as q, type TaskReceipt as r, type TaskStatus as s, type TaskTiming as t, type TaskUsage as u, type TaskWebhookConfig as v, type TerminalTaskStatus as w, type VerifyWebhookOptions as x, type WatchTaskOptions as y, isTerminalTaskStatus as z };

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@byte_fluffy/nexra-sdk",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.30",
   "type": "module",
+  "types": "./dist/index.d.ts",
   "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/starrank-soft/nexra-monorepo.git",
@@ -24,6 +28,18 @@
     "./decimal": {
       "types": "./dist/decimal.d.ts",
       "import": "./dist/decimal.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    },
+    "./media": {
+      "types": "./dist/media.d.ts",
+      "import": "./dist/media.js"
+    },
+    "./language": {
+      "types": "./dist/language.d.ts",
+      "import": "./dist/language.js"
     }
   },
   "publishConfig": {
@@ -32,13 +48,34 @@
   },
   "scripts": {
     "generate": "bun scripts/generate-public-catalog.ts",
-    "build": "bun run generate && tsup src/index.ts src/catalog.ts src/decimal.ts --format esm --dts --dts-resolve --clean --out-dir dist --target es2022 --platform browser",
+    "build": "bun run generate && tsup",
     "test": "vitest run --root ../.. packages/sdk/tests",
+    "verify:video-schema-drift": "bun scripts/verify-video-schema-drift.ts",
     "prepack": "bun run build"
   },
   "devDependencies": {
+    "@ai-sdk/anthropic": "4.0.30",
+    "@ai-sdk/google": "4.0.12",
+    "@ai-sdk/openai": "4.0.11",
+    "@ai-sdk/provider": "4.0.2",
+    "@ai-sdk/provider-utils": "5.0.21",
     "@nexra/contracts": "workspace:*",
+    "@nexra/models": "workspace:*",
     "tsup": "8.5.1",
     "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "@ai-sdk/anthropic": "^4.0.30",
+    "@ai-sdk/google": "^4.0.12",
+    "@ai-sdk/openai": "^4.0.11",
+    "@ai-sdk/provider": "^4.0.2",
+    "@ai-sdk/provider-utils": "^5.0.21"
+  },
+  "peerDependenciesMeta": {
+    "@ai-sdk/anthropic": { "optional": true },
+    "@ai-sdk/google": { "optional": true },
+    "@ai-sdk/openai": { "optional": true },
+    "@ai-sdk/provider": { "optional": true },
+    "@ai-sdk/provider-utils": { "optional": true }
   }
 }