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

package/dist/catalog.js

@@ -9,7 +9,7 @@ import {
   listModelSpecs,
   projectMediaGeometry,
   resolveNexraLanguageReasoning
-} from "./chunk-QXEDXMFI.js";
+} from "./chunk-FEMICSXW.js";
 import "./chunk-QBW7OCT3.js";
 export {
   CatalogClient,

package/dist/{chunk-QXEDXMFI.js → chunk-FEMICSXW.js}

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

package/dist/index.js

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

package/dist/language.js

@@ -1,12 +1,12 @@
 import {
   HttpTransport,
   SDK_VERSION,
-  createServerSentEventDecoder,
+  createServerSentEventFrameDecoder,
   getLanguageModelBinding,
   jsonBody,
   parseServerSentEvents,
   resolveNexraLanguageReasoning
-} from "./chunk-QXEDXMFI.js";
+} from "./chunk-FEMICSXW.js";
 import {
   isPublicErrorCode,
   publicErrorMessage,
@@ -212,7 +212,7 @@ var NexraNativeError = class extends APICallError {
     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 originalMessage = record(body.error).message ?? record(record(body.response).error).message ?? body.message;
     const message = nexraError?.message ?? (typeof originalMessage === "string" ? originalMessage : typeof context.body === "string" ? context.body : "The native model request failed.");
     super({
       message,
@@ -259,31 +259,68 @@ function createNexraNativeFetch(options = {}) {
 }
 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 decode = createServerSentEventFrameDecoder();
+  const reader = response.body.getReader();
+  const pending = [];
+  let finished = false;
+  let released = false;
+  let failure;
+  const release = () => {
+    if (!released) {
+      reader.releaseLock();
+      released = true;
+    }
+  };
+  const inspect = (event) => {
+    if (!event) return;
+    let body;
+    try {
+      body = JSON.parse(event.data);
+    } catch {
+      return event.event === "error" ? new NexraNativeError({ ...context, body: event.data, responseBody: event.data }) : void 0;
+    }
+    const payload = record(body);
+    if (event.event === "error" || payload.type === "error" || payload.type === "response.failed" || payload.error) {
+      return new NexraNativeError({ ...context, body, responseBody: event.data });
     }
   };
-  const stream = response.body.pipeThrough(new TransformStream({
-    transform(bytes, controller) {
-      inspect(decode(bytes));
-      controller.enqueue(bytes);
+  const stream = new ReadableStream({
+    async pull(controller) {
+      try {
+        while (!pending.length && !finished) {
+          const { value, done } = await reader.read();
+          for (const frame of decode(value, done)) {
+            failure = inspect(frame.event);
+            if (failure) {
+              finished = true;
+              await reader.cancel(failure).catch(() => void 0);
+              release();
+              break;
+            }
+            pending.push(frame.bytes);
+          }
+          if (done) {
+            finished = true;
+            release();
+          }
+        }
+        if (pending.length) controller.enqueue(pending.shift());
+        else if (failure) controller.error(failure);
+        else controller.close();
+      } catch (error) {
+        await reader.cancel(error).catch(() => void 0);
+        release();
+        controller.error(error);
+      }
     },
-    flush() {
-      inspect(decode(void 0, true));
+    async cancel(reason) {
+      pending.length = 0;
+      if (!released) {
+        await reader.cancel(reason);
+        release();
+      }
     }
-  }));
+  }, { highWaterMark: 0 });
   return new Response(stream, { status: response.status, statusText: response.statusText, headers: response.headers });
 }
 
@@ -500,15 +537,33 @@ function createNexraLanguageModel(modelId, options) {
   if (binding.endpoint.protocol === "gemini-generate-content") {
     model = createGoogleGenerativeAI({ ...common, name: "nexra.google", baseURL: `${root}/v1beta/models` })(binding.spec.id);
   } else if (binding.endpoint.protocol === "openai-responses") {
-    model = createOpenAI({ ...common, name: "nexra.openai", baseURL: `${root}/v1` }).responses(binding.spec.id);
+    const responsesFetch = (input, init) => fetch(
+      input,
+      typeof init?.body === "string" ? { ...init, body: JSON.stringify(explicitResponsesMessages(JSON.parse(init.body))) } : init
+    );
+    model = createOpenAI({ ...common, name: "nexra.openai", baseURL: `${root}/v1`, fetch: responsesFetch }).responses(binding.spec.id);
   } else {
     model = createAnthropic({ ...common, name: "nexra.anthropic", baseURL: `${root}/v1` })(binding.spec.id);
   }
-  return withNativeUsage(model, binding);
+  return withNativeContract(model, binding);
 }
 function object3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+function explicitResponsesMessages(value) {
+  const body = object3(value);
+  if (!Array.isArray(body.input)) return value;
+  return { ...body, input: body.input.map((value2) => {
+    const item = object3(value2);
+    return item.type === void 0 && ["system", "developer", "user", "assistant"].includes(String(item.role)) && (typeof item.content === "string" || Array.isArray(item.content)) ? { ...item, type: "message" } : value2;
+  }) };
+}
+function nativeRequest(protocol, request, stream = false) {
+  return protocol === "openai-responses" && request ? {
+    ...request,
+    body: explicitResponsesMessages(stream ? { ...object3(request.body), stream: true } : request.body)
+  } : request;
+}
 function prepare(options, binding, stream) {
   options = prepareLanguageReasoning(options, binding);
   const properties = object3(binding.endpoint.inputSchema?.properties);
@@ -572,7 +627,7 @@ function mergeRecords(previous, next) {
   }
   return merged;
 }
-function withNativeUsage(model, binding) {
+function withNativeContract(model, binding) {
   return {
     specificationVersion: "v4",
     provider: model.provider,
@@ -581,7 +636,11 @@ function withNativeUsage(model, binding) {
     async doGenerate(options) {
       const result = await model.doGenerate(prepare(options, binding, false));
       const raw = nativeUsage(binding.endpoint.protocol, result.response?.body);
-      return raw ? { ...result, usage: { ...result.usage, raw } } : result;
+      return {
+        ...result,
+        request: nativeRequest(binding.endpoint.protocol, result.request),
+        ...raw ? { usage: { ...result.usage, raw } } : {}
+      };
     },
     async doStream(options) {
       if (!binding.supportsStreaming) throw new Error(`Nexra model does not support streaming: ${binding.spec.id}`);
@@ -592,35 +651,39 @@ function withNativeUsage(model, binding) {
       let finish;
       const textMetadata = /* @__PURE__ */ new Map();
       const reasoningMetadata2 = /* @__PURE__ */ new Map();
-      return { ...result, stream: result.stream.pipeThrough(new TransformStream({
-        transform(part, controller) {
-          if (part.type === "raw") {
-            const payload = object3(part.rawValue);
-            terminal ||= binding.endpoint.protocol === "anthropic-messages" ? payload.type === "message_stop" : binding.endpoint.protocol === "openai-responses" ? ["response.completed", "response.incomplete", "response.failed"].includes(String(payload.type)) : Array.isArray(payload.candidates) && payload.candidates.some((candidate) => typeof object3(candidate).finishReason === "string");
-            const next = nativeUsage(binding.endpoint.protocol, part.rawValue);
-            if (next) raw = mergeRecords(raw, next);
-            if (options.includeRawChunks) controller.enqueue(part);
-          } else if (part.type === "finish") finish = part;
-          else {
-            if (part.type === "error") failed = true;
-            if (part.type === "text-start" || part.type === "text-delta" || part.type === "text-end" || part.type === "reasoning-start" || part.type === "reasoning-delta" || part.type === "reasoning-end") {
-              const metadata = part.type.startsWith("text-") ? textMetadata : reasoningMetadata2;
-              if (part.providerMetadata) metadata.set(part.id, mergeRecords(metadata.get(part.id), part.providerMetadata));
-              if (part.type === "text-end" || part.type === "reasoning-end") {
-                const retained = metadata.get(part.id);
-                metadata.delete(part.id);
-                if (retained) part = { ...part, providerMetadata: retained };
+      return {
+        ...result,
+        request: nativeRequest(binding.endpoint.protocol, result.request, true),
+        stream: result.stream.pipeThrough(new TransformStream({
+          transform(part, controller) {
+            if (part.type === "raw") {
+              const payload = object3(part.rawValue);
+              terminal ||= binding.endpoint.protocol === "anthropic-messages" ? payload.type === "message_stop" : binding.endpoint.protocol === "openai-responses" ? ["response.completed", "response.incomplete", "response.failed"].includes(String(payload.type)) : Array.isArray(payload.candidates) && payload.candidates.some((candidate) => typeof object3(candidate).finishReason === "string");
+              const next = nativeUsage(binding.endpoint.protocol, part.rawValue);
+              if (next) raw = mergeRecords(raw, next);
+              if (options.includeRawChunks) controller.enqueue(part);
+            } else if (part.type === "finish") finish = part;
+            else {
+              if (part.type === "error") failed = true;
+              if (part.type === "text-start" || part.type === "text-delta" || part.type === "text-end" || part.type === "reasoning-start" || part.type === "reasoning-delta" || part.type === "reasoning-end") {
+                const metadata = part.type.startsWith("text-") ? textMetadata : reasoningMetadata2;
+                if (part.providerMetadata) metadata.set(part.id, mergeRecords(metadata.get(part.id), part.providerMetadata));
+                if (part.type === "text-end" || part.type === "reasoning-end") {
+                  const retained = metadata.get(part.id);
+                  metadata.delete(part.id);
+                  if (retained) part = { ...part, providerMetadata: retained };
+                }
               }
+              controller.enqueue(part);
             }
-            controller.enqueue(part);
+          },
+          flush(controller) {
+            if (failed) return;
+            if (!terminal || !finish) controller.enqueue({ type: "error", error: new Error(`Nexra ${binding.endpoint.protocol} stream ended before its terminal response`) });
+            else controller.enqueue(raw ? { ...finish, usage: { ...finish.usage, raw } } : finish);
           }
-        },
-        flush(controller) {
-          if (failed) return;
-          if (!terminal || !finish) controller.enqueue({ type: "error", error: new Error(`Nexra ${binding.endpoint.protocol} stream ended before its terminal response`) });
-          else controller.enqueue(raw ? { ...finish, usage: { ...finish.usage, raw } } : finish);
-        }
-      })) };
+        }))
+      };
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byte_fluffy/nexra-sdk",
-  "version": "0.1.0-alpha.31",
+  "version": "0.1.0-alpha.33",
   "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
+    }
   }
 }