@byte_fluffy/nexra-sdk 0.1.0-alpha.46.1 → 0.1.0-alpha.48

package/dist/index.js

@@ -20,7 +20,7 @@ import {
   projectMediaGeometry,
   queryString,
   sleep
-} from "./chunk-JK6LUGM5.js";
+} from "./chunk-2IWCEEDI.js";
 import {
   MEDIA_KINDS,
   TASK_STATUSES,

package/dist/language.js

@@ -6,7 +6,7 @@ import {
   jsonBody,
   parseServerSentEvents,
   resolveNexraLanguageReasoning
-} from "./chunk-JK6LUGM5.js";
+} from "./chunk-2IWCEEDI.js";
 import {
   isPublicErrorCode,
   publicErrorMessage,
@@ -17,7 +17,6 @@ import {
 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,190 @@ 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);
@@ -553,30 +764,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 +795,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 +827,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 +849,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 +896,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byte_fluffy/nexra-sdk",
-  "version": "0.1.0-alpha.46.1",
+  "version": "0.1.0-alpha.48",
   "type": "module",
   "types": "./dist/index.d.ts",
   "sideEffects": false,
@@ -72,10 +72,20 @@
     "@ai-sdk/provider-utils": "^5.0.21"
   },
   "peerDependenciesMeta": {
-    "@ai-sdk/anthropic": { "optional": true },
-    "@ai-sdk/google": { "optional": true },
-    "@ai-sdk/openai": { "optional": true },
-    "@ai-sdk/provider": { "optional": true },
-    "@ai-sdk/provider-utils": { "optional": true }
+    "@ai-sdk/anthropic": {
+      "optional": true
+    },
+    "@ai-sdk/google": {
+      "optional": true
+    },
+    "@ai-sdk/openai": {
+      "optional": true
+    },
+    "@ai-sdk/provider": {
+      "optional": true
+    },
+    "@ai-sdk/provider-utils": {
+      "optional": true
+    }
   }
 }