@ai-sdk/openai 4.0.63 → 4.0.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.63",
+  "version": "4.0.65",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.11",
-    "@ai-sdk/provider-utils": "5.0.37"
+    "@ai-sdk/provider": "4.0.13",
+    "@ai-sdk/provider-utils": "5.0.39"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.1",

package/src/chat/openai-chat-language-model.ts

@@ -1,13 +1,14 @@
-import type {
-  LanguageModelV4,
-  LanguageModelV4CallOptions,
-  LanguageModelV4Content,
-  LanguageModelV4FinishReason,
-  LanguageModelV4GenerateResult,
-  LanguageModelV4StreamPart,
-  LanguageModelV4StreamResult,
-  SharedV4ProviderMetadata,
-  SharedV4Warning,
+import {
+  InvalidResponseDataError,
+  type LanguageModelV4,
+  type LanguageModelV4CallOptions,
+  type LanguageModelV4Content,
+  type LanguageModelV4FinishReason,
+  type LanguageModelV4GenerateResult,
+  type LanguageModelV4StreamPart,
+  type LanguageModelV4StreamResult,
+  type SharedV4ProviderMetadata,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   StreamingToolCallTracker,
@@ -396,6 +397,13 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
     });
 
     const choice = response.choices[0];
+    if (choice == null) {
+      throw new InvalidResponseDataError({
+        data: rawResponse,
+        message: 'Response did not contain any choices.',
+      });
+    }
+
     const content: Array<LanguageModelV4Content> = [];
 
     // text content:

package/src/openai-batch.ts

@@ -2,10 +2,13 @@ import {
   InvalidArgumentError,
   InvalidResponseDataError,
   type Experimental_BatchV4 as BatchV4,
+  type Experimental_BatchV4CancelResult as BatchV4CancelResult,
   type Experimental_BatchV4StartResult as BatchV4StartResult,
   type Experimental_BatchV4Error as BatchV4Error,
   type Experimental_BatchV4ItemResult as BatchV4ItemResult,
   type Experimental_BatchV4OperationOptions as BatchV4OperationOptions,
+  type Experimental_BatchV4ListOptions as BatchV4ListOptions,
+  type Experimental_BatchV4ListResult as BatchV4ListResult,
   type Experimental_BatchV4Status as BatchV4Status,
   type Experimental_TextBatchV4ItemResult as TextBatchV4ItemResult,
   type Experimental_BatchV4StartOptions as BatchV4StartOptions,
@@ -86,36 +89,37 @@ type OpenAIBatchResultConversion =
   | { success: true; result: LanguageModelV4GenerateResult }
   | { success: false; error: BatchV4Error };
 
+const openaiBatchResponseZodSchema = () =>
+  z.object({
+    id: z.string(),
+    status: z.string(),
+    output_file_id: z.string().nullish(),
+    error_file_id: z.string().nullish(),
+    created_at: z.number().nullish(),
+    expires_at: z.number().nullish(),
+    request_counts: z
+      .object({
+        total: z.number().nullish(),
+        completed: z.number().nullish(),
+        failed: z.number().nullish(),
+      })
+      .nullish(),
+    errors: z
+      .object({
+        data: z
+          .array(
+            z.object({
+              code: z.string().nullish(),
+              message: z.string().nullish(),
+            }),
+          )
+          .nullish(),
+      })
+      .nullish(),
+  });
+
 const openaiBatchResponseSchema = lazySchema(() =>
-  zodSchema(
-    z.object({
-      id: z.string(),
-      status: z.string(),
-      output_file_id: z.string().nullish(),
-      error_file_id: z.string().nullish(),
-      created_at: z.number().nullish(),
-      expires_at: z.number().nullish(),
-      request_counts: z
-        .object({
-          total: z.number().nullish(),
-          completed: z.number().nullish(),
-          failed: z.number().nullish(),
-        })
-        .nullish(),
-      errors: z
-        .object({
-          data: z
-            .array(
-              z.object({
-                code: z.string().nullish(),
-                message: z.string().nullish(),
-              }),
-            )
-            .nullish(),
-        })
-        .nullish(),
-    }),
-  ),
+  zodSchema(openaiBatchResponseZodSchema()),
 );
 
 type OpenAIBatchResponse = InferSchema<typeof openaiBatchResponseSchema>;
@@ -141,6 +145,16 @@ const openaiBatchResultLineSchema = lazySchema(() =>
   ),
 );
 
+const openaiBatchListResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      data: z.array(openaiBatchResponseZodSchema()),
+      has_more: z.boolean(),
+      last_id: z.string().nullish(),
+    }),
+  ),
+);
+
 type OpenAIBatchResultLine = InferSchema<typeof openaiBatchResultLineSchema>;
 
 export class OpenAIBatch implements BatchV4<OpenAIBatchModelIds> {
@@ -319,6 +333,58 @@ export class OpenAIBatch implements BatchV4<OpenAIBatchModelIds> {
     return convertOpenAIBatchStatus(batch);
   }
 
+  async doCancelBatch(
+    options: BatchV4OperationOptions,
+  ): Promise<BatchV4CancelResult> {
+    await postJsonToApi({
+      url: this.getUrl(
+        `/batches/${encodeURIComponent(options.batchId)}/cancel`,
+      ),
+      headers: combineHeaders(this.options.config.headers?.(), options.headers),
+      body: {},
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiBatchResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.options.config.fetch,
+    });
+
+    return {};
+  }
+
+  async doListBatches(options: BatchV4ListOptions): Promise<BatchV4ListResult> {
+    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 getFromApi({
+      url: url.toString(),
+      headers: combineHeaders(this.options.config.headers?.(), options.headers),
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        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: BatchV4OperationOptions,
   ): Promise<ReadableStream<BatchV4ItemResult>> {