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

package/dist/language.js

@@ -6,17 +6,18 @@ import {
   jsonBody,
   parseServerSentEvents,
   resolveNexraLanguageReasoning
-} from "./chunk-V3KBU3J5.js";
+} from "./chunk-MLDFBO2A.js";
 import {
   isPublicErrorCode,
   publicErrorMessage,
   resolvePublicErrorLocale
-} from "./chunk-LEZWVFQH.js";
+} from "./chunk-IOGCXMW3.js";
 
 // src/language/index.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { getModelCapabilities as getAnthropicModelCapabilities } from "@ai-sdk/anthropic/internal";
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
 import { mapReasoningToProviderBudget } from "@ai-sdk/provider-utils";
 
 // src/language/chat-model.ts
@@ -71,30 +72,6 @@ function nativeOptions(part) {
   const value = part.providerOptions?.nexra;
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function nativeMediaUrlPatterns(binding, kind) {
-  const field = kind === "audio" ? "input_audio" : `${kind}_url`;
-  const messages2 = asObject(asObject(binding.endpoint.inputSchema?.properties).messages);
-  const content = asObject(asObject(asObject(messages2.items).properties).content);
-  const patterns = /* @__PURE__ */ new Set();
-  const visit = (value) => {
-    if (Array.isArray(value)) {
-      value.forEach(visit);
-      return;
-    }
-    const node = asObject(value);
-    const properties = asObject(node.properties);
-    if (asObject(properties.type).const === field) {
-      const url = asObject(asObject(asObject(properties[field]).properties).url);
-      if (typeof url.pattern === "string") patterns.add(url.pattern);
-    }
-    for (const child of Object.values(node)) if (child && typeof child === "object") visit(child);
-  };
-  visit(content);
-  return patterns.size ? [...patterns].map((pattern) => new RegExp(pattern)) : void 0;
-}
-function chatSupportedUrls(binding) {
-  return Object.fromEntries(binding.spec.capabilities.inputModalities.filter((kind) => ["image", "audio", "video"].includes(kind)).map((kind) => [`${kind}/*`, nativeMediaUrlPatterns(binding, kind) ?? [/^https?:\/\//]]));
-}
 function filePart(part, binding) {
   const kind = part.mediaType.split("/")[0];
   if (["image", "audio", "video"].includes(kind) && !binding.spec.capabilities.inputModalities.includes(kind)) {
@@ -106,10 +83,6 @@ function filePart(part, binding) {
     throw new UnsupportedFunctionalityError({ functionality: "file reference without a Nexra reference" });
   }
   const url = part.data.type === "url" ? part.data.url.toString() : void 0;
-  const patterns = nativeMediaUrlPatterns(binding, kind);
-  if (url && patterns && !patterns.some((pattern) => pattern.test(url))) {
-    throw new UnsupportedFunctionalityError({ functionality: `native media URL for ${binding.spec.id}; provide bytes or a matching data URL` });
-  }
   const data = part.data.type === "data" ? convertToBase64(part.data.data) : void 0;
   if (kind === "image" || kind === "video") {
     const field = kind === "image" ? "image_url" : "video_url";
@@ -268,6 +241,40 @@ var NexraNativeError = class extends APICallError {
     return this.statusCode;
   }
 };
+function restoreNativeError(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current instanceof Error && !seen.has(current)) {
+    if (current instanceof NexraNativeError) return current;
+    seen.add(current);
+    current = current.cause;
+  }
+  return error;
+}
+function restoreNativeStreamErrors(stream) {
+  const reader = stream.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { value, done } = await reader.read();
+        if (done) {
+          reader.releaseLock();
+          controller.close();
+        } else controller.enqueue(value);
+      } catch (error) {
+        reader.releaseLock();
+        controller.error(restoreNativeError(error));
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  }, { highWaterMark: 0 });
+}
 function createNexraNativeFetch(options = {}) {
   const fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
   return async (input, init) => {
@@ -407,7 +414,7 @@ function createChatLanguageModel(binding, transport) {
     specificationVersion: "v4",
     provider: "nexra.chat",
     modelId: binding.spec.id,
-    supportedUrls: chatSupportedUrls(binding),
+    supportedUrls: Object.fromEntries(binding.spec.capabilities.inputModalities.filter((kind) => ["image", "audio", "video"].includes(kind)).map((kind) => [`${kind}/*`, [/^https?:\/\//]])),
     async doGenerate(options) {
       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 });
@@ -555,190 +562,6 @@ function combineHeaders(options) {
   return headers;
 }
 
-// src/language/responses-model.ts
-import { createOpenAI } from "@ai-sdk/openai";
-function object3(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function isUnpositionedCitation(value) {
-  const node = object3(value);
-  return node.type === "url_citation" && typeof node.url === "string" && !Object.hasOwn(node, "start_index") && !Object.hasOwn(node, "end_index");
-}
-function project(value) {
-  if (Array.isArray(value)) return value.map(project);
-  if (!value || typeof value !== "object") return value;
-  const projected = Object.fromEntries(Object.entries(value).map(([key, item]) => [
-    key,
-    key === "annotations" && Array.isArray(item) ? item.filter((annotation) => !isUnpositionedCitation(annotation)).map(project) : project(item)
-  ]));
-  if (projected.type === "output_text" && projected.annotations === void 0) projected.annotations = [];
-  return projected;
-}
-function citations(value) {
-  if (Array.isArray(value)) return value.flatMap(citations);
-  const node = object3(value);
-  if (isUnpositionedCitation(node)) return [node];
-  return Object.values(node).flatMap((item) => item && typeof item === "object" ? citations(item) : []);
-}
-function nativeSearchBody(value, call) {
-  const extension = call.providerOptions?.nexra?.web_search;
-  if (extension === void 0) return value;
-  if (!extension || typeof extension !== "object" || Array.isArray(extension)) throw new Error("Nexra web_search options must be a native tool object");
-  const body = object3(value);
-  if (!Array.isArray(body.tools) || !body.tools.some((tool) => object3(tool).type === "web_search")) {
-    throw new Error("Nexra web_search options require an enabled web_search tool");
-  }
-  return { ...body, tools: body.tools.map((tool) => object3(tool).type === "web_search" ? { ...object3(tool), ...extension, type: "web_search" } : tool) };
-}
-function nativeSearchRequest(init, call) {
-  return typeof init?.body === "string" ? { ...init, body: JSON.stringify(nativeSearchBody(JSON.parse(init.body), call)) } : init;
-}
-function createResponsesLanguageModel(options) {
-  const factory = (fetch) => createOpenAI({
-    apiKey: options.apiKey,
-    headers: options.headers,
-    name: "nexra.openai",
-    baseURL: options.baseUrl,
-    fetch
-  }).responses(options.modelId);
-  const base = factory(options.fetch);
-  return {
-    specificationVersion: "v4",
-    provider: base.provider,
-    modelId: base.modelId,
-    supportedUrls: base.supportedUrls,
-    async doGenerate(call) {
-      let original;
-      const fetch = async (input, init) => {
-        const response = await options.fetch(input, nativeSearchRequest(init, call));
-        if (!response.ok || !response.headers.get("content-type")?.includes("application/json")) return response;
-        const text = await response.text();
-        try {
-          original = JSON.parse(text);
-        } catch {
-          return new Response(text, response);
-        }
-        return new Response(JSON.stringify(project(original)), response);
-      };
-      const result = await factory(fetch).doGenerate(call);
-      const seen = /* @__PURE__ */ new Set();
-      const sources = sourceParts(original, seen);
-      return {
-        ...result,
-        content: [...result.content, ...sources],
-        request: result.request ? { ...result.request, body: nativeSearchBody(result.request.body, call) } : void 0,
-        response: { ...result.response, ...original === void 0 ? {} : { body: original } }
-      };
-    },
-    async doStream(call) {
-      const entries = /* @__PURE__ */ new Map();
-      let before = [];
-      const canceled = new AbortController();
-      const fetch = async (input, init) => {
-        const response = await options.fetch(input, nativeSearchRequest(init, call));
-        if (!response.ok || !response.headers.get("content-type")?.includes("text/event-stream")) return response;
-        const signal = init?.signal ? AbortSignal.any([init.signal, canceled.signal]) : canceled.signal;
-        const iterator = parseServerSentEvents(response, { signal });
-        const encoder = new TextEncoder();
-        const body = new ReadableStream({
-          async pull(controller) {
-            try {
-              while (true) {
-                const next = await iterator.next();
-                if (next.done) {
-                  controller.close();
-                  return;
-                }
-                const frame = next.value;
-                let native;
-                try {
-                  native = JSON.parse(frame.data);
-                } catch {
-                  controller.enqueue(encoder.encode(`${frame.event ? `event: ${frame.event}
-` : ""}data: ${frame.data}
-
-`));
-                  return;
-                }
-                if (object3(native).type === "response.output_text.annotation.added" && isUnpositionedCitation(object3(native).annotation)) {
-                  before.push(native);
-                  continue;
-                }
-                const projected = project(native);
-                const key = JSON.stringify(projected);
-                const queue = entries.get(key) ?? [];
-                queue.push({ original: native, before });
-                before = [];
-                entries.set(key, queue);
-                controller.enqueue(encoder.encode(`${frame.id ? `id: ${frame.id}
-` : ""}${frame.event ? `event: ${frame.event}
-` : ""}${frame.retry !== void 0 ? `retry: ${frame.retry}
-` : ""}data: ${key}
-
-`));
-                return;
-              }
-            } catch (error) {
-              controller.error(error);
-              await iterator.return(void 0);
-            }
-          },
-          async cancel(reason) {
-            canceled.abort(reason);
-            await iterator.return(void 0);
-          }
-        });
-        return new Response(body, response);
-      };
-      const result = await factory(fetch).doStream({ ...call, includeRawChunks: true });
-      const seen = /* @__PURE__ */ new Set();
-      return {
-        ...result,
-        request: result.request ? { ...result.request, body: nativeSearchBody(result.request.body, call) } : void 0,
-        stream: result.stream.pipeThrough(new TransformStream({
-          transform(part, controller) {
-            if (part.type !== "raw") {
-              controller.enqueue(part);
-              return;
-            }
-            const key = JSON.stringify(part.rawValue);
-            const queue = entries.get(key);
-            const entry = queue?.shift();
-            if (queue?.length === 0) entries.delete(key);
-            const native = entry?.original ?? part.rawValue;
-            for (const frame of [...entry?.before ?? [], native]) {
-              for (const source of sourceParts(frame, seen)) controller.enqueue(source);
-              if (call.includeRawChunks) controller.enqueue({ type: "raw", rawValue: frame });
-            }
-          },
-          flush(controller) {
-            for (const frame of before) {
-              for (const source of sourceParts(frame, seen)) controller.enqueue(source);
-              if (call.includeRawChunks) controller.enqueue({ type: "raw", rawValue: frame });
-            }
-            entries.clear();
-            before = [];
-          }
-        }))
-      };
-    }
-  };
-}
-function sourceParts(value, seen) {
-  return citations(value).flatMap((annotation) => {
-    const key = JSON.stringify([annotation.url, annotation.title]);
-    if (seen.has(key)) return [];
-    seen.add(key);
-    return [{
-      type: "source",
-      sourceType: "url",
-      id: `native-source-${seen.size}`,
-      url: annotation.url,
-      ...typeof annotation.title === "string" ? { title: annotation.title } : {}
-    }];
-  });
-}
-
 // src/language/index.ts
 function createNexraLanguageModel(modelId, options) {
   const binding = getLanguageModelBinding(modelId, options);
@@ -764,30 +587,30 @@ function createNexraLanguageModel(modelId, options) {
       input,
       typeof init?.body === "string" ? { ...init, body: JSON.stringify(explicitResponsesMessages(JSON.parse(init.body))) } : init
     );
-    model = createResponsesLanguageModel({ modelId: binding.spec.id, apiKey, headers: common.headers, baseUrl: `${root}/v1`, fetch: responsesFetch });
+    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 withNativeContract(model, binding);
 }
-function object4(value) {
+function object3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function explicitResponsesMessages(value) {
-  const body = object4(value);
+  const body = object3(value);
   if (!Array.isArray(body.input)) return value;
   return { ...body, input: body.input.map((value2) => {
-    const item = object4(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 googleNativeBody(binding, value) {
-  const body = object4(value);
-  const config = object4(body.generationConfig);
-  const thinking = object4(config.thinkingConfig);
-  const fields = object4(binding.endpoint.inputSchema?.properties);
-  const nativeThinking = object4(object4(object4(object4(fields.generationConfig).properties).thinkingConfig).properties);
-  const values = object4(nativeThinking.thinkingLevel).enum;
+  const body = object3(value);
+  const config = object3(body.generationConfig);
+  const thinking = object3(config.thinkingConfig);
+  const fields = object3(binding.endpoint.inputSchema?.properties);
+  const nativeThinking = object3(object3(object3(object3(fields.generationConfig).properties).thinkingConfig).properties);
+  const values = object3(nativeThinking.thinkingLevel).enum;
   const level = typeof thinking.thinkingLevel === "string" && Array.isArray(values) ? values.find((value2) => typeof value2 === "string" && value2.toLowerCase() === String(thinking.thinkingLevel).toLowerCase()) : void 0;
   return level === void 0 || level === thinking.thinkingLevel ? value : { ...body, generationConfig: { ...config, thinkingConfig: { ...thinking, thinkingLevel: level } } };
 }
@@ -795,29 +618,25 @@ function nativeRequest(binding, request, stream = false) {
   if (!request) return request;
   return binding.endpoint.protocol === "openai-responses" ? {
     ...request,
-    body: explicitResponsesMessages(stream ? { ...object4(request.body), stream: true } : request.body)
+    body: explicitResponsesMessages(stream ? { ...object3(request.body), stream: true } : request.body)
   } : binding.endpoint.protocol === "gemini-generate-content" ? { ...request, body: googleNativeBody(binding, request.body) } : request;
 }
 function prepare(options, binding, stream) {
   binding = getLanguageModelBinding(binding.spec.id, { protocol: binding.endpoint.protocol, stream });
   options = prepareLanguageReasoning(options, binding);
-  const properties = object4(binding.endpoint.inputSchema?.properties);
-  const choices2 = object4(properties.tool_choice).enum;
-  if (options.toolChoice && Array.isArray(choices2) && !choices2.includes(options.toolChoice.type)) {
-    throw new Error(`Nexra tool choice is outside the native contract for ${binding.spec.id}: ${options.toolChoice.type}`);
-  }
-  const tokenField = object4(binding.endpoint.protocol === "gemini-generate-content" ? object4(object4(properties.generationConfig).properties).maxOutputTokens : properties.max_output_tokens ?? properties.max_tokens);
+  const properties = object3(binding.endpoint.inputSchema?.properties);
+  const tokenField = object3(binding.endpoint.protocol === "gemini-generate-content" ? object3(object3(properties.generationConfig).properties).maxOutputTokens : properties.max_output_tokens ?? properties.max_tokens);
   if (options.maxOutputTokens !== void 0 && (!Number.isInteger(options.maxOutputTokens) || typeof tokenField.minimum === "number" && options.maxOutputTokens < tokenField.minimum || binding.maxOutputTokens !== void 0 && options.maxOutputTokens > binding.maxOutputTokens)) throw new Error(`Nexra output token limit is outside the native contract for ${binding.spec.id}`);
   if (options.tools?.length && !binding.endpoint.capabilities.includes("tool_call")) throw new Error(`Nexra model does not support tools: ${binding.spec.id}`);
   const providerOptions = { ...options.providerOptions };
   if (binding.endpoint.protocol === "openai-responses") {
-    const current = object4(providerOptions.openai);
+    const current = object3(providerOptions.openai);
     providerOptions.openai = {
       store: false,
       forceReasoning: binding.endpoint.capabilities.includes("reasoning"),
       ...current
     };
-    const reasoning = object4(providerOptions.openai);
+    const reasoning = object3(providerOptions.openai);
     if (reasoning.forceReasoning === true && (options.temperature !== void 0 || options.topP !== void 0)) {
       throw new Error(`Nexra Responses adapter cannot preserve explicit sampling parameters with reasoning for ${binding.spec.id}`);
     }
@@ -827,8 +646,8 @@ function prepare(options, binding, stream) {
   }
   if (binding.endpoint.protocol === "anthropic-messages") {
     const capabilities = getAnthropicModelCapabilities(binding.spec.id);
-    const native = { ...object4(providerOptions.anthropic), ...object4(providerOptions.nexra) };
-    let thinking = object4(native.thinking);
+    const native = { ...object3(providerOptions.anthropic), ...object3(providerOptions.nexra) };
+    let thinking = object3(native.thinking);
     if (!native.thinking && native.effort == null && options.reasoning && options.reasoning !== "provider-default") {
       thinking = options.reasoning === "none" ? { type: "disabled" } : capabilities.supportsAdaptiveThinking ? { type: "adaptive" } : { type: "enabled", budgetTokens: mapReasoningToProviderBudget({
         reasoning: options.reasoning,
@@ -849,20 +668,20 @@ function prepare(options, binding, stream) {
     options = { ...options, maxOutputTokens: visible };
   }
   if (stream && binding.endpoint.protocol === "gemini-generate-content" && binding.endpoint.capabilities.includes("reasoning")) {
-    const google = object4(providerOptions.google);
-    providerOptions.google = { ...google, thinkingConfig: { includeThoughts: true, ...object4(google.thinkingConfig) } };
+    const google = object3(providerOptions.google);
+    providerOptions.google = { ...google, thinkingConfig: { includeThoughts: true, ...object3(google.thinkingConfig) } };
   }
   return { ...options, providerOptions };
 }
 function nativeUsage(protocol, value) {
-  const payload = object4(value);
-  const raw = protocol === "gemini-generate-content" ? payload.usageMetadata : protocol === "anthropic-messages" ? object4(payload.message).usage ?? payload.usage : object4(payload.response).usage ?? payload.usage;
+  const payload = object3(value);
+  const raw = protocol === "gemini-generate-content" ? payload.usageMetadata : protocol === "anthropic-messages" ? object3(payload.message).usage ?? payload.usage : object3(payload.response).usage ?? payload.usage;
   return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : void 0;
 }
 function mergeRecords(previous, next) {
   const merged = { ...previous, ...next };
   for (const [key, value] of Object.entries(next)) {
-    if (value && typeof value === "object" && !Array.isArray(value)) merged[key] = { ...object4(previous?.[key]), ...object4(value) };
+    if (value && typeof value === "object" && !Array.isArray(value)) merged[key] = { ...object3(previous?.[key]), ...object3(value) };
   }
   return merged;
 }
@@ -873,7 +692,9 @@ function withNativeContract(model, binding) {
     modelId: model.modelId,
     supportedUrls: model.supportedUrls,
     async doGenerate(options) {
-      const result = await model.doGenerate(prepare(options, binding, false));
+      const result = await Promise.resolve(model.doGenerate(prepare(options, binding, false))).catch((error) => {
+        throw restoreNativeError(error);
+      });
       const raw = nativeUsage(binding.endpoint.protocol, result.response?.body);
       return {
         ...result,
@@ -883,7 +704,9 @@ function withNativeContract(model, binding) {
     },
     async doStream(options) {
       if (!binding.supportsStreaming) throw new Error(`Nexra model does not support streaming: ${binding.spec.id}`);
-      const result = await model.doStream({ ...prepare(options, binding, true), includeRawChunks: true });
+      const result = await Promise.resolve(model.doStream({ ...prepare(options, binding, true), includeRawChunks: true })).catch((error) => {
+        throw restoreNativeError(error);
+      });
       let raw;
       let terminal = false;
       let failed = false;
@@ -893,17 +716,20 @@ function withNativeContract(model, binding) {
       return {
         ...result,
         request: nativeRequest(binding, result.request, true),
-        stream: result.stream.pipeThrough(new TransformStream({
+        stream: restoreNativeStreamErrors(result.stream).pipeThrough(new TransformStream({
           transform(part, controller) {
             if (part.type === "raw") {
-              const payload = object4(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 object4(candidate).finishReason === "string");
+              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 === "error") {
+                failed = true;
+                part = { ...part, error: restoreNativeError(part.error) };
+              }
               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));

package/dist/{media-DzOxLGs-.d.ts → media-IaOdOMQC.d.ts}

@@ -1,4 +1,4 @@
-import { a as JsonObject } from './json-Cz0MkWQn.js';
+import { J as JsonObject } from './json-dnsDzk-s.js';
 
 declare const MEDIA_KINDS: readonly ["image", "video", "audio", "document", "archive", "other"];
 type MediaKind = (typeof MEDIA_KINDS)[number];
@@ -161,6 +161,8 @@ type NexraVideoGenerateInput = Readonly<{
     duration?: number;
     fit?: "contain" | "cover";
     title?: string;
+    /** Audio source for models that expose original-video sound. */
+    audio?: "native" | "original";
     generate_audio?: boolean;
     output_format?: string;
     seed?: number;
@@ -217,8 +219,18 @@ type NexraVideoDepthInput = Readonly<{
     resolution?: string;
 }>;
 type NexraVideoSegmentInput = Readonly<{
-    content: readonly [NexraVideoContentPart, NexraTextContentPart] | readonly [NexraTextContentPart, NexraVideoContentPart];
+    content: readonly [NexraVideoContentPart, NexraTextContentPart] | readonly [NexraTextContentPart, NexraVideoContentPart] | readonly [NexraVideoContentPart];
     resolution?: string;
+    mode?: "preview" | "track";
+    preview_time_ms?: number;
+    prompts?: readonly Readonly<{
+        time_ms: number;
+        points: readonly Readonly<{
+            x: number;
+            y: number;
+            label: 0 | 1;
+        }>[];
+    }>[];
 }>;
 type NexraMediaInputByOperation = Readonly<{
     "image.generate": NexraImageGenerateInput;

package/dist/{media-geometry-COln1N_2.d.ts → media-geometry-z7fXaDSN.d.ts}

@@ -1,4 +1,4 @@
-import { b as JsonPrimitive, a as JsonObject, J as JsonValue } from './json-Cz0MkWQn.js';
+import { a as JsonPrimitive, J as JsonObject, b as JsonValue } from './json-dnsDzk-s.js';
 
 declare const BILLING_METRICS: readonly ["requests", "input_tokens", "cached_input_tokens", "cache_write_tokens", "cache_creation_5m_input_tokens", "cache_creation_1h_input_tokens", "cache_read_input_tokens", "output_tokens", "input_characters", "input_utf8_bytes", "input_images", "output_images", "input_audio_seconds", "output_audio_seconds", "input_video_seconds", "output_video_seconds", "provider_credits", "web_search_requests"];
 type BillingMetric = (typeof BILLING_METRICS)[number];
@@ -90,6 +90,8 @@ interface TaskModelSummary {
         end: string;
         succeeded: number;
         total: number;
+        attemptSucceeded?: number;
+        attemptTotal?: number;
     }[];
     id: string;
     slug: string;
@@ -335,6 +337,7 @@ declare class HttpTransport {
     private readonly maxRetries;
     constructor(options: NexraClientOptions);
     url(path: string): string;
+    headers(additional?: HeadersInit): Headers;
     json<T>(path: string, init?: RequestInit, options?: RequestOptions): Promise<T>;
     response(path: string, init?: RequestInit, options?: RequestOptions): Promise<Response>;
 }
@@ -366,4 +369,4 @@ declare function decodeMediaGeometry(_inputSchema: JsonObject, input: JsonObject
 /** Normalize the SDK convenience alias `ratio` without producing Native fields. */
 declare function applyMediaGeometry(inputSchema: JsonObject, input: JsonObject): JsonObject;
 
-export { type ModelDateVersion as A, type ModelEndpointSummary as B, type CreateNexraQuoteRequest as C, type ModelModality as D, type ModelResourceOption as E, type FetchLike as F, type NexraDisplayQuoteBatchEntry as G, HttpTransport as H, type MediaGeometryField as M, type NexraCatalogChangeParams as N, type TaskModelSummary as T, type UnifiedMediaGeometry as U, type NexraCatalogChangePage as a, type NexraCatalogModelState as b, type NexraSalePriceList as c, type NexraQuote as d, type CreateNexraDisplayQuoteBatchRequest as e, type NexraDisplayQuoteBatch as f, type NexraCatalogRevision as g, type NexraModelSpec as h, type NexraModelEndpointSpec as i, type NexraModelSpecFilter as j, type MediaGeometryProjection as k, type NexraBillingCurrency as l, type NexraCatalogModelIdentity as m, type NexraModelOperation as n, type NexraSalePrice as o, type NexraSettlement as p, applyMediaGeometry as q, decodeMediaGeometry as r, encodeMediaGeometry as s, projectMediaGeometry as t, type ModelSearchParams as u, type TaskModel as v, type ModelSchema as w, type ModelResourceList as x, type NexraClientOptions as y, type ModelCapabilitySummary as z };
+export { type NexraCatalogChangeParams as A, type NexraCatalogChangePage as B, type CreateNexraDisplayQuoteBatchRequest as C, type NexraCatalogModelState as D, type NexraModelEndpointSpec as E, type FetchLike as F, type NexraCatalogModelIdentity as G, HttpTransport as H, type MediaGeometryField as M, type NexraClientOptions as N, type TaskModel as T, type UnifiedMediaGeometry as U, type CreateNexraQuoteRequest as a, type MediaGeometryProjection as b, type ModelCapabilitySummary as c, type ModelDateVersion as d, type ModelEndpointSummary as e, type ModelModality as f, type ModelResourceList as g, type ModelResourceOption as h, type ModelSchema as i, type ModelSearchParams as j, type NexraBillingCurrency as k, type NexraCatalogRevision as l, type NexraDisplayQuoteBatch as m, type NexraDisplayQuoteBatchEntry as n, type NexraModelOperation as o, type NexraModelSpec as p, type NexraModelSpecFilter as q, type NexraQuote as r, type NexraSalePrice as s, type NexraSalePriceList as t, type NexraSettlement as u, type TaskModelSummary as v, applyMediaGeometry as w, decodeMediaGeometry as x, encodeMediaGeometry as y, projectMediaGeometry as z };

package/dist/media.d.ts

@@ -1,2 +1,2 @@
-export { k as NEXRA_GENERATION_OPERATIONS, l as NEXRA_MEDIA_API_VERSION, m as NEXRA_MEDIA_FEATURES, n as NEXRA_MEDIA_INPUT_SCHEMAS, o as NEXRA_MEDIA_OPERATIONS, p as NEXRA_MEDIA_OPERATION_DEFINITIONS, q as NEXRA_PUBLISHED_MEDIA_OPERATIONS, r as NexraAudioContentPart, s as NexraAudioGenerateInput, t as NexraAudioTranscribeInput, u as NexraGenerationOperation, v as NexraImageContentPart, w as NexraImageGenerateInput, N as NexraImageLayer, g as NexraImageLayerDecompositionOutput, x as NexraImageUpscaleInput, y as NexraMediaContentPart, z as NexraMediaFeature, B as NexraMediaInputByOperation, C as NexraMediaInputMode, D as NexraMediaInputSlot, E as NexraMediaKind, F as NexraMediaOperation, G as NexraMediaOperationDefinition, H as NexraMediaParameter, I as NexraMediaParameterConstraint, J as NexraMediaSource, K as NexraPublishedMediaOperation, L as NexraResourceContentPart, O as NexraTextContentPart, P as NexraVideoContentPart, Q as NexraVideoDepthInput, R as NexraVideoGenerateInput, S as NexraVideoKeyframeContentPart, T as NexraVideoUpscaleInput, U as isNexraMediaInput, V as nexraMediaInputSchema, W as nexraMediaInputSchemaForMode, X as nexraMediaOperationForMode } from './media-DzOxLGs-.js';
-import './json-Cz0MkWQn.js';
+export { k as NEXRA_GENERATION_OPERATIONS, l as NEXRA_MEDIA_API_VERSION, m as NEXRA_MEDIA_FEATURES, n as NEXRA_MEDIA_INPUT_SCHEMAS, o as NEXRA_MEDIA_OPERATIONS, p as NEXRA_MEDIA_OPERATION_DEFINITIONS, q as NEXRA_PUBLISHED_MEDIA_OPERATIONS, r as NexraAudioContentPart, s as NexraAudioGenerateInput, t as NexraAudioTranscribeInput, u as NexraGenerationOperation, v as NexraImageContentPart, w as NexraImageGenerateInput, N as NexraImageLayer, g as NexraImageLayerDecompositionOutput, x as NexraImageUpscaleInput, y as NexraMediaContentPart, z as NexraMediaFeature, B as NexraMediaInputByOperation, C as NexraMediaInputMode, D as NexraMediaInputSlot, E as NexraMediaKind, F as NexraMediaOperation, G as NexraMediaOperationDefinition, H as NexraMediaParameter, I as NexraMediaParameterConstraint, J as NexraMediaSource, K as NexraPublishedMediaOperation, L as NexraResourceContentPart, O as NexraTextContentPart, P as NexraVideoContentPart, Q as NexraVideoDepthInput, R as NexraVideoGenerateInput, S as NexraVideoKeyframeContentPart, T as NexraVideoUpscaleInput, U as isNexraMediaInput, V as nexraMediaInputSchema, W as nexraMediaInputSchemaForMode, X as nexraMediaOperationForMode } from './media-IaOdOMQC.js';
+import './json-dnsDzk-s.js';

package/dist/media.js

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

package/dist/node.d.ts

@@ -0,0 +1,17 @@
+export { A as AssetImportRequest, a as AssetInput, b as AssetReference, c as AssetUploadOptions, M as MEDIA_KINDS, d as MediaAsset, e as MediaAssetStatus, f as MediaKind, N as NexraImageLayer, g as NexraImageLayerDecompositionOutput } from './media-IaOdOMQC.js';
+import { N as NexraClientOptions } from './media-geometry-z7fXaDSN.js';
+export { C as CreateNexraDisplayQuoteBatchRequest, a as CreateNexraQuoteRequest, F as FetchLike, M as MediaGeometryField, b as MediaGeometryProjection, c as ModelCapabilitySummary, d as ModelDateVersion, e as ModelEndpointSummary, f as ModelModality, g as ModelResourceList, h as ModelResourceOption, i as ModelSchema, j as ModelSearchParams, k as NexraBillingCurrency, l as NexraCatalogRevision, m as NexraDisplayQuoteBatch, n as NexraDisplayQuoteBatchEntry, o as NexraModelOperation, p as NexraModelSpec, q as NexraModelSpecFilter, r as NexraQuote, s as NexraSalePrice, t as NexraSalePriceList, u as NexraSettlement, T as TaskModel, v as TaskModelSummary, U as UnifiedMediaGeometry, w as applyMediaGeometry, x as decodeMediaGeometry, y as encodeMediaGeometry, z as projectMediaGeometry } from './media-geometry-z7fXaDSN.js';
+export { C as CursorPage, J as JsonObject, a as JsonPrimitive, b as JsonValue } from './json-dnsDzk-s.js';
+export { A as ApiErrorPayload, N as NexraError, P as PublicError, a as PublicErrorContext, b as PublicErrorFields, e as extractUpstreamErrorMessage } from './errors-BXPUVOh7.js';
+export { A as AssetsClient, C as CreateTaskOptions, a as CreateTaskRequest, b as CreateVoiceRequest, N as NexraTranscriptionError, R as RequestDetails, c as RunResult, d as RunTaskOptions, T as TASK_STATUSES, e as Task, f as TaskCost, g as TaskError, h as TaskEvent, i as TaskEventType, j as TaskListParams, k as TaskPage, l as TaskProgress, m as TaskReceipt, e as TaskResult, n as TaskStatus, o as TaskTiming, p as TaskUsage, q as TaskWebhookConfig, r as TasksClient, s as TerminalTaskStatus, t as TranscriptionClient, u as TranscriptionEvent, v as TranscriptionResponse, w as TranscriptionStreamOptions, V as VerifyWebhookOptions, x as Voice, y as VoiceCreation, W as WaitTaskOptions, z as WatchTaskOptions, B as isTerminalTaskStatus, D as verifyWebhook } from './voices-BrCaiHnb.js';
+export { CatalogClient, formatModelDisplayName, getModelSpec, listModelSpecs } from './catalog.js';
+import { NexraClient as NexraClient$1 } from './index.js';
+export { CreateVoiceOptions, ModelsClient, NexraApiError, NexraTaskError, NexraWaitTimeoutError, VoicesClient } from './index.js';
+export { ceilDecimal, multiplyDecimal } from './decimal.js';
+
+declare class NexraClient extends NexraClient$1 {
+    constructor(options?: NexraClientOptions);
+}
+declare function createNexra(options?: NexraClientOptions): NexraClient;
+
+export { NexraClient, NexraClientOptions, createNexra };

package/dist/node.js

@@ -0,0 +1,78 @@
+import {
+  AssetsClient,
+  ModelsClient,
+  NexraClient,
+  NexraTranscriptionError,
+  TasksClient,
+  TranscriptionClient,
+  VoicesClient,
+  verifyWebhook
+} from "./chunk-ZTRVMQMH.js";
+import {
+  ceilDecimal,
+  multiplyDecimal
+} from "./chunk-FCH5IQP5.js";
+import {
+  CatalogClient,
+  NexraApiError,
+  NexraTaskError,
+  NexraWaitTimeoutError,
+  applyMediaGeometry,
+  decodeMediaGeometry,
+  encodeMediaGeometry,
+  formatModelDisplayName,
+  getModelSpec,
+  listModelSpecs,
+  projectMediaGeometry
+} from "./chunk-MLDFBO2A.js";
+import {
+  ASR_MAX_FRAME_BYTES,
+  MEDIA_KINDS,
+  TASK_STATUSES,
+  extractUpstreamErrorMessage,
+  isTerminalTaskStatus
+} from "./chunk-IOGCXMW3.js";
+
+// src/node.ts
+import WebSocket from "ws";
+var NexraClient2 = class extends NexraClient {
+  constructor(options = {}) {
+    super(options, (url, headers) => new WebSocket(url, {
+      headers: Object.fromEntries(headers),
+      maxPayload: ASR_MAX_FRAME_BYTES,
+      followRedirects: false,
+      perMessageDeflate: false
+    }));
+  }
+};
+function createNexra(options = {}) {
+  return new NexraClient2(options);
+}
+export {
+  AssetsClient,
+  CatalogClient,
+  MEDIA_KINDS,
+  ModelsClient,
+  NexraApiError,
+  NexraClient2 as NexraClient,
+  NexraTaskError,
+  NexraTranscriptionError,
+  NexraWaitTimeoutError,
+  TASK_STATUSES,
+  TasksClient,
+  TranscriptionClient,
+  VoicesClient,
+  applyMediaGeometry,
+  ceilDecimal,
+  createNexra,
+  decodeMediaGeometry,
+  encodeMediaGeometry,
+  extractUpstreamErrorMessage,
+  formatModelDisplayName,
+  getModelSpec,
+  isTerminalTaskStatus,
+  listModelSpecs,
+  multiplyDecimal,
+  projectMediaGeometry,
+  verifyWebhook
+};