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

package/dist/media.js

@@ -0,0 +1,26 @@
+import {
+  NEXRA_GENERATION_OPERATIONS,
+  NEXRA_MEDIA_API_VERSION,
+  NEXRA_MEDIA_FEATURES,
+  NEXRA_MEDIA_INPUT_SCHEMAS,
+  NEXRA_MEDIA_OPERATIONS,
+  NEXRA_MEDIA_OPERATION_DEFINITIONS,
+  NEXRA_PUBLISHED_MEDIA_OPERATIONS,
+  isNexraMediaInput,
+  nexraMediaInputSchema,
+  nexraMediaInputSchemaForMode,
+  nexraMediaOperationForMode
+} from "./chunk-LEZWVFQH.js";
+export {
+  NEXRA_GENERATION_OPERATIONS,
+  NEXRA_MEDIA_API_VERSION,
+  NEXRA_MEDIA_FEATURES,
+  NEXRA_MEDIA_INPUT_SCHEMAS,
+  NEXRA_MEDIA_OPERATIONS,
+  NEXRA_MEDIA_OPERATION_DEFINITIONS,
+  NEXRA_PUBLISHED_MEDIA_OPERATIONS,
+  isNexraMediaInput,
+  nexraMediaInputSchema,
+  nexraMediaInputSchemaForMode,
+  nexraMediaOperationForMode
+};

package/dist/types.d.ts

@@ -0,0 +1,5 @@
+export { A as AssetImportRequest, a as AssetInput, b as AssetReference, c as AssetUploadOptions, d as MediaAsset, e as MediaAssetStatus, f as MediaKind, N as NexraImageLayer, g as NexraImageLayerDecompositionOutput } from './media-DzOxLGs-.js';
+export { e as CreateNexraDisplayQuoteBatchRequest, C as CreateNexraQuoteRequest, F as FetchLike, M as MediaGeometryField, k as MediaGeometryProjection, z as ModelCapabilitySummary, A as ModelDateVersion, B as ModelEndpointSummary, D as ModelModality, x as ModelResourceList, E as ModelResourceOption, w as ModelSchema, u as ModelSearchParams, l as NexraBillingCurrency, g as NexraCatalogRevision, y as NexraClientOptions, f as NexraDisplayQuoteBatch, G as NexraDisplayQuoteBatchEntry, n as NexraModelOperation, h as NexraModelSpec, j as NexraModelSpecFilter, d as NexraQuote, o as NexraSalePrice, c as NexraSalePriceList, p as NexraSettlement, v as TaskModel, T as TaskModelSummary, U as UnifiedMediaGeometry } from './media-geometry-COln1N_2.js';
+export { C as CursorPage, a as JsonObject, b as JsonPrimitive, J as JsonValue } from './json-Cz0MkWQn.js';
+export { A as ApiErrorPayload, N as NexraError, a as PublicError, b as PublicErrorContext, P as PublicErrorFields } from './errors-DJZuAKoO.js';
+export { d as CreateTaskOptions, e as CreateTaskRequest, C as CreateVoiceRequest, f as RequestDetails, b as RunResult, R as RunTaskOptions, c as Task, h as TaskCost, i as TaskError, j as TaskEvent, k as TaskEventType, l as TaskListParams, m as TaskPage, n as TaskProgress, o as TaskReceipt, c as TaskResult, p as TaskStatus, q as TaskTiming, r as TaskUsage, s as TaskWebhookConfig, t as TerminalTaskStatus, u as VerifyWebhookOptions, V as Voice, a as VoiceCreation, W as WaitTaskOptions, v as WatchTaskOptions } from './voices-xyPqhQqR.js';

package/dist/voices-xyPqhQqR.d.ts

