@ai-sdk/openai 4.0.64 → 4.0.66

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @ai-sdk/openai
 
+## 4.0.66
+
+### Patch Changes
+
+- 5ec21a6: fix: reject unsupported batch request types
+- 7469a3b: feat: support image generation requests in batches
+- 0de8886: fix(openai): allow providers to disable web search source includes
+- d5e3024: fix(openai): remove propertyNames from JSON Schema
+- Updated dependencies [5ec21a6]
+- Updated dependencies [7469a3b]
+- Updated dependencies [813bb36]
+- Updated dependencies [c43e4b7]
+  - @ai-sdk/provider@4.0.14
+  - @ai-sdk/provider-utils@5.0.40
+
+## 4.0.65
+
+### Patch Changes
+
+- 9942196: feat(openai): add batch cancellation and listing
+- Updated dependencies [9942196]
+  - @ai-sdk/provider@4.0.13
+  - @ai-sdk/provider-utils@5.0.39
+
 ## 4.0.64
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1379,6 +1379,7 @@ type OpenAIResponsesModelId = 'gpt-3.5-turbo-0125' | 'gpt-3.5-turbo-1106' | 'gpt
 declare const openaiLanguageModelResponsesOptionsSchema: _ai_sdk_provider_utils.LazySchema<{
     conversation?: string | null | undefined;
     include?: ("web_search_call.results" | "file_search_call.results" | "message.output_text.logprobs" | "reasoning.encrypted_content")[] | null | undefined;
+    includeWebSearchSources?: boolean | undefined;
     instructions?: string | null | undefined;
     logprobs?: number | boolean | undefined;
     maxToolCalls?: number | null | undefined;
@@ -1636,6 +1637,13 @@ type OpenAIConfig = {
      * @see https://github.com/vercel/ai/issues/20180
      */
     explicitMessageItemType?: boolean;
+    /**
+     * Whether the provider supports the
+     * `web_search_call.action.sources` Responses API include value.
+     *
+     * Defaults to `true`.
+     */
+    supportsWebSearchSourcesInclude?: boolean;
     /**
      * This is soft-deprecated. Use provider references (e.g. `{ openai: 'file-abc123' }`)
      * in file part data instead. File ID prefixes used to identify file IDs

package/dist/index.js

@@ -918,9 +918,119 @@ var openaiLanguageModelChatOptions = lazySchema2(
 );
 
 // src/chat/openai-chat-prepare-tools.ts
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+} from "@ai-sdk/provider";
+
+// src/normalize-openai-json-schema.ts
 import {
   UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
+function normalizeOpenAIJsonSchema(schema) {
+  let removedPropertyNames = false;
+  const normalizedSchema = normalizeSchema(schema);
+  return {
+    schema: normalizedSchema,
+    warnings: removedPropertyNames ? [
+      {
+        type: "compatibility",
+        feature: "JSON Schema propertyNames",
+        details: "OpenAI does not support JSON Schema propertyNames. It was removed before sending the schema, so OpenAI will not enforce property-name constraints."
+      }
+    ] : []
+  };
+  function normalizeSchema(schema2) {
+    const propertyNames = schema2.propertyNames;
+    if (propertyNames != null) {
+      if (typeof propertyNames === "boolean" || propertyNames.type !== "string") {
+        throw new UnsupportedFunctionalityError2({
+          functionality: "JSON Schema propertyNames that does not use a string schema"
+        });
+      }
+      removedPropertyNames = true;
+    }
+    const normalizedSchema2 = { ...schema2 };
+    delete normalizedSchema2.propertyNames;
+    if (normalizedSchema2.properties != null) {
+      normalizedSchema2.properties = normalizeSchemaRecord(
+        normalizedSchema2.properties
+      );
+    }
+    if (normalizedSchema2.patternProperties != null) {
+      normalizedSchema2.patternProperties = normalizeSchemaRecord(
+        normalizedSchema2.patternProperties
+      );
+    }
+    if (normalizedSchema2.additionalProperties != null) {
+      normalizedSchema2.additionalProperties = normalizeDefinition(
+        normalizedSchema2.additionalProperties
+      );
+    }
+    if (normalizedSchema2.additionalItems != null) {
+      normalizedSchema2.additionalItems = normalizeDefinition(
+        normalizedSchema2.additionalItems
+      );
+    }
+    if (normalizedSchema2.items != null) {
+      normalizedSchema2.items = Array.isArray(normalizedSchema2.items) ? normalizedSchema2.items.map(normalizeDefinition) : normalizeDefinition(normalizedSchema2.items);
+    }
+    if (normalizedSchema2.contains != null) {
+      normalizedSchema2.contains = normalizeDefinition(
+        normalizedSchema2.contains
+      );
+    }
+    if (normalizedSchema2.not != null) {
+      normalizedSchema2.not = normalizeDefinition(normalizedSchema2.not);
+    }
+    if (normalizedSchema2.allOf != null) {
+      normalizedSchema2.allOf = normalizedSchema2.allOf.map(normalizeDefinition);
+    }
+    if (normalizedSchema2.anyOf != null) {
+      normalizedSchema2.anyOf = normalizedSchema2.anyOf.map(normalizeDefinition);
+    }
+    if (normalizedSchema2.oneOf != null) {
+      normalizedSchema2.oneOf = normalizedSchema2.oneOf.map(normalizeDefinition);
+    }
+    if (normalizedSchema2.definitions != null) {
+      normalizedSchema2.definitions = normalizeSchemaRecord(
+        normalizedSchema2.definitions
+      );
+    }
+    if (normalizedSchema2.$defs != null) {
+      normalizedSchema2.$defs = normalizeSchemaRecord(normalizedSchema2.$defs);
+    }
+    if (normalizedSchema2.dependencies != null) {
+      normalizedSchema2.dependencies = Object.fromEntries(
+        Object.entries(normalizedSchema2.dependencies).map(
+          ([key, dependency]) => [
+            key,
+            Array.isArray(dependency) ? dependency : normalizeDefinition(dependency)
+          ]
+        )
+      );
+    }
+    for (const keyword of ["if", "then", "else"]) {
+      const conditionalSchema = normalizedSchema2[keyword];
+      if (conditionalSchema != null) {
+        normalizedSchema2[keyword] = normalizeDefinition(conditionalSchema);
+      }
+    }
+    return normalizedSchema2;
+  }
+  function normalizeSchemaRecord(schemas) {
+    return Object.fromEntries(
+      Object.entries(schemas).map(([key, schema2]) => [
+        key,
+        normalizeDefinition(schema2)
+      ])
+    );
+  }
+  function normalizeDefinition(definition) {
+    return typeof definition === "boolean" ? definition : normalizeSchema(definition);
+  }
+}
+
+// src/chat/openai-chat-prepare-tools.ts
 function prepareChatTools({
   tools,
   toolChoice
@@ -933,17 +1043,22 @@ function prepareChatTools({
   const openaiTools2 = [];
   for (const tool of tools) {
     switch (tool.type) {
-      case "function":
+      case "function": {
+        const normalizedInputSchema = normalizeOpenAIJsonSchema(
+          tool.inputSchema
+        );
+        toolWarnings.push(...normalizedInputSchema.warnings);
         openaiTools2.push({
           type: "function",
           function: {
             name: tool.name,
             description: tool.description,
-            parameters: tool.inputSchema,
+            parameters: normalizedInputSchema.schema,
             ...tool.strict != null ? { strict: tool.strict } : {}
           }
         });
         break;
+      }
       default:
         toolWarnings.push({
           type: "unsupported",
@@ -974,7 +1089,7 @@ function prepareChatTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError2({
+      throw new UnsupportedFunctionalityError3({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -1050,6 +1165,10 @@ var OpenAIChatLanguageModel = class _OpenAIChatLanguageModel {
     );
     warnings.push(...messageWarnings);
     const strictJsonSchema = (_e = openaiOptions.strictJsonSchema) != null ? _e : true;
+    const normalizedResponseFormatSchema = (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null ? normalizeOpenAIJsonSchema(responseFormat.schema) : void 0;
+    if (normalizedResponseFormatSchema != null) {
+      warnings.push(...normalizedResponseFormatSchema.warnings);
+    }
     const baseArgs = {
       // model id:
       model: this.modelId,
@@ -1065,10 +1184,10 @@ var OpenAIChatLanguageModel = class _OpenAIChatLanguageModel {
       top_p: topP,
       frequency_penalty: frequencyPenalty,
       presence_penalty: presencePenalty,
-      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? responseFormat.schema != null ? {
+      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? normalizedResponseFormatSchema != null ? {
         type: "json_schema",
         json_schema: {
-          schema: responseFormat.schema,
+          schema: normalizedResponseFormatSchema.schema,
           strict: strictJsonSchema,
           name: (_f = responseFormat.name) != null ? _f : "response",
           description: responseFormat.description
@@ -1485,7 +1604,7 @@ function convertOpenAICompletionUsage(usage) {
 // src/completion/convert-to-openai-completion-prompt.ts
 import {
   InvalidPromptError,
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError4
 } from "@ai-sdk/provider";
 function convertToOpenAICompletionPrompt({
   prompt,
@@ -1528,7 +1647,7 @@ ${userMessage}
               return part.text;
             }
             case "tool-call": {
-              throw new UnsupportedFunctionalityError3({
+              throw new UnsupportedFunctionalityError4({
                 functionality: "tool-call messages"
               });
             }
@@ -1541,7 +1660,7 @@ ${assistantMessage}
         break;
       }
       case "tool": {
-        throw new UnsupportedFunctionalityError3({
+        throw new UnsupportedFunctionalityError4({
           functionality: "tool messages"
         });
       }
@@ -3562,7 +3681,8 @@ var openaiTools = {
 // src/openai-batch.ts
 import {
   InvalidArgumentError as InvalidArgumentError2,
-  InvalidResponseDataError as InvalidResponseDataError2
+  InvalidResponseDataError as InvalidResponseDataError2,
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError7
 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders7,
@@ -4723,7 +4843,7 @@ function prepareOpenAIConfigForWorkflowDeserialize(config) {
 
 // src/responses/convert-to-openai-responses-input.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError4
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError5
 } from "@ai-sdk/provider";
 import {
   convertToBase64 as convertToBase642,
@@ -5143,7 +5263,7 @@ async function convertToOpenAIResponsesInput({
                     };
                   }
                   case "text": {
-                    throw new UnsupportedFunctionalityError4({
+                    throw new UnsupportedFunctionalityError5({
                       functionality: "text file parts"
                     });
                   }
@@ -5173,7 +5293,7 @@ async function convertToOpenAIResponsesInput({
                       }
                       const fullMediaType = resolveFullMediaType2({ part });
                       if (fullMediaType !== "application/pdf" && !passThroughUnsupportedFiles) {
-                        throw new UnsupportedFunctionalityError4({
+                        throw new UnsupportedFunctionalityError5({
                           functionality: `file part media type ${fullMediaType}`
                         });
                       }
@@ -5909,7 +6029,7 @@ ${text}`,
           }
           const resultCaller = (_P = (_O = part.providerOptions) == null ? void 0 : _O[providerOptionsName]) == null ? void 0 : _P.caller;
           if (output.type === "execution-denied" && ((resultCaller == null ? void 0 : resultCaller.type) === "program" || programmaticToolCallIds.has(part.toolCallId))) {
-            throw new UnsupportedFunctionalityError4({
+            throw new UnsupportedFunctionalityError5({
               functionality: "execution-denied results for programmatic tool calls"
             });
           }
@@ -6060,6 +6180,14 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema25(
           "message.output_text.logprobs"
         ])
       ).nullish(),
+      /**
+       * Whether to automatically include web search action sources in the
+       * response. Disable this for OpenAI-compatible providers that do not
+       * support the `web_search_call.action.sources` include value.
+       *
+       * Defaults to `true`.
+       */
+      includeWebSearchSources: z27.boolean().optional(),
       /**
        * Instructions for the model.
        * They can be used to change the system or developer message when continuing a conversation using the `previousResponseId` option.
@@ -6259,7 +6387,7 @@ var openaiLanguageModelResponsesOptionsSchema = lazySchema25(
 
 // src/responses/openai-responses-prepare-tools.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError5
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError6
 } from "@ai-sdk/provider";
 import {
   resolveProviderReference as resolveProviderReference3,
@@ -6307,6 +6435,7 @@ async function prepareResponsesTools({
         const openaiFunctionTool = prepareFunctionTool({
           tool,
           options: openaiOptions,
+          toolWarnings,
           async: resolveAsyncToolOption({
             value: openaiOptions == null ? void 0 : openaiOptions.async,
             supportsAsyncToolCalling,
@@ -6329,7 +6458,7 @@ async function prepareResponsesTools({
             namespaceTools.set(namespace.name, namespaceTool);
             openaiTools2.push(namespaceTool);
           } else if (namespaceTool.description !== namespace.description) {
-            throw new UnsupportedFunctionalityError5({
+            throw new UnsupportedFunctionalityError6({
               functionality: `conflicting descriptions for OpenAI tool namespace "${namespace.name}"`
             });
           }
@@ -6596,7 +6725,7 @@ async function prepareResponsesTools({
       allowedToolEntries.push(resolution.entry);
     }
     if (allowedToolEntries.length === 0) {
-      throw new UnsupportedFunctionalityError5({
+      throw new UnsupportedFunctionalityError6({
         functionality: `allowedTools with only tools that cannot be allow-listed (${droppedToolNames.join(
           ", "
         )})`
@@ -6631,7 +6760,7 @@ async function prepareResponsesTools({
     }
     default: {
       const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError5({
+      throw new UnsupportedFunctionalityError6({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -6687,19 +6816,27 @@ function toAllowedToolResolution(tool) {
 function prepareFunctionTool({
   tool,
   options,
+  toolWarnings,
   async
 }) {
+  var _a2;
   const deferLoading = options == null ? void 0 : options.deferLoading;
+  const normalizedInputSchema = normalizeOpenAIJsonSchema(tool.inputSchema);
+  const normalizedOutputSchema = (options == null ? void 0 : options.outputSchema) != null ? normalizeOpenAIJsonSchema(options.outputSchema) : void 0;
+  toolWarnings.push(
+    ...normalizedInputSchema.warnings,
+    ...(_a2 = normalizedOutputSchema == null ? void 0 : normalizedOutputSchema.warnings) != null ? _a2 : []
+  );
   return {
     type: "function",
     name: tool.name,
     description: tool.description,
-    parameters: tool.inputSchema,
+    parameters: normalizedInputSchema.schema,
     ...async != null ? { async } : {},
     ...tool.strict != null ? { strict: tool.strict } : {},
     ...deferLoading != null ? { defer_loading: deferLoading } : {},
     ...(options == null ? void 0 : options.allowedCallers) != null ? { allowed_callers: options.allowedCallers } : {},
-    ...(options == null ? void 0 : options.outputSchema) != null ? { output_schema: options.outputSchema } : {}
+    ...(options == null ? void 0 : options.outputSchema) != null ? { output_schema: normalizedOutputSchema == null ? void 0 : normalizedOutputSchema.schema } : {}
   };
 }
 function resolveAsyncToolOption({
@@ -7022,6 +7159,10 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
       input.push({ type: "compaction_trigger" });
     }
     const strictJsonSchema = (_g = openaiOptions == null ? void 0 : openaiOptions.strictJsonSchema) != null ? _g : true;
+    const normalizedResponseFormatSchema = (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null ? normalizeOpenAIJsonSchema(responseFormat.schema) : void 0;
+    if (normalizedResponseFormatSchema != null) {
+      warnings.push(...normalizedResponseFormatSchema.warnings);
+    }
     let include = openaiOptions == null ? void 0 : openaiOptions.include;
     function addInclude(key) {
       if (include == null) {
@@ -7044,7 +7185,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
     const webSearchToolName = (_h = tools == null ? void 0 : tools.find(
       (tool) => tool.type === "provider" && (tool.id === "openai.web_search" || tool.id === "openai.web_search_preview")
     )) == null ? void 0 : _h.name;
-    if (webSearchToolName) {
+    if (webSearchToolName && config.supportsWebSearchSourcesInclude !== false && (openaiOptions == null ? void 0 : openaiOptions.includeWebSearchSources) !== false) {
       addInclude("web_search_call.action.sources");
     }
     if (hasOpenAITool("openai.code_interpreter")) {
@@ -7063,12 +7204,12 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
       ...((responseFormat == null ? void 0 : responseFormat.type) === "json" || (openaiOptions == null ? void 0 : openaiOptions.textVerbosity)) && {
         text: {
           ...(responseFormat == null ? void 0 : responseFormat.type) === "json" && {
-            format: responseFormat.schema != null ? {
+            format: normalizedResponseFormatSchema != null ? {
               type: "json_schema",
               strict: strictJsonSchema,
               name: (_i = responseFormat.name) != null ? _i : "response",
               description: responseFormat.description,
-              schema: responseFormat.schema
+              schema: normalizedResponseFormatSchema.schema
             } : { type: "json_object" }
           },
           ...(openaiOptions == null ? void 0 : openaiOptions.textVerbosity) && {
@@ -9097,30 +9238,40 @@ var openaiBatchProviderOptionsSchema = lazySchema26(
     })
   )
 );
+function assertTextBatchRequests(requests) {
+  for (const request of requests) {
+    const requestType = request.type;
+    if (requestType !== "text") {
+      throw new UnsupportedFunctionalityError7({
+        functionality: `batch request type: ${requestType}`,
+        message: `The OpenAI Batch API does not support batch requests with type "${requestType}".`
+      });
+    }
+  }
+}
+var openaiBatchResponseZodSchema = () => z28.object({
+  id: z28.string(),
+  status: z28.string(),
+  output_file_id: z28.string().nullish(),
+  error_file_id: z28.string().nullish(),
+  created_at: z28.number().nullish(),
+  expires_at: z28.number().nullish(),
+  request_counts: z28.object({
+    total: z28.number().nullish(),
+    completed: z28.number().nullish(),
+    failed: z28.number().nullish()
+  }).nullish(),
+  errors: z28.object({
+    data: z28.array(
+      z28.object({
+        code: z28.string().nullish(),
+        message: z28.string().nullish()
+      })
+    ).nullish()
+  }).nullish()
+});
 var openaiBatchResponseSchema = lazySchema26(
-  () => zodSchema26(
-    z28.object({
-      id: z28.string(),
-      status: z28.string(),
-      output_file_id: z28.string().nullish(),
-      error_file_id: z28.string().nullish(),
-      created_at: z28.number().nullish(),
-      expires_at: z28.number().nullish(),
-      request_counts: z28.object({
-        total: z28.number().nullish(),
-        completed: z28.number().nullish(),
-        failed: z28.number().nullish()
-      }).nullish(),
-      errors: z28.object({
-        data: z28.array(
-          z28.object({
-            code: z28.string().nullish(),
-            message: z28.string().nullish()
-          })
-        ).nullish()
-      }).nullish()
-    })
-  )
+  () => zodSchema26(openaiBatchResponseZodSchema())
 );
 var openaiBatchResultLineSchema = lazySchema26(
   () => zodSchema26(
@@ -9138,6 +9289,15 @@ var openaiBatchResultLineSchema = lazySchema26(
     })
   )
 );
+var openaiBatchListResponseSchema = lazySchema26(
+  () => zodSchema26(
+    z28.object({
+      data: z28.array(openaiBatchResponseZodSchema()),
+      has_more: z28.boolean(),
+      last_id: z28.string().nullish()
+    })
+  )
+);
 var OpenAIBatch = class {
   constructor(options) {
     this.options = options;
@@ -9147,6 +9307,7 @@ var OpenAIBatch = class {
   }
   async doStartBatch(options) {
     var _a2, _b, _c, _d, _e, _f;
+    assertTextBatchRequests(options.requests);
     validateSingleModel(options.requests);
     const fileParts = [];
     const warnings = options.webhookUrl == null ? [] : [
@@ -9273,6 +9434,51 @@ var OpenAIBatch = class {
     const batch = await this.retrieveBatch(options);
     return convertOpenAIBatchStatus(batch);
   }
+  async doCancelBatch(options) {
+    var _a2, _b;
+    await postJsonToApi6({
+      url: this.getUrl(
+        `/batches/${encodeURIComponent(options.batchId)}/cancel`
+      ),
+      headers: combineHeaders7((_b = (_a2 = this.options.config).headers) == null ? void 0 : _b.call(_a2), options.headers),
+      body: {},
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler7(
+        openaiBatchResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.options.config.fetch
+    });
+    return {};
+  }
+  async doListBatches(options) {
+    var _a2, _b;
+    const url = new URL(this.getUrl("/batches"));
+    if (options.limit != null) {
+      url.searchParams.set("limit", String(options.limit));
+    }
+    if (options.cursor != null) {
+      url.searchParams.set("after", options.cursor);
+    }
+    const { value: page } = await getFromApi2({
+      url: url.toString(),
+      headers: combineHeaders7((_b = (_a2 = this.options.config).headers) == null ? void 0 : _b.call(_a2), options.headers),
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler7(
+        openaiBatchListResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.options.config.fetch,
+      validateUrl: false
+    });
+    return {
+      batches: page.data.map((batch) => ({
+        batchId: batch.id,
+        ...convertOpenAIBatchStatus(batch)
+      })),
+      ...page.has_more && page.last_id != null ? { nextCursor: page.last_id } : {}
+    };
+  }
   async doGetBatchResults(options) {
     const batch = await this.retrieveBatch(options);
     const batchStatus = convertOpenAIBatchStatus(batch);
@@ -10219,7 +10425,7 @@ var OpenAISpeechModel = class _OpenAISpeechModel {
 
 // src/transcription/openai-transcription-model.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError6
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError8
 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders9,
@@ -10509,7 +10715,7 @@ var OpenAITranscriptionModel = class _OpenAITranscriptionModel {
   async doGenerate(options) {
     var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     if (isRealtimeTranscriptionModelId(this.modelId)) {
-      throw new UnsupportedFunctionalityError6({
+      throw new UnsupportedFunctionalityError8({
         functionality: `non-streaming transcription with ${this.modelId}`
       });
     }
@@ -10576,7 +10782,7 @@ var OpenAITranscriptionModel = class _OpenAITranscriptionModel {
   async doStream(options) {
     var _a2, _b, _c, _d, _e, _f, _g;
     if (!isRealtimeTranscriptionModelId(this.modelId)) {
-      throw new UnsupportedFunctionalityError6({
+      throw new UnsupportedFunctionalityError8({
         functionality: `streaming transcription with ${this.modelId}`
       });
     }
@@ -11217,7 +11423,7 @@ var OpenAISkills = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.64" : "0.0.0-test";
+var VERSION = true ? "4.0.66" : "0.0.0-test";
 
 // src/openai-provider.ts
 function createOpenAI(options = {}) {