@byte_fluffy/nexra-sdk 0.1.0-alpha.45 → 0.1.0-alpha.47

package/dist/{chunk-FEACXUHZ.js → chunk-LXR3MEF3.js}

@@ -419,21 +419,27 @@ var NEXRA_GENERATION_OPERATIONS = [
   "video.generate",
   "audio.generate",
   "image.upscale",
-  "video.upscale"
+  "video.upscale",
+  "video.depth",
+  "video.segment"
 ];
 var NEXRA_MEDIA_OPERATIONS = [
   "image.generate",
   "video.generate",
   "audio.generate",
   "image.upscale",
-  "video.upscale"
+  "video.upscale",
+  "video.depth",
+  "video.segment"
 ];
 var NEXRA_PUBLISHED_MEDIA_OPERATIONS = [
   "image.generate",
   "video.generate",
   "audio.generate",
   "image.upscale",
-  "video.upscale"
+  "video.upscale",
+  "video.depth",
+  "video.segment"
 ];
 var NEXRA_MEDIA_FEATURES = [
   "text-to-image",
@@ -459,7 +465,9 @@ var NEXRA_MEDIA_FEATURES = [
   "voice-reference",
   "voice-design",
   "scale-factor",
-  "target-resolution"
+  "target-resolution",
+  "video-depth",
+  "video-segment"
 ];
 var NEXRA_MEDIA_OPERATION_DEFINITIONS = Object.freeze([
   {
@@ -496,6 +504,20 @@ var NEXRA_MEDIA_OPERATION_DEFINITIONS = Object.freeze([
     outputKind: "video",
     features: ["scale-factor", "target-resolution"],
     parameterKeys: ["scale", "resolution", "output_format", "preserve_details"]
+  },
+  {
+    operation: "video.depth",
+    status: "active",
+    outputKind: "video",
+    features: ["video-depth"],
+    parameterKeys: ["resolution"]
+  },
+  {
+    operation: "video.segment",
+    status: "active",
+    outputKind: "video",
+    features: ["video-segment"],
+    parameterKeys: ["resolution"]
   }
 ]);
 var mediaSourceSchema = {
@@ -553,9 +575,20 @@ function inputSchema(contentItems, properties, contentBounds = {}) {
   };
 }
 var imagePart = mediaPartSchema("image", ["source", "reference", "first_frame", "last_frame", "mask", "control", "subject", "background"]);
-var videoImagePart = mediaPartSchema("image", ["source", "reference", "first_frame", "last_frame", "mask", "control", "subject", "background", "keyframe"]);
+var videoImagePart = mediaPartSchema("image", ["source", "reference", "first_frame", "middle_frame", "last_frame", "mask", "control", "subject", "background", "keyframe"]);
 var videoPart = mediaPartSchema("video", ["source", "reference", "edit", "extend"]);
 var audioPart = mediaPartSchema("audio", ["source", "reference", "voice_reference"]);
+var resourcePart = {
+  type: "object",
+  properties: {
+    type: { const: "resource" },
+    resource: { type: "string", enum: ["element", "voice"] },
+    source: { type: "string", minLength: 1 },
+    name: { type: "string", minLength: 1 }
+  },
+  required: ["type", "resource", "source", "name"],
+  additionalProperties: false
+};
 var draftPart = {
   type: "object",
   properties: {
@@ -580,7 +613,7 @@ var NEXRA_MEDIA_INPUT_SCHEMAS = Object.freeze({
     }
   ),
   "video.generate": inputSchema(
-    [textPartSchema(["prompt", "negative_prompt", "script"]), videoImagePart, videoPart, audioPart, draftPart],
+    [textPartSchema(["prompt", "negative_prompt", "script"]), videoImagePart, videoPart, audioPart, draftPart, resourcePart],
     {
       task_type: { type: "string", minLength: 1, "x-ui": { order: 8, control: "segmented" } },
       voice: { type: "string", minLength: 1, "x-ui": { order: 9, control: "resource", resource: "voice" } },
@@ -635,6 +668,16 @@ var NEXRA_MEDIA_INPUT_SCHEMAS = Object.freeze({
       preserve_details: { type: "boolean", "x-ui": { order: 13, control: "switch" } }
     },
     { minItems: 1, maxItems: 1 }
+  ),
+  "video.segment": inputSchema(
+    [textPartSchema(["prompt"]), mediaPartSchema("video", ["source"])],
+    { resolution: { type: "string", minLength: 1, "x-ui": { order: 10 } } },
+    { minItems: 2, maxItems: 2 }
+  ),
+  "video.depth": inputSchema(
+    [mediaPartSchema("video", ["source"])],
+    { resolution: { type: "string", minLength: 1, "x-ui": { order: 10 } } },
+    { minItems: 1, maxItems: 1 }
   )
 });
 function nexraMediaInputSchema(operation) {
@@ -649,6 +692,7 @@ function isNexraMediaInput(value) {
   return Array.isArray(content) && content.length > 0 && content.every((part) => {
     if (!part || typeof part !== "object" || Array.isArray(part)) return false;
     if (part.type === "text") return typeof part.text === "string" && part.text.length > 0;
+    if (part.type === "resource") return ["element", "voice"].includes(String(part.resource)) && typeof part.source === "string" && part.source.length > 0 && typeof part.name === "string" && part.name.length > 0;
     if (part.type === "draft_task") {
       const reference = part.draft_task;
       return Boolean(reference && typeof reference === "object" && !Array.isArray(reference) && typeof reference.id === "string" && reference.id.length > 0);
@@ -664,6 +708,8 @@ function nexraMediaOperationForMode(mode) {
   if (["text-to-speech", "text-to-music", "text-to-sfx"].includes(mode)) return "audio.generate";
   if (mode === "image-upscale") return "image.upscale";
   if (mode === "video-upscale") return "video.upscale";
+  if (mode === "video-depth") return "video.depth";
+  if (mode === "video-segment") return "video.segment";
   return void 0;
 }
 function nexraMediaInputSchemaForMode(mode) {
@@ -705,10 +751,11 @@ function nexraMediaInputSchemaForMode(mode) {
       variant.required = [...required];
     }
   }
-  const requiredMedia = mode === "image-to-image" || mode === "image-to-video" || mode === "avatar-video" ? "image" : void 0;
+  const requiredMedia = ["video-depth", "video-segment"].includes(mode) ? "video" : mode === "image-to-image" || mode === "image-to-video" || mode === "avatar-video" ? "image" : void 0;
   const requiresReferenceMedia = mode === "multimodal-to-video";
+  const hasTextPart = items.oneOf.some((variant) => variant.properties.type.const === "text");
   content.allOf = [
-    ...mode === "avatar-video" ? [] : [{
+    ...mode === "avatar-video" || !hasTextPart ? [] : [{
       contains: { type: "object", properties: { type: { const: "text" } }, required: ["type"] },
       minContains: 1
     }],

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-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-CwGmG5qB.js';
-import { H as HttpTransport, u as ModelSearchParams, T as TaskModelSummary, v as TaskModel, w as ModelSchema, x as ModelResourceList, y as NexraClientOptions } from './media-geometry-KwQh1O8Y.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, E as ModelResourceOption, l as NexraBillingCurrency, g as NexraCatalogRevision, 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, U as UnifiedMediaGeometry, q as applyMediaGeometry, r as decodeMediaGeometry, s as encodeMediaGeometry, t as projectMediaGeometry } from './media-geometry-KwQh1O8Y.js';
+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-Co8S2qEM.js';
+import { H as HttpTransport, u as ModelSearchParams, T as TaskModelSummary, v as TaskModel, w as ModelSchema, x as ModelResourceList, y as NexraClientOptions } from './media-geometry-BS4DZh4B.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, E as ModelResourceOption, l as NexraBillingCurrency, g as NexraCatalogRevision, 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, U as UnifiedMediaGeometry, q as applyMediaGeometry, r as decodeMediaGeometry, s as encodeMediaGeometry, t as projectMediaGeometry } from './media-geometry-BS4DZh4B.js';
 import { C as CursorPage, J as JsonValue } from './json-Cz0MkWQn.js';
 export { a as JsonObject, b as JsonPrimitive } from './json-Cz0MkWQn.js';
 import { N as NexraError, P as PublicErrorFields } from './errors-DJZuAKoO.js';
 export { A as ApiErrorPayload, a as PublicError, b as PublicErrorContext, e as extractUpstreamErrorMessage } from './errors-DJZuAKoO.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-B09HqQJJ.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-B09HqQJJ.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-Bzt4nV1r.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-Bzt4nV1r.js';
 import { CatalogClient } from './catalog.js';
 export { formatModelDisplayName, getModelSpec, listModelSpecs } from './catalog.js';
 export { ceilDecimal, multiplyDecimal } from './decimal.js';

package/dist/index.js

@@ -20,14 +20,14 @@ import {
   projectMediaGeometry,
   queryString,
   sleep
-} from "./chunk-OX5GFYVN.js";
+} from "./chunk-7MNUV5BJ.js";
 import {
   MEDIA_KINDS,
   TASK_STATUSES,
   createTaskRequest,
   extractUpstreamErrorMessage,
   isTerminalTaskStatus
-} from "./chunk-FEACXUHZ.js";
+} from "./chunk-LXR3MEF3.js";
 
 // src/assets.ts
 var AssetsClient = class {

package/dist/language.d.ts

@@ -1,7 +1,7 @@
 import { APICallError, LanguageModelV4 } from '@ai-sdk/provider';
 import { NexraLanguageProtocol } from './catalog.js';
 export { NexraLanguageModelBinding } from './catalog.js';
-import { F as FetchLike } from './media-geometry-KwQh1O8Y.js';
+import { F as FetchLike } from './media-geometry-BS4DZh4B.js';
 import { N as NexraError } from './errors-DJZuAKoO.js';
 import './json-Cz0MkWQn.js';
 

package/dist/language.js

@@ -6,18 +6,17 @@ import {
   jsonBody,
   parseServerSentEvents,
   resolveNexraLanguageReasoning
-} from "./chunk-OX5GFYVN.js";
+} from "./chunk-7MNUV5BJ.js";
 import {
   isPublicErrorCode,
   publicErrorMessage,
   resolvePublicErrorLocale
-} from "./chunk-FEACXUHZ.js";
+} from "./chunk-LXR3MEF3.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
@@ -72,6 +71,30 @@ 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)) {
@@ -83,6 +106,10 @@ 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";
@@ -380,7 +407,7 @@ function createChatLanguageModel(binding, transport) {
     specificationVersion: "v4",
     provider: "nexra.chat",
     modelId: binding.spec.id,
-    supportedUrls: Object.fromEntries(binding.spec.capabilities.inputModalities.filter((kind) => ["image", "audio", "video"].includes(kind)).map((kind) => [`${kind}/*`, [/^https?:\/\//]])),
+    supportedUrls: chatSupportedUrls(binding),
     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 });
@@ -528,6 +555,188 @@ 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;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+    key,
+    key === "annotations" && Array.isArray(item) ? item.filter((annotation) => !isUnpositionedCitation(annotation)).map(project) : project(item)
+  ]));
+}
+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);
@@ -553,30 +762,30 @@ function createNexraLanguageModel(modelId, options) {
       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);
+    model = createResponsesLanguageModel({ modelId: binding.spec.id, apiKey, headers: common.headers, baseUrl: `${root}/v1`, fetch: responsesFetch });
   } else {
     model = createAnthropic({ ...common, name: "nexra.anthropic", baseURL: `${root}/v1` })(binding.spec.id);
   }
   return withNativeContract(model, binding);
 }
-function object3(value) {
+function object4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function explicitResponsesMessages(value) {
-  const body = object3(value);
+  const body = object4(value);
   if (!Array.isArray(body.input)) return value;
   return { ...body, input: body.input.map((value2) => {
-    const item = object3(value2);
+    const item = object4(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 = 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 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 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 } } };
 }
@@ -584,25 +793,29 @@ function nativeRequest(binding, request, stream = false) {
   if (!request) return request;
   return binding.endpoint.protocol === "openai-responses" ? {
     ...request,
-    body: explicitResponsesMessages(stream ? { ...object3(request.body), stream: true } : request.body)
+    body: explicitResponsesMessages(stream ? { ...object4(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 = 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);
+  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);
   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 = object3(providerOptions.openai);
+    const current = object4(providerOptions.openai);
     providerOptions.openai = {
       store: false,
       forceReasoning: binding.endpoint.capabilities.includes("reasoning"),
       ...current
     };
-    const reasoning = object3(providerOptions.openai);
+    const reasoning = object4(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}`);
     }
@@ -612,8 +825,8 @@ function prepare(options, binding, stream) {
   }
   if (binding.endpoint.protocol === "anthropic-messages") {
     const capabilities = getAnthropicModelCapabilities(binding.spec.id);
-    const native = { ...object3(providerOptions.anthropic), ...object3(providerOptions.nexra) };
-    let thinking = object3(native.thinking);
+    const native = { ...object4(providerOptions.anthropic), ...object4(providerOptions.nexra) };
+    let thinking = object4(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,
@@ -634,20 +847,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 = object3(providerOptions.google);
-    providerOptions.google = { ...google, thinkingConfig: { includeThoughts: true, ...object3(google.thinkingConfig) } };
+    const google = object4(providerOptions.google);
+    providerOptions.google = { ...google, thinkingConfig: { includeThoughts: true, ...object4(google.thinkingConfig) } };
   }
   return { ...options, providerOptions };
 }
 function nativeUsage(protocol, value) {
-  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;
+  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;
   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] = { ...object3(previous?.[key]), ...object3(value) };
+    if (value && typeof value === "object" && !Array.isArray(value)) merged[key] = { ...object4(previous?.[key]), ...object4(value) };
   }
   return merged;
 }
@@ -681,8 +894,8 @@ function withNativeContract(model, binding) {
         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 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 next = nativeUsage(binding.endpoint.protocol, part.rawValue);
               if (next) raw = mergeRecords(raw, next);
               if (options.includeRawChunks) controller.enqueue(part);