@@ -0,0 +1,348 @@
+import { c as AssetUploadOptions, d as MediaAsset, A as AssetImportRequest, h as AssetCertificationRequest, i as AssetCertification, j as AssetCertificationWaitOptions } from './media-DzOxLGs-.js';
+import { H as HttpTransport, p as NexraSettlement } from './media-geometry-COln1N_2.js';
+import { a as JsonObject, J as JsonValue, C as CursorPage } from './json-Cz0MkWQn.js';
+import { P as PublicErrorFields, a as PublicError, b as PublicErrorContext, N as NexraError } from './errors-DJZuAKoO.js';
+
+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 REQUEST_HISTORY_MODALITIES: readonly ["image", "video", "audio", "language"];
+declare const REQUEST_HISTORY_KINDS: readonly ["task", "api"];
+declare const REQUEST_HISTORY_DISPLAY_STATUSES: readonly ["succeeded", "failed", "delivery_failed", "running"];
+type RequestHistoryFilters = Readonly<{
+    query?: string;
+    modality?: typeof REQUEST_HISTORY_MODALITIES[number];
+    kind?: typeof REQUEST_HISTORY_KINDS[number];
+    displayStatus?: typeof REQUEST_HISTORY_DISPLAY_STATUSES[number];
+}>;
+
+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;
+}
+type TaskBillingReason = "request_failed" | "request_cancelled" | "billing_usage_unavailable" | "billing_usage_invalid" | "billing_usage_incomplete" | "billing_evidence_invalid" | "billing_evidence_incomplete" | "billing_hold_unavailable" | "billing_price_unavailable" | "billing_pricing_unavailable" | "api_key_spending_limit_exceeded";
+interface TaskQueueSnapshot {
+    phase: "waiting_capacity" | "waiting_channel" | "dispatch_pending" | "waiting_upstream";
+    since: string;
+    deadlineAt?: string;
+    /** Upstream gateway queue position, present while waiting_upstream and observed. */
+    queuePosition?: number;
+    /** Upstream gateway queue ETA in seconds, present while waiting_upstream and observed. */
+    etaSeconds?: number;
+    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";
+    /** Safe read-only cause; execution failures release authorization rather than failing settlement. */
+    billingReason?: TaskBillingReason;
+    /** 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), `endUserId` (opaque end-user identifier), and `endUserIp`
+     * (IPv4/IPv6 address) for support diagnostics. These caller assertions are
+     * checked for format only 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;
+    /** Owning Nexra account, used to separate users in system request history. */
+    accountId?: string | null;
+    /** Owning organization for organization-key requests, including calls without a personal account. */
+    organizationId?: string | null;
+    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"];
+    billingReason?: Task["billingReason"];
+    settlement?: NexraSettlement;
+    metadata?: JsonObject;
+    /** Caller-asserted origin recorded with the request; diagnostics display only. */
+    callerUrl?: string | null;
+    /** Client address recorded at the trusted HTTP ingress; absent on historical requests. */
+    clientIp?: string | null;
+    /** Caller-asserted end-user identifier recorded with the request; diagnostics display only. */
+    endUserId?: string | null;
+    endUserIp?: string | null;
+    purpose?: string | null;
+    sourceSessionId?: string | null;
+    sourceTaskId?: 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 extends RequestHistoryFilters {
+    status?: TaskStatus;
+    model?: string;
+    limit?: number;
+    cursor?: string;
+    orphanOnly?: boolean;
+}
+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, type CreateVoiceRequest as C, 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 CreateTaskOptions as d, type CreateTaskRequest as e, type RequestDetails as f, TASK_STATUSES as g, type TaskCost as h, type TaskError as i, type TaskEvent as j, type TaskEventType as k, type TaskListParams as l, type TaskPage as m, type TaskProgress as n, type TaskReceipt as o, type TaskStatus as p, type TaskTiming as q, type TaskUsage as r, type TaskWebhookConfig as s, type TerminalTaskStatus as t, type VerifyWebhookOptions as u, type WatchTaskOptions as v, isTerminalTaskStatus as w, verifyWebhook as x };

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@byte_fluffy/nexra-sdk",
-  "version": "0.1.0-alpha.5",
+  "version": "0.1.0-alpha.52",
   "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": {
@@ -34,11 +50,42 @@
     "generate": "bun scripts/generate-public-catalog.ts",
     "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
+    }
   }
 }