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

package/dist/language.js

@@ -0,0 +1,631 @@
+import {
+  HttpTransport,
+  SDK_VERSION,
+  createServerSentEventDecoder,
+  getLanguageModelBinding,
+  jsonBody,
+  parseServerSentEvents,
+  resolveNexraLanguageReasoning
+} from "./chunk-QXEDXMFI.js";
+import {
+  isPublicErrorCode,
+  publicErrorMessage,
+  resolvePublicErrorLocale
+} from "./chunk-QBW7OCT3.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
+import { InvalidResponseDataError } from "@ai-sdk/provider";
+import { StreamingToolCallTracker } from "@ai-sdk/provider-utils";
+
+// src/language/chat-prompt.ts
+import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
+import { convertToBase64, resolveFullMediaType } from "@ai-sdk/provider-utils";
+
+// src/language/reasoning.ts
+function object(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function prepareLanguageReasoning(options, binding) {
+  if (!options.reasoning || options.reasoning === "provider-default") return options;
+  const fields = object(binding.endpoint.inputSchema?.properties);
+  if (!binding.endpoint.capabilities.includes("reasoning")) throw new Error(`Nexra model does not support reasoning: ${binding.spec.id}`);
+  const namespace = binding.endpoint.protocol === "openai-responses" ? "openai" : binding.endpoint.protocol === "anthropic-messages" ? "anthropic" : binding.endpoint.protocol === "gemini-generate-content" ? "google" : "nexra";
+  const current = object(options.providerOptions?.[namespace]);
+  if (current.thinking !== void 0 || current.reasoningEffort !== void 0 || current.reasoning_effort !== void 0 || object(current.thinkingConfig).thinkingLevel !== void 0 || object(current.thinkingConfig).thinkingBudget !== void 0) return options;
+  const nativeField = binding.endpoint.protocol === "openai-chat-completions" ? fields.reasoning_effort : binding.endpoint.protocol === "openai-responses" ? object(object(fields.reasoning).properties).effort : binding.endpoint.protocol === "gemini-generate-content" ? object(object(object(object(fields.generationConfig).properties).thinkingConfig).properties).thinkingLevel : void 0;
+  const values = object(nativeField).enum;
+  if (options.reasoning === "none") {
+    const resolved = resolveNexraLanguageReasoning(binding.spec.id, { enabled: false, protocol: binding.endpoint.protocol });
+    if (!resolved.canDisable) throw new Error(`Nexra model cannot disable reasoning: ${binding.spec.id}`);
+    const desired = object(resolved.providerOptions[namespace]);
+    return { ...options, reasoning: void 0, providerOptions: { ...options.providerOptions, [namespace]: { ...desired, ...current } } };
+  }
+  if (Array.isArray(values) && !values.includes(options.reasoning)) throw new Error(`Nexra reasoning effort is outside the native contract for ${binding.spec.id}: ${options.reasoning}`);
+  if (binding.endpoint.protocol === "openai-chat-completions") {
+    const thinkingType = object(object(object(fields.thinking).properties).type).enum;
+    return { ...options, providerOptions: { ...options.providerOptions, nexra: {
+      ...Array.isArray(thinkingType) && thinkingType.includes("enabled") ? { thinking: { type: "enabled" } } : {},
+      ...current,
+      reasoning_effort: options.reasoning
+    } } };
+  }
+  return options;
+}
+
+// src/language/chat-prompt.ts
+function nativeOptions(part) {
+  const value = part.providerOptions?.nexra;
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function filePart(part, binding) {
+  const kind = part.mediaType.split("/")[0];
+  if (["image", "audio", "video"].includes(kind) && !binding.spec.capabilities.inputModalities.includes(kind)) {
+    throw new UnsupportedFunctionalityError({ functionality: `${kind} input for ${binding.spec.id}` });
+  }
+  const metadata = nativeOptions(part);
+  const reference = part.data.type === "reference" ? part.data.reference.nexra : void 0;
+  if (part.data.type === "reference" && typeof reference !== "string") {
+    throw new UnsupportedFunctionalityError({ functionality: "file reference without a Nexra reference" });
+  }
+  const url = part.data.type === "url" ? part.data.url.toString() : void 0;
+  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";
+    const source = reference ? { file_id: reference } : { url: url ?? `data:${resolveFullMediaType({ part })};base64,${data}` };
+    if (!reference && !url && data === void 0) throw new UnsupportedFunctionalityError({ functionality: `${kind} text file input` });
+    return { ...metadata, type: field, [field]: { ...asObject(metadata[field]), ...source } };
+  }
+  if (kind === "audio") {
+    if (reference || url) return { ...metadata, type: "input_audio", input_audio: { ...asObject(metadata.input_audio), ...reference ? { file_id: reference } : { url } } };
+    const mime = resolveFullMediaType({ part });
+    const format = { "audio/mpeg": "mp3", "audio/mp3": "mp3", "audio/wav": "wav", "audio/x-wav": "wav", "audio/aac": "aac", "audio/mp4": "m4a", "audio/x-m4a": "m4a" }[mime];
+    if (data === void 0 || !format) throw new UnsupportedFunctionalityError({ functionality: `audio input format ${mime}` });
+    return { ...metadata, type: "input_audio", input_audio: { ...asObject(metadata.input_audio), data, format } };
+  }
+  if (part.mediaType === "application/pdf" || reference) {
+    const source = reference ? { file_id: reference } : url ? { file_url: url } : { file_data: `data:application/pdf;base64,${data}`, filename: part.filename ?? "document.pdf" };
+    if (!reference && !url && data === void 0) throw new UnsupportedFunctionalityError({ functionality: "PDF text file input" });
+    return { ...metadata, type: "file", file: { ...asObject(metadata.file), ...source } };
+  }
+  if (kind === "text" && part.data.type === "text") return { ...metadata, type: "text", text: part.data.text };
+  throw new UnsupportedFunctionalityError({ functionality: `file media type ${part.mediaType}` });
+}
+function asObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function toolOutput(output, binding) {
+  switch (output.type) {
+    case "text":
+    case "error-text":
+      return output.value;
+    case "json":
+    case "error-json":
+      return JSON.stringify(output.value);
+    case "execution-denied":
+      return output.reason ?? "Tool execution denied";
+    case "content":
+      return output.value.map((part) => {
+        if (part.type === "text") return { ...nativeOptions(part), type: "text", text: part.text };
+        if (part.type === "file") return filePart(part, binding);
+        throw new UnsupportedFunctionalityError({ functionality: "custom tool output" });
+      });
+  }
+}
+function messages(prompt, binding) {
+  return prompt.flatMap((message) => {
+    const metadata = nativeOptions(message);
+    if (message.role === "system") return [{ ...metadata, role: "system", content: message.content }];
+    if (message.role === "user") {
+      const content2 = message.content.map((part) => part.type === "text" ? { ...nativeOptions(part), type: "text", text: part.text } : filePart(part, binding));
+      return [{ ...metadata, role: "user", content: content2.length === 1 && content2[0]?.type === "text" ? content2[0].text : content2 }];
+    }
+    if (message.role === "tool") return message.content.map((part) => {
+      if (part.type === "tool-approval-response") throw new UnsupportedFunctionalityError({ functionality: "provider tool approval" });
+      return { ...nativeOptions(part), role: "tool", tool_call_id: part.toolCallId, content: toolOutput(part.output, binding) };
+    });
+    let text = "";
+    const content = [];
+    let hasFile = false;
+    let reasoning = "";
+    let encrypted = metadata.encrypted_content;
+    const calls = [];
+    for (const part of message.content) {
+      if (part.type === "text") {
+        text += part.text;
+        content.push({ ...nativeOptions(part), type: "text", text: part.text });
+      } else if (part.type === "file") {
+        content.push(filePart(part, binding));
+        hasFile = true;
+      } else if (part.type === "reasoning") {
+        reasoning += part.text;
+        encrypted = nativeOptions(part).encrypted_content ?? encrypted;
+      } else if (part.type === "tool-call" && !part.providerExecuted) calls.push({ ...nativeOptions(part), id: part.toolCallId, type: "function", function: { name: part.toolName, arguments: JSON.stringify(part.input ?? {}) } });
+      else throw new UnsupportedFunctionalityError({ functionality: `assistant ${part.type}` });
+    }
+    return [{
+      ...metadata,
+      role: "assistant",
+      content: hasFile ? content : text,
+      ...reasoning ? { reasoning_content: reasoning } : {},
+      ...encrypted ? { encrypted_content: encrypted } : {},
+      ...calls.length ? { tool_calls: calls } : {}
+    }];
+  });
+}
+function chatRequest(binding, options, stream) {
+  options = prepareLanguageReasoning(options, binding);
+  const extension = nativeOptions(options);
+  const limits = asObject(asObject(binding.endpoint.inputSchema?.properties).max_tokens);
+  if (options.maxOutputTokens !== void 0 && (!Number.isInteger(options.maxOutputTokens) || typeof limits.minimum === "number" && options.maxOutputTokens < limits.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 (extension.n !== void 0 && extension.n !== 1) throw new UnsupportedFunctionalityError({ functionality: "multiple Chat Completions choices" });
+  for (const key of ["model", "messages", "stream"]) {
+    if (Object.hasOwn(extension, key)) throw new Error(`Nexra providerOptions cannot override ${key}`);
+  }
+  if (options.tools?.length && !binding.endpoint.capabilities.includes("tool_call")) {
+    throw new UnsupportedFunctionalityError({ functionality: `tools for ${binding.spec.id}` });
+  }
+  const tools = options.tools?.map((tool) => {
+    if (tool.type !== "function") throw new UnsupportedFunctionalityError({ functionality: "provider tools in Chat Completions" });
+    return { type: "function", function: { name: tool.name, description: tool.description, parameters: tool.inputSchema, ...tool.strict !== void 0 ? { strict: tool.strict } : {} } };
+  });
+  const choice = options.toolChoice;
+  return {
+    ...extension.max_completion_tokens === void 0 ? { max_tokens: options.maxOutputTokens } : {},
+    temperature: options.temperature,
+    top_p: options.topP,
+    top_k: options.topK,
+    frequency_penalty: options.frequencyPenalty,
+    presence_penalty: options.presencePenalty,
+    stop: options.stopSequences,
+    seed: options.seed,
+    ...options.reasoning && options.reasoning !== "provider-default" ? { reasoning_effort: options.reasoning } : {},
+    ...options.responseFormat?.type === "json" ? { response_format: options.responseFormat.schema ? { type: "json_schema", json_schema: { name: options.responseFormat.name ?? "response", description: options.responseFormat.description, schema: options.responseFormat.schema, strict: true } } : { type: "json_object" } } : {},
+    ...extension,
+    model: binding.spec.id,
+    messages: messages(options.prompt, binding),
+    stream,
+    ...stream ? { stream_options: { include_usage: true, ...asObject(extension.stream_options) } } : {},
+    ...tools?.length ? { tools } : {},
+    ...choice ? { tool_choice: choice.type === "tool" ? { type: "function", function: { name: choice.toolName } } : choice.type } : {}
+  };
+}
+
+// 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 ?? 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 = createServerSentEventDecoder();
+  const inspect = (events) => {
+    for (const event of events) {
+      let body;
+      try {
+        body = JSON.parse(event.data);
+      } catch {
+        if (event.event === "error") throw new NexraNativeError({ ...context, body: event.data, responseBody: event.data });
+        continue;
+      }
+      const payload = record(body);
+      if (event.event === "error" || payload.type === "error" || payload.type === "response.failed" || payload.error) {
+        throw new NexraNativeError({ ...context, body, responseBody: event.data });
+      }
+    }
+  };
+  const stream = response.body.pipeThrough(new TransformStream({
+    transform(bytes, controller) {
+      inspect(decode(bytes));
+      controller.enqueue(bytes);
+    },
+    flush() {
+      inspect(decode(void 0, true));
+    }
+  }));
+  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 : {};
+}
+function count(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function usage(value) {
+  const raw = object2(value);
+  const input = count(raw.prompt_tokens);
+  const output = count(raw.completion_tokens);
+  const cached = count(object2(raw.prompt_tokens_details).cached_tokens);
+  const written = count(object2(raw.prompt_tokens_details).cache_write_tokens);
+  const reasoning = count(object2(raw.completion_tokens_details).reasoning_tokens);
+  return {
+    inputTokens: { total: input, noCache: input === void 0 ? void 0 : Math.max(0, input - (cached ?? 0) - (written ?? 0)), cacheRead: cached, cacheWrite: written },
+    outputTokens: { total: output, text: output === void 0 ? void 0 : Math.max(0, output - (reasoning ?? 0)), reasoning },
+    raw: Object.keys(raw).length ? raw : void 0
+  };
+}
+function finishReason(raw) {
+  const value = typeof raw === "string" ? raw : void 0;
+  const reasons = { stop: "stop", length: "length", tool_calls: "tool-calls", function_call: "tool-calls", content_filter: "content-filter" };
+  return { unified: reasons[value] ?? "other", raw: value };
+}
+function invalid(data, message) {
+  throw new InvalidResponseDataError({ data, message });
+}
+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);
+}
+function reasoningMetadata(message) {
+  return typeof message.encrypted_content === "string" ? { nexra: { encrypted_content: message.encrypted_content } } : void 0;
+}
+function createChatLanguageModel(binding, transport) {
+  return {
+    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?:\/\//]])),
+    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 });
+      const payload = object2(await response.json());
+      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 = [];
+      const metadata = reasoningMetadata(message);
+      const reasoning = message.reasoning_content ?? message.reasoning;
+      if (typeof reasoning === "string" || metadata) content.push({ type: "reasoning", text: typeof reasoning === "string" ? reasoning : "", ...metadata ? { providerMetadata: metadata } : {} });
+      if (typeof message.content === "string" && message.content) content.push({ type: "text", text: message.content });
+      if (message.content !== null && message.content !== void 0 && typeof message.content !== "string") invalid(message.content, "Chat Completions content must be text");
+      if (Array.isArray(message.tool_calls)) {
+        for (const raw of message.tool_calls) {
+          const call = object2(raw);
+          const fn = object2(call.function);
+          if (typeof call.id !== "string" || typeof fn.name !== "string" || typeof fn.arguments !== "string") invalid(call, "Invalid Chat Completions tool call");
+          content.push({ type: "tool-call", toolCallId: call.id, toolName: fn.name, input: fn.arguments });
+        }
+      }
+      return {
+        content,
+        finishReason: finishReason(choice.finish_reason),
+        usage: usage(payload.usage),
+        warnings: [],
+        request: { body },
+        response: {
+          id: typeof payload.id === "string" ? payload.id : void 0,
+          modelId: typeof payload.model === "string" ? payload.model : void 0,
+          headers: Object.fromEntries(response.headers),
+          body: payload
+        }
+      };
+    },
+    async doStream(options) {
+      if (!binding.supportsStreaming) throw new Error(`Nexra model does not support streaming: ${binding.spec.id}`);
+      const body = chatRequest(binding, options, true);
+      const abort = new AbortController();
+      const signal = options.abortSignal ? AbortSignal.any([options.abortSignal, abort.signal]) : abort.signal;
+      const response = await transport.response("/chat/completions", { method: "POST", ...jsonBody(body), headers: combineHeaders(options), signal }, { retryable: false });
+      const iterator = parseServerSentEvents(response, { signal });
+      let canceled = false;
+      const stream = new ReadableStream({
+        async start(controller) {
+          controller.enqueue({ type: "stream-start", warnings: [] });
+          const tracker = new StreamingToolCallTracker(controller, { typeValidation: "if-present" });
+          const pending = /* @__PURE__ */ new Map();
+          const startedTools = /* @__PURE__ */ new Set();
+          let textOpen = false;
+          let reasoningOpen = false;
+          let metadataSent = false;
+          let rawUsage;
+          let reason;
+          let ended = false;
+          let encrypted = "";
+          try {
+            for await (const event of iterator) {
+              if (event.data === "[DONE]") {
+                ended = true;
+                break;
+              }
+              const payload = object2(JSON.parse(event.data));
+              if (options.includeRawChunks) controller.enqueue({ type: "raw", rawValue: payload });
+              if (!metadataSent) {
+                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, response, options.headers)[0];
+              if (payload.usage) rawUsage = payload.usage;
+              if (!choice) continue;
+              if (choice.finish_reason != null) reason = choice.finish_reason;
+              const delta = object2(choice.delta);
+              if (typeof delta.encrypted_content === "string") encrypted += delta.encrypted_content;
+              const reasoning = delta.reasoning_content ?? delta.reasoning;
+              if (typeof reasoning === "string" && reasoning) {
+                if (!reasoningOpen) {
+                  controller.enqueue({ type: "reasoning-start", id: "reasoning-0" });
+                  reasoningOpen = true;
+                }
+                controller.enqueue({ type: "reasoning-delta", id: "reasoning-0", delta: reasoning });
+              }
+              if (typeof delta.content === "string" && delta.content) {
+                if (reasoningOpen) {
+                  controller.enqueue({ type: "reasoning-end", id: "reasoning-0", ...encrypted ? { providerMetadata: { nexra: { encrypted_content: encrypted } } } : {} });
+                  reasoningOpen = false;
+                }
+                if (!textOpen) {
+                  controller.enqueue({ type: "text-start", id: "text-0" });
+                  textOpen = true;
+                }
+                controller.enqueue({ type: "text-delta", id: "text-0", delta: delta.content });
+              }
+              if (Array.isArray(delta.tool_calls)) {
+                for (const item of delta.tool_calls) {
+                  const part = object2(item);
+                  const index = part.index ?? 0;
+                  if (startedTools.has(index)) {
+                    tracker.processDelta(part);
+                    continue;
+                  }
+                  const saved = pending.get(index);
+                  const merged = { ...saved, ...part, function: {
+                    ...saved?.function,
+                    ...part.function,
+                    arguments: `${saved?.function?.arguments ?? ""}${part.function?.arguments ?? ""}`
+                  } };
+                  if (merged.id && merged.function?.name) {
+                    pending.delete(index);
+                    startedTools.add(index);
+                    tracker.processDelta(merged);
+                  } else pending.set(index, merged);
+                }
+              }
+            }
+            if (!ended || typeof reason !== "string") invalid({ ended, finish_reason: reason }, "Chat Completions stream ended before its terminal response");
+            if (pending.size) invalid([...pending.values()], "Chat Completions stream contains incomplete tool calls");
+            if (encrypted && !reasoningOpen) {
+              controller.enqueue({ type: "reasoning-start", id: "encrypted-0" });
+              controller.enqueue({ type: "reasoning-end", id: "encrypted-0", providerMetadata: { nexra: { encrypted_content: encrypted } } });
+            }
+            if (reasoningOpen) controller.enqueue({ type: "reasoning-end", id: "reasoning-0", ...encrypted ? { providerMetadata: { nexra: { encrypted_content: encrypted } } } : {} });
+            if (textOpen) controller.enqueue({ type: "text-end", id: "text-0" });
+            tracker.flush();
+            controller.enqueue({ type: "finish", finishReason: finishReason(reason), usage: usage(rawUsage) });
+          } catch (error) {
+            if (!canceled) controller.enqueue({ type: "error", error });
+          } finally {
+            if (!canceled) controller.close();
+          }
+        },
+        async cancel(reason) {
+          canceled = true;
+          abort.abort(reason);
+          await iterator.return(void 0);
+        }
+      });
+      return { stream, request: { body }, response: { headers: Object.fromEntries(response.headers) } };
+    }
+  };
+}
+function combineHeaders(options) {
+  const headers = new Headers(options.headers);
+  headers.set("content-type", "application/json");
+  return headers;
+}
+
+// src/language/index.ts
+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, 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 };
+  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);
+  } else {
+    model = createAnthropic({ ...common, name: "nexra.anthropic", baseURL: `${root}/v1` })(binding.spec.id);
+  }
+  return withNativeUsage(model, binding);
+}
+function object3(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function prepare(options, binding, 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);
+  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);
+    providerOptions.openai = {
+      store: false,
+      forceReasoning: binding.endpoint.capabilities.includes("reasoning"),
+      ...current
+    };
+    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}`);
+    }
+    if (reasoning.forceReasoning === false && (reasoning.reasoningEffort !== void 0 || reasoning.reasoningSummary !== void 0 || reasoning.reasoningMode !== void 0 || reasoning.reasoningContext !== void 0 || options.reasoning !== void 0 && options.reasoning !== "provider-default")) {
+      throw new Error(`Nexra Responses adapter cannot preserve reasoning options with forceReasoning disabled for ${binding.spec.id}`);
+    }
+  }
+  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);
+    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,
+        maxOutputTokens: capabilities.maxOutputTokens,
+        maxReasoningBudget: capabilities.maxOutputTokens,
+        warnings: []
+      }) };
+    }
+    const budget = thinking.type === "enabled" ? thinking.budgetTokens ?? 1024 : 0;
+    if (typeof budget !== "number" || !Number.isInteger(budget) || budget < 0) {
+      throw new Error(`Nexra thinking token budget is invalid for ${binding.spec.id}`);
+    }
+    const maximum = Math.min(binding.maxOutputTokens ?? Infinity, capabilities.isKnownModel ? capabilities.maxOutputTokens : Infinity);
+    const visible = options.maxOutputTokens ?? Math.min(capabilities.maxOutputTokens, maximum - budget);
+    if (visible < 1 || visible + budget > maximum) {
+      throw new Error(`Nexra output token limit including thinking is outside the native contract for ${binding.spec.id}`);
+    }
+    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) } };
+  }
+  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;
+  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) };
+  }
+  return merged;
+}
+function withNativeUsage(model, binding) {
+  return {
+    specificationVersion: "v4",
+    provider: model.provider,
+    modelId: model.modelId,
+    supportedUrls: model.supportedUrls,
+    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;
+    },
+    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 });
+      let raw;
+      let terminal = false;
+      let failed = false;
+      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 };
+              }
+            }
+            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);
+        }
+      })) };
+    }
+  };
+}
+export {
+  NexraNativeError,
+  createNexraLanguageModel,
+  createNexraNativeFetch
+};