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

package/dist/catalog.js

@@ -9,8 +9,8 @@ import {
   listModelSpecs,
   projectMediaGeometry,
   resolveNexraLanguageReasoning
-} from "./chunk-3CF6PDT3.js";
-import "./chunk-DKQZWIQ7.js";
+} from "./chunk-MNRDMPUS.js";
+import "./chunk-QBW7OCT3.js";
 export {
   CatalogClient,
   applyMediaGeometry,

package/dist/{chunk-3CF6PDT3.js → chunk-MNRDMPUS.js}

@@ -2,7 +2,7 @@ import {
   normalizePublicErrorInput,
   pickPublicErrorFields,
   sortRatioDisplayOrder
-} from "./chunk-DKQZWIQ7.js";
+} from "./chunk-QBW7OCT3.js";
 
 // src/catalog/generated/audio.generated.json
 var audio_generated_default = [
@@ -30539,6 +30539,452 @@ var video_generated_default = [
     ],
     endpoints: []
   },
+  {
+    id: "minimax/minimax-h3-local-reference",
+    contractVersion: 1,
+    developer: "minimax",
+    displayName: "MiniMax H3 Local Reference",
+    summary: "Generate video from a prompt with reference images, videos and audio.",
+    kind: "video",
+    family: "H3 Local",
+    versionLabel: "H3 Local Reference",
+    aliases: [],
+    capabilities: {
+      inputModalities: [
+        "text",
+        "image",
+        "video",
+        "audio"
+      ],
+      outputModalities: [
+        "video"
+      ],
+      inputModes: [
+        "image-to-video",
+        "video-to-video",
+        "audio-to-video"
+      ],
+      features: [
+        "reference-image",
+        "reference-video",
+        "reference-audio",
+        "omni-reference"
+      ]
+    },
+    operations: [
+      {
+        operation: "video.generate",
+        inputModalities: [
+          "text",
+          "image",
+          "video",
+          "audio"
+        ],
+        outputModalities: [
+          "video"
+        ],
+        inputSchema: {
+          $schema: "https://json-schema.org/draft/2020-12/schema",
+          type: "object",
+          properties: {
+            content: {
+              type: "array",
+              minItems: 2,
+              items: {
+                oneOf: [
+                  {
+                    type: "object",
+                    properties: {
+                      type: {
+                        const: "text"
+                      },
+                      text: {
+                        type: "string",
+                        minLength: 1
+                      },
+                      role: {
+                        type: "string",
+                        enum: [
+                          "prompt",
+                          "negative_prompt"
+                        ]
+                      }
+                    },
+                    required: [
+                      "type",
+                      "text",
+                      "role"
+                    ],
+                    additionalProperties: false,
+                    allOf: [
+                      {
+                        if: {
+                          type: "object",
+                          properties: {
+                            role: {
+                              const: "prompt"
+                            }
+                          },
+                          required: [
+                            "role"
+                          ]
+                        },
+                        then: {
+                          type: "object",
+                          properties: {
+                            text: {
+                              type: "string",
+                              maxLength: 2e4,
+                              minLength: 1,
+                              title: "Prompt"
+                            }
+                          }
+                        }
+                      },
+                      {
+                        if: {
+                          type: "object",
+                          properties: {
+                            role: {
+                              const: "negative_prompt"
+                            }
+                          },
+                          required: [
+                            "role"
+                          ]
+                        },
+                        then: {
+                          type: "object",
+                          properties: {
+                            text: {
+                              type: "string",
+                              maxLength: 1e4,
+                              title: "Negative Prompt",
+                              default: ""
+                            }
+                          }
+                        }
+                      }
+                    ]
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      type: {
+                        const: "image"
+                      },
+                      source: {
+                        oneOf: [
+                          {
+                            type: "string",
+                            minLength: 1
+                          },
+                          {
+                            type: "object",
+                            properties: {
+                              assetId: {
+                                type: "string",
+                                minLength: 1
+                              }
+                            },
+                            required: [
+                              "assetId"
+                            ],
+                            additionalProperties: false
+                          }
+                        ]
+                      },
+                      role: {
+                        type: "string",
+                        const: "reference"
+                      }
+                    },
+                    required: [
+                      "type",
+                      "source",
+                      "role"
+                    ],
+                    additionalProperties: false
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      type: {
+                        const: "video"
+                      },
+                      source: {
+                        oneOf: [
+                          {
+                            type: "string",
+                            minLength: 1
+                          },
+                          {
+                            type: "object",
+                            properties: {
+                              assetId: {
+                                type: "string",
+                                minLength: 1
+                              }
+                            },
+                            required: [
+                              "assetId"
+                            ],
+                            additionalProperties: false
+                          }
+                        ]
+                      },
+                      role: {
+                        type: "string",
+                        const: "reference"
+                      }
+                    },
+                    required: [
+                      "type",
+                      "source",
+                      "role"
+                    ],
+                    additionalProperties: false
+                  },
+                  {
+                    type: "object",
+                    properties: {
+                      type: {
+                        const: "audio"
+                      },
+                      source: {
+                        oneOf: [
+                          {
+                            type: "string",
+                            minLength: 1
+                          },
+                          {
+                            type: "object",
+                            properties: {
+                              assetId: {
+                                type: "string",
+                                minLength: 1
+                              }
+                            },
+                            required: [
+                              "assetId"
+                            ],
+                            additionalProperties: false
+                          }
+                        ]
+                      },
+                      role: {
+                        type: "string",
+                        const: "reference"
+                      }
+                    },
+                    required: [
+                      "type",
+                      "source",
+                      "role"
+                    ],
+                    additionalProperties: false
+                  }
+                ]
+              },
+              "x-ui": {
+                control: "content-parts",
+                order: 0
+              },
+              maxItems: 17,
+              description: "Provide a prompt and at least one image, video or audio reference.",
+              allOf: [
+                {
+                  contains: {
+                    type: "object",
+                    properties: {
+                      type: {
+                        const: "text"
+                      },
+                      role: {
+                        const: "prompt"
+                      }
+                    },
+                    required: [
+                      "type",
+                      "role"
+                    ]
+                  },
+                  minContains: 1,
+                  maxContains: 1
+                },
+                {
+                  contains: {
+                    type: "object",
+                    properties: {
+                      type: {
+                        const: "text"
+                      },
+                      role: {
+                        const: "negative_prompt"
+                      }
+                    },
+                    required: [
+                      "type",
+                      "role"
+                    ]
+                  },
+                  minContains: 0,
+                  maxContains: 1
+                },
+                {
+                  contains: {
+                    type: "object",
+                    properties: {
+                      type: {
+                        const: "image"
+                      },
+                      role: {
+                        const: "reference"
+                      }
+                    },
+                    required: [
+                      "type",
+                      "role"
+                    ]
+                  },
+                  minContains: 0,
+                  maxContains: 9
+                },
+                {
+                  contains: {
+                    type: "object",
+                    properties: {
+                      type: {
+                        const: "video"
+                      },
+                      role: {
+                        const: "reference"
+                      }
+                    },
+                    required: [
+                      "type",
+                      "role"
+                    ]
+                  },
+                  minContains: 0,
+                  maxContains: 3
+                },
+                {
+                  contains: {
+                    type: "object",
+                    properties: {
+                      type: {
+                        const: "audio"
+                      },
+                      role: {
+                        const: "reference"
+                      }
+                    },
+                    required: [
+                      "type",
+                      "role"
+                    ]
+                  },
+                  minContains: 0,
+                  maxContains: 3
+                },
+                {
+                  contains: {
+                    type: "object",
+                    properties: {
+                      type: {
+                        enum: [
+                          "image",
+                          "video",
+                          "audio"
+                        ]
+                      }
+                    },
+                    required: [
+                      "type"
+                    ]
+                  },
+                  minContains: 1
+                }
+              ]
+            },
+            aspect_ratio: {
+              type: "string",
+              title: "Aspect Ratio",
+              default: "16:9",
+              pattern: "^(?:1:1|2:3|3:2|3:4|4:3|9:16|16:9|21:9)(?: \\([^)]+\\))?$",
+              "x-ui": {
+                order: 10
+              },
+              enum: [
+                "1:1",
+                "2:3",
+                "3:2",
+                "3:4",
+                "4:3",
+                "9:16",
+                "16:9",
+                "21:9"
+              ]
+            },
+            duration: {
+              type: "number",
+              maximum: 15,
+              title: "\u89C6\u9891\u65F6\u957F",
+              default: 5,
+              minimum: 0.2,
+              "x-ui": {
+                order: 12,
+                control: "range",
+                unit: "\u79D2"
+              }
+            },
+            seed: {
+              type: "integer",
+              minimum: 0,
+              title: "\u968F\u673A\u79CD\u5B50",
+              "x-ui": {
+                order: 13,
+                control: "number"
+              }
+            },
+            resolution: {
+              type: "string",
+              title: "\u5206\u8FA8\u7387",
+              enum: [
+                "480P",
+                "768P"
+              ],
+              "x-ui": {
+                order: 11,
+                control: "segmented"
+              }
+            }
+          },
+          required: [
+            "content"
+          ],
+          additionalProperties: false
+        },
+        outputSchema: {},
+        metering: {
+          schemaVersion: 1,
+          kind: "non_token",
+          metrics: [
+            {
+              metric: "requests",
+              requirement: "required"
+            },
+            {
+              metric: "output_video_seconds",
+              requirement: "required"
+            }
+          ]
+        }
+      }
+    ],
+    endpoints: []
+  },
   {
     id: "agnes/agnes-video-v2-0",
     contractVersion: 1,
@@ -50448,7 +50894,7 @@ var NexraWaitTimeoutError = class extends Error {
 };
 
 // src/generated/version.generated.ts
-var SDK_VERSION = "0.1.0-alpha.30";
+var SDK_VERSION = "0.1.0-alpha.32";
 
 // src/transport.ts
 var DEFAULT_BASE_URL = "https://api.nexra-ai.com/v1";
@@ -50583,39 +51029,14 @@ async function* parseServerSentEvents(response, options = {}) {
     void reader.cancel(options.signal?.reason).catch(() => void 0);
   };
   options.signal?.addEventListener("abort", abort, { once: true });
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let current = emptyEvent();
+  const decode = createServerSentEventDecoder();
   try {
     while (true) {
       if (options.signal?.aborted) throw options.signal.reason ?? new Error("SSE request was aborted");
       const { value, done } = await reader.read();
       if (options.signal?.aborted) throw options.signal.reason ?? new Error("SSE request was aborted");
-      buffer += decoder.decode(value, { stream: !done });
-      const lines = buffer.split(/\r?\n/);
-      buffer = done ? "" : lines.pop() ?? "";
-      for (const line of lines) {
-        if (line === "") {
-          const event = buildEvent(current);
-          current = emptyEvent();
-          if (event) yield event;
-          continue;
-        }
-        if (line.startsWith(":")) continue;
-        const separator = line.indexOf(":");
-        const field2 = separator === -1 ? line : line.slice(0, separator);
-        let content = separator === -1 ? "" : line.slice(separator + 1);
-        if (content.startsWith(" ")) content = content.slice(1);
-        if (field2 === "data") current.data.push(content);
-        else if (field2 === "event") current.event = content;
-        else if (field2 === "id") current.id = content;
-        else if (field2 === "retry") current.retry = Number(content);
-      }
-      if (done) {
-        const event = buildEvent(current);
-        if (event) yield event;
-        return;
-      }
+      for (const event of decode(value, done)) yield event;
+      if (done) return;
     }
   } finally {
     options.signal?.removeEventListener("abort", abort);
@@ -50623,6 +51044,59 @@ async function* parseServerSentEvents(response, options = {}) {
     reader.releaseLock();
   }
 }
+function createServerSentEventDecoder() {
+  const decode = createServerSentEventFrameDecoder();
+  return (bytes, done) => decode(bytes, done).flatMap((frame) => frame.event ? [frame.event] : []);
+}
+function createServerSentEventFrameDecoder() {
+  const decoder = new TextDecoder();
+  let buffer = new Uint8Array();
+  let cursor = 0;
+  let lineStart = 0;
+  let current = emptyEvent();
+  const line = (value) => {
+    if (value.startsWith(":")) return;
+    const separator = value.indexOf(":");
+    const field2 = separator === -1 ? value : value.slice(0, separator);
+    let content = separator === -1 ? "" : value.slice(separator + 1);
+    if (content.startsWith(" ")) content = content.slice(1);
+    if (field2 === "data") current.data.push(content);
+    else if (field2 === "event") current.event = content;
+    else if (field2 === "id") current.id = content;
+    else if (field2 === "retry") current.retry = Number(content);
+  };
+  return (bytes, done = false) => {
+    const frames = [];
+    if (bytes?.length) {
+      const joined = new Uint8Array(buffer.length + bytes.length);
+      joined.set(buffer);
+      joined.set(bytes, buffer.length);
+      buffer = joined;
+    }
+    let frameStart = 0;
+    for (; cursor < buffer.length; cursor++) {
+      if (buffer[cursor] !== 10) continue;
+      const lineEnd = buffer[cursor - 1] === 13 ? cursor - 1 : cursor;
+      if (lineEnd === lineStart) {
+        frames.push({ event: buildEvent(current), bytes: buffer.slice(frameStart, cursor + 1) });
+        current = emptyEvent();
+        frameStart = cursor + 1;
+      } else line(decoder.decode(buffer.subarray(lineStart, lineEnd)));
+      lineStart = cursor + 1;
+    }
+    buffer = buffer.slice(frameStart);
+    cursor -= frameStart;
+    lineStart -= frameStart;
+    if (done) {
+      if (lineStart < buffer.length) line(decoder.decode(buffer.subarray(lineStart)));
+      if (buffer.length) frames.push({ event: buildEvent(current), bytes: buffer });
+      buffer = new Uint8Array();
+      cursor = lineStart = 0;
+      current = emptyEvent();
+    }
+    return frames;
+  };
+}
 function emptyEvent() {
   return { data: [] };
 }
@@ -50829,6 +51303,7 @@ export {
   applyMediaGeometry,
   applyNoWatermark,
   parseServerSentEvents,
+  createServerSentEventFrameDecoder,
   formatModelDisplayName,
   CatalogClient,
   getModelSpec,

package/dist/{chunk-DKQZWIQ7.js → chunk-QBW7OCT3.js}

@@ -539,6 +539,12 @@ var PUBLIC_ERROR_MESSAGES = {
   "zh-CN": Object.fromEntries(PUBLIC_ERROR_CODES.map((code) => [code, PUBLIC_ERROR_CATALOG[code]["zh-CN"]])),
   en: Object.fromEntries(PUBLIC_ERROR_CODES.map((code) => [code, PUBLIC_ERROR_CATALOG[code].en]))
 };
+function isPublicErrorCode(code) {
+  return Object.hasOwn(PUBLIC_ERROR_CATALOG, code);
+}
+function publicErrorMessage(code, locale = "en") {
+  return PUBLIC_ERROR_MESSAGES[locale][isPublicErrorCode(code) ? code : "internal_error"];
+}
 function pickPublicErrorDetails(value) {
   return isRecord(value) && typeof value.param === "string" && value.param.trim() ? { param: value.param } : void 0;
 }
@@ -637,6 +643,23 @@ function identifier(value) {
 function httpStatus(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599 ? value : void 0;
 }
+function resolvePublicErrorLocale(acceptLanguage) {
+  let chosen = "en";
+  let highestQuality = 0;
+  for (const candidate of (acceptLanguage ?? "").split(",")) {
+    const [tag, ...parameters] = candidate.trim().toLowerCase().split(";");
+    const locale = /^zh(?:-[a-z0-9]+)*$/.test(tag ?? "") ? "zh-CN" : /^en(?:-[a-z0-9]+)*$/.test(tag ?? "") ? "en" : void 0;
+    if (!locale) continue;
+    const qualityParameter = parameters.map((parameter) => parameter.trim()).find((parameter) => parameter.startsWith("q="));
+    const rawQuality = qualityParameter?.slice(2).trim();
+    const quality = rawQuality === void 0 ? 1 : /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/.test(rawQuality) ? Number(rawQuality) : 0;
+    if (quality > highestQuality) {
+      chosen = locale;
+      highestQuality = quality;
+    }
+  }
+  return chosen;
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -710,8 +733,11 @@ function sortRatioDisplayOrder(values) {
 
 export {
   MEDIA_KINDS,
+  isPublicErrorCode,
+  publicErrorMessage,
   pickPublicErrorFields,
   normalizePublicErrorInput,
+  resolvePublicErrorLocale,
   NEXRA_MEDIA_API_VERSION,
   NEXRA_GENERATION_OPERATIONS,
   NEXRA_MEDIA_OPERATIONS,

package/dist/errors-DZlSwyv8.d.ts

@@ -0,0 +1,30 @@
+import { J as JsonValue } 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;
+
+export type { ApiErrorPayload as A, NexraError as N, PublicErrorFields as P, PublicError as a, PublicErrorContext as b };

package/dist/index.d.ts

@@ -3,8 +3,10 @@ import { H as HttpTransport, M as ModelSearchParams, T as TaskModelSummary, a as
 export { C as CreateNexraDisplayQuoteBatchRequest, d as CreateNexraQuoteRequest, F as FetchLike, e as MediaGeometryField, f as MediaGeometryProjection, g as ModelCapabilitySummary, h as ModelDateVersion, i as ModelEndpointSummary, j as ModelModality, k as ModelResourceOption, l as NexraBillingCurrency, m as NexraCatalogRevision, n as NexraDisplayQuoteBatch, o as NexraDisplayQuoteBatchEntry, p as NexraModelOperation, q as NexraModelSpec, r as NexraModelSpecFilter, s as NexraQuote, t as NexraSalePrice, u as NexraSalePriceList, v as NexraSettlement, U as UnifiedMediaGeometry, w as applyMediaGeometry, x as decodeMediaGeometry, y as encodeMediaGeometry, z as projectMediaGeometry } from './media-geometry-DAVFGry1.js';
 import { C as CursorPage, J as JsonValue } from './json-Cz0MkWQn.js';
 export { a as JsonObject, b as JsonPrimitive } from './json-Cz0MkWQn.js';
-import { V as Voice, C as CreateVoiceRequest, a as VoiceCreation, A as AssetsClient, T as TasksClient, R as RunTaskOptions, b as RunResult, N as NexraError, P as PublicErrorFields, c as TaskResult } from './voices-Cl4ygZHV.js';
-export { d as ApiErrorPayload, e as CreateTaskOptions, f as CreateTaskRequest, g as PublicError, h as PublicErrorContext, i as RequestDetails, j as TASK_STATUSES, k as TaskCost, l as TaskError, m as TaskEvent, n as TaskEventType, o as TaskListParams, p as TaskPage, q as TaskProgress, r as TaskReceipt, s as TaskStatus, t as TaskTiming, u as TaskUsage, v as TaskWebhookConfig, w as TerminalTaskStatus, x as VerifyWebhookOptions, W as WaitTaskOptions, y as WatchTaskOptions, z as isTerminalTaskStatus, B as verifyWebhook } from './voices-Cl4ygZHV.js';
+import { N as NexraError, P as PublicErrorFields } from './errors-DZlSwyv8.js';
+export { A as ApiErrorPayload, a as PublicError, b as PublicErrorContext } from './errors-DZlSwyv8.js';
+import { V as Voice, C as CreateVoiceRequest, a as VoiceCreation, A as AssetsClient, T as TasksClient, R as RunTaskOptions, b as RunResult, c as TaskResult } from './voices-2zWJXgCq.js';
+export { d as CreateTaskOptions, e as CreateTaskRequest, f as RequestDetails, g as TASK_STATUSES, h as TaskCost, i as TaskError, j as TaskEvent, k as TaskEventType, l as TaskListParams, m as TaskPage, n as TaskProgress, o as TaskReceipt, p as TaskStatus, q as TaskTiming, r as TaskUsage, s as TaskWebhookConfig, t as TerminalTaskStatus, u as VerifyWebhookOptions, W as WaitTaskOptions, v as WatchTaskOptions, w as isTerminalTaskStatus, x as verifyWebhook } from './voices-2zWJXgCq.js';
 import { CatalogClient } from './catalog.js';
 export { formatModelDisplayName, getModelSpec, listModelSpecs } from './catalog.js';
 export { ceilDecimal, multiplyDecimal } from './decimal.js';

package/dist/index.js

@@ -20,13 +20,13 @@ import {
   projectMediaGeometry,
   queryString,
   sleep
-} from "./chunk-3CF6PDT3.js";
+} from "./chunk-MNRDMPUS.js";
 import {
   MEDIA_KINDS,
   TASK_STATUSES,
   createTaskRequest,
   isTerminalTaskStatus
-} from "./chunk-DKQZWIQ7.js";
+} from "./chunk-QBW7OCT3.js";
 
 // src/assets.ts
 var AssetsClient = class {

package/dist/language.d.ts

@@ -1,9 +1,31 @@
-import { LanguageModelV4 } from '@ai-sdk/provider';
+import { APICallError, LanguageModelV4 } from '@ai-sdk/provider';
 import { NexraLanguageProtocol } from './catalog.js';
 export { NexraLanguageModelBinding } from './catalog.js';
 import { F as FetchLike } from './media-geometry-DAVFGry1.js';
+import { N as NexraError } from './errors-DZlSwyv8.js';
 import './json-Cz0MkWQn.js';
 
+type NativeErrorContext = {
+    url: string;
+    statusCode?: number;
+    headers?: HeadersInit;
+    body: unknown;
+    responseBody?: string;
+    acceptLanguage?: string | null;
+};
+/** Native response IDs may belong to the provider; only the classification header is platform-owned. */
+declare class NexraNativeError extends APICallError {
+    readonly nexraError?: NexraError;
+    constructor(context: NativeErrorContext);
+    get code(): string | undefined;
+    get status(): number | undefined;
+}
+/** Reusable by native provider factories; native request bodies and successful response bytes remain untouched. */
+declare function createNexraNativeFetch(options?: {
+    fetch?: FetchLike;
+    headers?: HeadersInit;
+}): FetchLike;
+
 type NexraLanguageModelOptions = {
     apiKey: string;
     baseUrl?: string;
@@ -13,4 +35,4 @@ type NexraLanguageModelOptions = {
 };
 declare function createNexraLanguageModel(modelId: string, options: NexraLanguageModelOptions): LanguageModelV4;
 
-export { type NexraLanguageModelOptions, NexraLanguageProtocol, createNexraLanguageModel };
+export { type NexraLanguageModelOptions, NexraLanguageProtocol, NexraNativeError, createNexraLanguageModel, createNexraNativeFetch };

package/dist/language.js

@@ -1,12 +1,17 @@
 import {
   HttpTransport,
   SDK_VERSION,
+  createServerSentEventFrameDecoder,
   getLanguageModelBinding,
   jsonBody,
   parseServerSentEvents,
   resolveNexraLanguageReasoning
-} from "./chunk-3CF6PDT3.js";
-import "./chunk-DKQZWIQ7.js";
+} from "./chunk-MNRDMPUS.js";
+import {
+  isPublicErrorCode,
+  publicErrorMessage,
+  resolvePublicErrorLocale
+} from "./chunk-QBW7OCT3.js";
 
 // src/language/index.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
@@ -194,6 +199,131 @@ function chatRequest(binding, options, stream) {
   };
 }
 
+// src/language/native-errors.ts
+import { APICallError } from "@ai-sdk/provider";
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+var NexraNativeError = class extends APICallError {
+  nexraError;
+  constructor(context) {
+    const headers = new Headers(context.headers);
+    const code = headers.get("x-nexra-error-code");
+    const locale = resolvePublicErrorLocale(context.acceptLanguage ?? headers.get("content-language"));
+    const nexraError = code && isPublicErrorCode(code) ? { code, message: publicErrorMessage(code, locale) } : void 0;
+    const body = record(context.body);
+    const originalMessage = record(body.error).message ?? record(record(body.response).error).message ?? body.message;
+    const message = nexraError?.message ?? (typeof originalMessage === "string" ? originalMessage : typeof context.body === "string" ? context.body : "The native model request failed.");
+    super({
+      message,
+      url: context.url,
+      requestBodyValues: void 0,
+      statusCode: context.statusCode,
+      responseHeaders: Object.fromEntries(headers),
+      responseBody: context.responseBody,
+      data: context.body
+    });
+    this.name = "NexraNativeError";
+    this.nexraError = nexraError;
+  }
+  get code() {
+    return this.nexraError?.code;
+  }
+  get status() {
+    return this.statusCode;
+  }
+};
+function createNexraNativeFetch(options = {}) {
+  const fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+  return async (input, init) => {
+    const headers = new Headers(options.headers);
+    if (input instanceof Request) input.headers.forEach((value, key) => headers.set(key, value));
+    new Headers(init?.headers).forEach((value, key) => headers.set(key, value));
+    const response = await fetch(input, { ...init, headers });
+    const context = {
+      url: input instanceof Request ? input.url : String(input),
+      statusCode: response.status,
+      headers: response.headers,
+      acceptLanguage: headers.get("accept-language")
+    };
+    const eventStream = response.headers.get("content-type")?.includes("text/event-stream");
+    if (response.ok && (eventStream || !response.headers.has("x-nexra-error-code"))) return guardNativeErrorFrames(response, context);
+    const text = await response.text();
+    let body = text;
+    try {
+      body = JSON.parse(text);
+    } catch {
+    }
+    throw new NexraNativeError({ ...context, body, responseBody: text });
+  };
+}
+function guardNativeErrorFrames(response, context) {
+  if (!response.body || !response.headers.get("content-type")?.includes("text/event-stream")) return response;
+  const decode = createServerSentEventFrameDecoder();
+  const reader = response.body.getReader();
+  const pending = [];
+  let finished = false;
+  let released = false;
+  let failure;
+  const release = () => {
+    if (!released) {
+      reader.releaseLock();
+      released = true;
+    }
+  };
+  const inspect = (event) => {
+    if (!event) return;
+    let body;
+    try {
+      body = JSON.parse(event.data);
+    } catch {
+      return event.event === "error" ? new NexraNativeError({ ...context, body: event.data, responseBody: event.data }) : void 0;
+    }
+    const payload = record(body);
+    if (event.event === "error" || payload.type === "error" || payload.type === "response.failed" || payload.error) {
+      return new NexraNativeError({ ...context, body, responseBody: event.data });
+    }
+  };
+  const stream = new ReadableStream({
+    async pull(controller) {
+      try {
+        while (!pending.length && !finished) {
+          const { value, done } = await reader.read();
+          for (const frame of decode(value, done)) {
+            failure = inspect(frame.event);
+            if (failure) {
+              finished = true;
+              await reader.cancel(failure).catch(() => void 0);
+              release();
+              break;
+            }
+            pending.push(frame.bytes);
+          }
+          if (done) {
+            finished = true;
+            release();
+          }
+        }
+        if (pending.length) controller.enqueue(pending.shift());
+        else if (failure) controller.error(failure);
+        else controller.close();
+      } catch (error) {
+        await reader.cancel(error).catch(() => void 0);
+        release();
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      pending.length = 0;
+      if (!released) {
+        await reader.cancel(reason);
+        release();
+      }
+    }
+  }, { highWaterMark: 0 });
+  return new Response(stream, { status: response.status, statusText: response.statusText, headers: response.headers });
+}
+
 // src/language/chat-model.ts
 function object2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -222,8 +352,14 @@ function finishReason(raw) {
 function invalid(data, message) {
   throw new InvalidResponseDataError({ data, message });
 }
-function choices(payload) {
-  if (payload.error) invalid(payload.error, "Nexra returned a language error");
+function choices(payload, response, headers) {
+  if (payload.error) throw new NexraNativeError({
+    url: response.url,
+    statusCode: response.status,
+    headers: response.headers,
+    body: payload,
+    acceptLanguage: headers?.["accept-language"] ?? headers?.["Accept-Language"]
+  });
   if (!Array.isArray(payload.choices)) invalid(payload, "Chat Completions response is missing choices");
   if (payload.choices.length > 1) invalid(payload, "Multiple Chat Completions choices are unsupported");
   return payload.choices.map(object2);
@@ -241,7 +377,7 @@ function createChatLanguageModel(binding, transport) {
       const body = chatRequest(binding, options, false);
       const response = await transport.response("/chat/completions", { method: "POST", ...jsonBody(body), headers: combineHeaders(options), signal: options.abortSignal }, { retryable: false });
       const payload = object2(await response.json());
-      const choice = choices(payload)[0];
+      const choice = choices(payload, response, options.headers)[0];
       if (!choice || typeof choice.finish_reason !== "string") invalid(payload, "Chat Completions response is incomplete");
       const message = object2(choice.message);
       const content = [];
@@ -305,7 +441,7 @@ function createChatLanguageModel(binding, transport) {
                 controller.enqueue({ type: "response-metadata", id: typeof payload.id === "string" ? payload.id : void 0, modelId: typeof payload.model === "string" ? payload.model : void 0 });
                 metadataSent = true;
               }
-              const choice = choices(payload)[0];
+              const choice = choices(payload, response, options.headers)[0];
               if (payload.usage) rawUsage = payload.usage;
               if (!choice) continue;
               if (choice.finish_reason != null) reason = choice.finish_reason;
@@ -389,26 +525,45 @@ function createNexraLanguageModel(modelId, options) {
   const binding = getLanguageModelBinding(modelId, options);
   const apiKey = options.apiKey.trim();
   if (!apiKey) throw new Error("Nexra language model requires an API key");
+  const fetch = createNexraNativeFetch(options);
   const transport = new HttpTransport({ ...options, baseUrl: options.baseUrl?.trim().replace(/\/+$/, ""), apiKey, maxRetries: 0 });
   const root = transport.baseUrl.replace(/\/(?:v1|v1beta)(?:\/models)?$/, "");
-  if (binding.endpoint.protocol === "openai-chat-completions") return createChatLanguageModel(binding, new HttpTransport({ ...options, baseUrl: `${root}/v1`, apiKey, maxRetries: 0 }));
+  if (binding.endpoint.protocol === "openai-chat-completions") return createChatLanguageModel(binding, new HttpTransport({ ...options, fetch, baseUrl: `${root}/v1`, apiKey, maxRetries: 0 }));
   const headers = new Headers(options.headers);
   if (!headers.has("authorization")) headers.set("authorization", `Bearer ${apiKey}`);
   headers.set("x-nexra-sdk", `typescript/${SDK_VERSION}`);
-  const common = { apiKey, headers: Object.fromEntries(headers), fetch: options.fetch };
+  const common = { apiKey, headers: Object.fromEntries(headers), fetch };
   let model;
   if (binding.endpoint.protocol === "gemini-generate-content") {
     model = createGoogleGenerativeAI({ ...common, name: "nexra.google", baseURL: `${root}/v1beta/models` })(binding.spec.id);
   } else if (binding.endpoint.protocol === "openai-responses") {
-    model = createOpenAI({ ...common, name: "nexra.openai", baseURL: `${root}/v1` }).responses(binding.spec.id);
+    const responsesFetch = (input, init) => fetch(
+      input,
+      typeof init?.body === "string" ? { ...init, body: JSON.stringify(explicitResponsesMessages(JSON.parse(init.body))) } : init
+    );
+    model = createOpenAI({ ...common, name: "nexra.openai", baseURL: `${root}/v1`, fetch: responsesFetch }).responses(binding.spec.id);
   } else {
     model = createAnthropic({ ...common, name: "nexra.anthropic", baseURL: `${root}/v1` })(binding.spec.id);
   }
-  return withNativeUsage(model, binding);
+  return withNativeContract(model, binding);
 }
 function object3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+function explicitResponsesMessages(value) {
+  const body = object3(value);
+  if (!Array.isArray(body.input)) return value;
+  return { ...body, input: body.input.map((value2) => {
+    const item = object3(value2);
+    return item.type === void 0 && ["system", "developer", "user", "assistant"].includes(String(item.role)) && (typeof item.content === "string" || Array.isArray(item.content)) ? { ...item, type: "message" } : value2;
+  }) };
+}
+function nativeRequest(protocol, request, stream = false) {
+  return protocol === "openai-responses" && request ? {
+    ...request,
+    body: explicitResponsesMessages(stream ? { ...object3(request.body), stream: true } : request.body)
+  } : request;
+}
 function prepare(options, binding, stream) {
   options = prepareLanguageReasoning(options, binding);
   const properties = object3(binding.endpoint.inputSchema?.properties);
@@ -472,7 +627,7 @@ function mergeRecords(previous, next) {
   }
   return merged;
 }
-function withNativeUsage(model, binding) {
+function withNativeContract(model, binding) {
   return {
     specificationVersion: "v4",
     provider: model.provider,
@@ -481,7 +636,11 @@ function withNativeUsage(model, binding) {
     async doGenerate(options) {
       const result = await model.doGenerate(prepare(options, binding, false));
       const raw = nativeUsage(binding.endpoint.protocol, result.response?.body);
-      return raw ? { ...result, usage: { ...result.usage, raw } } : result;
+      return {
+        ...result,
+        request: nativeRequest(binding.endpoint.protocol, result.request),
+        ...raw ? { usage: { ...result.usage, raw } } : {}
+      };
     },
     async doStream(options) {
       if (!binding.supportsStreaming) throw new Error(`Nexra model does not support streaming: ${binding.spec.id}`);
@@ -492,38 +651,44 @@ function withNativeUsage(model, binding) {
       let finish;
       const textMetadata = /* @__PURE__ */ new Map();
       const reasoningMetadata2 = /* @__PURE__ */ new Map();
-      return { ...result, stream: result.stream.pipeThrough(new TransformStream({
-        transform(part, controller) {
-          if (part.type === "raw") {
-            const payload = object3(part.rawValue);
-            terminal ||= binding.endpoint.protocol === "anthropic-messages" ? payload.type === "message_stop" : binding.endpoint.protocol === "openai-responses" ? ["response.completed", "response.incomplete", "response.failed"].includes(String(payload.type)) : Array.isArray(payload.candidates) && payload.candidates.some((candidate) => typeof object3(candidate).finishReason === "string");
-            const next = nativeUsage(binding.endpoint.protocol, part.rawValue);
-            if (next) raw = mergeRecords(raw, next);
-            if (options.includeRawChunks) controller.enqueue(part);
-          } else if (part.type === "finish") finish = part;
-          else {
-            if (part.type === "error") failed = true;
-            if (part.type === "text-start" || part.type === "text-delta" || part.type === "text-end" || part.type === "reasoning-start" || part.type === "reasoning-delta" || part.type === "reasoning-end") {
-              const metadata = part.type.startsWith("text-") ? textMetadata : reasoningMetadata2;
-              if (part.providerMetadata) metadata.set(part.id, mergeRecords(metadata.get(part.id), part.providerMetadata));
-              if (part.type === "text-end" || part.type === "reasoning-end") {
-                const retained = metadata.get(part.id);
-                metadata.delete(part.id);
-                if (retained) part = { ...part, providerMetadata: retained };
+      return {
+        ...result,
+        request: nativeRequest(binding.endpoint.protocol, result.request, true),
+        stream: result.stream.pipeThrough(new TransformStream({
+          transform(part, controller) {
+            if (part.type === "raw") {
+              const payload = object3(part.rawValue);
+              terminal ||= binding.endpoint.protocol === "anthropic-messages" ? payload.type === "message_stop" : binding.endpoint.protocol === "openai-responses" ? ["response.completed", "response.incomplete", "response.failed"].includes(String(payload.type)) : Array.isArray(payload.candidates) && payload.candidates.some((candidate) => typeof object3(candidate).finishReason === "string");
+              const next = nativeUsage(binding.endpoint.protocol, part.rawValue);
+              if (next) raw = mergeRecords(raw, next);
+              if (options.includeRawChunks) controller.enqueue(part);
+            } else if (part.type === "finish") finish = part;
+            else {
+              if (part.type === "error") failed = true;
+              if (part.type === "text-start" || part.type === "text-delta" || part.type === "text-end" || part.type === "reasoning-start" || part.type === "reasoning-delta" || part.type === "reasoning-end") {
+                const metadata = part.type.startsWith("text-") ? textMetadata : reasoningMetadata2;
+                if (part.providerMetadata) metadata.set(part.id, mergeRecords(metadata.get(part.id), part.providerMetadata));
+                if (part.type === "text-end" || part.type === "reasoning-end") {
+                  const retained = metadata.get(part.id);
+                  metadata.delete(part.id);
+                  if (retained) part = { ...part, providerMetadata: retained };
+                }
               }
+              controller.enqueue(part);
             }
-            controller.enqueue(part);
+          },
+          flush(controller) {
+            if (failed) return;
+            if (!terminal || !finish) controller.enqueue({ type: "error", error: new Error(`Nexra ${binding.endpoint.protocol} stream ended before its terminal response`) });
+            else controller.enqueue(raw ? { ...finish, usage: { ...finish.usage, raw } } : finish);
           }
-        },
-        flush(controller) {
-          if (failed) return;
-          if (!terminal || !finish) controller.enqueue({ type: "error", error: new Error(`Nexra ${binding.endpoint.protocol} stream ended before its terminal response`) });
-          else controller.enqueue(raw ? { ...finish, usage: { ...finish.usage, raw } } : finish);
-        }
-      })) };
+        }))
+      };
     }
   };
 }
 export {
-  createNexraLanguageModel
+  NexraNativeError,
+  createNexraLanguageModel,
+  createNexraNativeFetch
 };

package/dist/media.js

@@ -10,7 +10,7 @@ import {
   nexraMediaInputSchema,
   nexraMediaInputSchemaForMode,
   nexraMediaOperationForMode
-} from "./chunk-DKQZWIQ7.js";
+} from "./chunk-QBW7OCT3.js";
 export {
   NEXRA_GENERATION_OPERATIONS,
   NEXRA_MEDIA_API_VERSION,

package/dist/types.d.ts

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

package/dist/{voices-Cl4ygZHV.d.ts → voices-2zWJXgCq.d.ts}

@@ -1,33 +1,7 @@
 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;
+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-DZlSwyv8.js';
 
 declare class AssetsClient {
     private readonly transport;
@@ -342,4 +316,4 @@ type VoiceCreation = Readonly<{
     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 };
+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,6 +1,6 @@
 {
   "name": "@byte_fluffy/nexra-sdk",
-  "version": "0.1.0-alpha.30",
+  "version": "0.1.0-alpha.32",
   "type": "module",
   "types": "./dist/index.d.ts",
   "sideEffects": false,