ai 7.0.88 → 7.0.89

package/dist/internal/index.js

@@ -91,7 +91,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.88" : "0.0.0-test";
+var VERSION = true ? "7.0.89" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/docs/03-ai-sdk-core/39-file-uploads.mdx

@@ -94,6 +94,31 @@ const { providerReference } = await uploadFile({
 });
 ```
 
+## Streaming Uploads
+
+Providers that support streaming uploads (e.g. OpenAI, xAI) accept a tagged
+`{ type: 'stream', stream }` shape, sending the bytes without buffering the
+full file in memory. Providers without streaming support reject stream data
+with an `UnsupportedFunctionalityError`.
+
+```ts
+const { providerReference } = await uploadFile({
+  api: openai.files(),
+  data: { type: 'stream', stream: fileStream },
+  mediaType: 'application/jsonl',
+  filename: 'batch.jsonl',
+});
+```
+
+The provider consumes the stream: any failed upload — including validation
+failures before a request is made — cancels it, and it must not be reused. Stream data cannot be sniffed, so `mediaType` defaults to
+`application/octet-stream` when omitted, and multipart-based providers default
+the filename to `"blob"`.
+
+Uploads can be cancelled with `abortSignal` and carry request-specific
+`headers`. Results include `byteSize`, `createdAt`, and `expiresAt` (the
+provider-applied retention expiry) when the provider reports them.
+
 ## Provider References
 
 A `ProviderReference` is a `Record<string, string>` that maps provider names to

package/docs/07-reference/01-ai-sdk-core/14-upload-file.mdx

@@ -39,22 +39,35 @@ const { providerReference } = await uploadFile({
     },
     {
       name: 'data',
-      type: 'DataContent',
+      type: 'DataContent | { type: "stream"; stream: ReadableStream<Uint8Array> }',
       description:
-        'The file data to upload. Can be a `Uint8Array`, a base64-encoded string, an `ArrayBuffer`, or a `Buffer`. URLs are not supported — fetch the content first and pass the bytes.',
+        'The file data to upload. Can be a `Uint8Array`, a base64-encoded string, an `ArrayBuffer`, a `Buffer`, or a tagged `{ type: "stream", stream }` shape for providers that support streaming uploads (sent without buffering; other providers reject with an `UnsupportedFunctionalityError`). The provider consumes the stream — any failed upload (including validation failures before a request is made) cancels it, and it must not be reused. URLs are not supported — fetch the content first and pass the bytes.',
     },
     {
       name: 'mediaType',
       type: 'string',
       isOptional: true,
       description:
-        'IANA media type of the file (e.g. `image/png`, `application/pdf`). Auto-detected from the file bytes if not provided.',
+        'IANA media type of the file (e.g. `image/png`, `application/pdf`). Auto-detected from the file bytes if not provided; stream data cannot be sniffed and defaults to `application/octet-stream`.',
     },
     {
       name: 'filename',
       type: 'string',
       isOptional: true,
-      description: 'Filename for the uploaded file.',
+      description:
+        'Filename for the uploaded file. Multipart-based providers default it to `"blob"` when omitted.',
+    },
+    {
+      name: 'abortSignal',
+      type: 'AbortSignal',
+      isOptional: true,
+      description: 'Signal to cancel the upload.',
+    },
+    {
+      name: 'headers',
+      type: 'Record<string, string>',
+      isOptional: true,
+      description: 'Additional HTTP headers to send with the request.',
     },
     {
       name: 'providerOptions',
@@ -76,6 +89,26 @@ const { providerReference } = await uploadFile({
       description:
         'A `Record<string, string>` mapping provider names to provider-specific file identifiers. Pass this as the `data` or `image` field in message content parts.',
     },
+    {
+      name: 'byteSize',
+      type: 'number',
+      isOptional: true,
+      description:
+        'Size of the uploaded file in bytes, if reported by the provider.',
+    },
+    {
+      name: 'createdAt',
+      type: 'Date',
+      isOptional: true,
+      description: 'When the file was created, if reported by the provider.',
+    },
+    {
+      name: 'expiresAt',
+      type: 'Date',
+      isOptional: true,
+      description:
+        'When the provider will delete the file (retention expiry, e.g. from a requested upload TTL), if reported by the provider.',
+    },
     {
       name: 'providerMetadata',
       type: 'ProviderMetadata',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.88",
+  "version": "7.0.89",
   "type": "module",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
@@ -42,20 +42,20 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.70",
-    "@ai-sdk/provider": "4.0.9",
-    "@ai-sdk/provider-utils": "5.0.34"
+    "@ai-sdk/gateway": "4.0.71",
+    "@ai-sdk/provider": "4.0.10",
+    "@ai-sdk/provider-utils": "5.0.35"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.70",
-    "@ai-sdk/deepseek": "3.0.37",
-    "@ai-sdk/google": "4.0.60",
-    "@ai-sdk/groq": "4.0.35",
-    "@ai-sdk/huggingface": "2.0.41",
-    "@ai-sdk/moonshotai": "3.0.43",
-    "@ai-sdk/openai": "4.0.54",
+    "@ai-sdk/amazon-bedrock": "5.0.71",
+    "@ai-sdk/deepseek": "3.0.38",
+    "@ai-sdk/google": "4.0.61",
+    "@ai-sdk/groq": "4.0.36",
+    "@ai-sdk/huggingface": "2.0.42",
+    "@ai-sdk/moonshotai": "3.0.44",
+    "@ai-sdk/openai": "4.0.55",
     "@ai-sdk/test-server": "2.0.1",
-    "@ai-sdk/xai": "4.0.51",
+    "@ai-sdk/xai": "4.0.52",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/upload-file/upload-file-result.ts

@@ -6,6 +6,18 @@ export interface UploadFileResult {
   readonly providerReference: ProviderReference;
   readonly mediaType?: string;
   readonly filename?: string;
+  /**
+   * The size of the uploaded file in bytes, if reported by the provider.
+   */
+  readonly byteSize?: number;
+  /**
+   * When the file was created, if reported by the provider.
+   */
+  readonly createdAt?: Date;
+  /**
+   * When the provider will delete the file (retention expiry), if reported.
+   */
+  readonly expiresAt?: Date;
   readonly providerMetadata?: ProviderMetadata;
   readonly warnings: Array<Warning>;
 }

package/src/upload-file/upload-file.ts

@@ -16,19 +16,31 @@ import type { UploadFileResult } from './upload-file-result';
  * Uploads a file using a files API interface.
  *
  * @param api - The Files API interface to use for uploading.
- * @param data - The file data to upload (tagged `{ type: 'data' | 'text' }`).
+ * @param data - The file data to upload (tagged `{ type: 'data' | 'text' | 'stream' }`).
+ * Stream data is sent without buffering by providers that support streaming
+ * uploads (others reject with `UnsupportedFunctionalityError`); the provider
+ * consumes the stream — any failed upload, including validation failures
+ * before a request is made, cancels it. Do not reuse it.
  * @param mediaType - Optional IANA media type. Auto-detected from file bytes
- * when omitted (falls back to `text/plain` for the `text` variant).
- * @param filename - Optional filename for the uploaded file.
+ * when omitted (falls back to `text/plain` for the `text` variant and
+ * `application/octet-stream` for the `stream` variant, which cannot be sniffed).
+ * @param filename - Optional filename for the uploaded file. Multipart-based
+ * providers default it to `"blob"` when omitted.
+ * @param abortSignal - Optional signal to cancel the upload.
+ * @param headers - Optional additional HTTP headers for the request.
  * @param providerOptions - Additional provider-specific options.
  *
- * @returns A result object containing the provider reference and optional metadata.
+ * @returns A result object containing the provider reference, optional
+ * metadata, and — when reported by the provider — `byteSize`, `createdAt`,
+ * and `expiresAt` (the provider-applied retention expiry).
  */
 export async function uploadFile({
   api,
   data: dataArg,
   mediaType: mediaTypeArg,
   filename,
+  abortSignal,
+  headers,
   providerOptions,
 }: {
   /**
@@ -54,35 +66,55 @@ export async function uploadFile({
       ? { type: 'data', data: dataArg }
       : dataArg;
 
+  // stream data cannot be sniffed without consuming it
   const mediaType =
     mediaTypeArg ??
     (data.type === 'text'
       ? 'text/plain'
-      : (detectMediaType({ data: data.data }) ??
-        (isLikelyText(data.data) ? 'text/plain' : 'application/octet-stream')));
+      : data.type === 'stream'
+        ? 'application/octet-stream'
+        : (detectMediaType({ data: data.data }) ??
+          (isLikelyText(data.data)
+            ? 'text/plain'
+            : 'application/octet-stream')));
 
-  const filesApi: FilesV4 =
-    'uploadFile' in api
-      ? api
-      : typeof api.files === 'function'
-        ? api.files()
-        : (() => {
-            throw new Error(
-              'The provider does not support file uploads. Make sure it exposes a files() method.',
-            );
-          })();
+  let result;
+  try {
+    const filesApi: FilesV4 =
+      'uploadFile' in api
+        ? api
+        : typeof api.files === 'function'
+          ? api.files()
+          : (() => {
+              throw new Error(
+                'The provider does not support file uploads. Make sure it exposes a files() method.',
+              );
+            })();
 
-  const result = await filesApi.uploadFile({
-    data,
-    mediaType,
-    filename,
-    providerOptions,
-  });
+    result = await filesApi.uploadFile({
+      data,
+      mediaType,
+      filename,
+      abortSignal,
+      headers,
+      providerOptions,
+    });
+  } catch (error) {
+    // ownership guarantee: a failed upload releases the stream, even when
+    // the provider rejected before (or without) consuming it
+    if (data.type === 'stream') {
+      await data.stream.cancel(error).catch(() => {});
+    }
+    throw error;
+  }
 
   return new DefaultUploadFileResult({
     providerReference: result.providerReference,
     mediaType: result.mediaType,
     filename: result.filename,
+    byteSize: result.byteSize,
+    createdAt: result.createdAt,
+    expiresAt: result.expiresAt,
     providerMetadata: result.providerMetadata,
     warnings: result.warnings,
   });
@@ -92,6 +124,9 @@ class DefaultUploadFileResult implements UploadFileResult {
   readonly providerReference: ProviderReference;
   readonly mediaType?: string;
   readonly filename?: string;
+  readonly byteSize?: number;
+  readonly createdAt?: Date;
+  readonly expiresAt?: Date;
   readonly providerMetadata?: ProviderMetadata;
   readonly warnings: Array<Warning>;
 
@@ -99,12 +134,18 @@ class DefaultUploadFileResult implements UploadFileResult {
     providerReference: ProviderReference;
     mediaType?: string;
     filename?: string;
+    byteSize?: number;
+    createdAt?: Date;
+    expiresAt?: Date;
     providerMetadata?: ProviderMetadata;
     warnings: Array<Warning>;
   }) {
     this.providerReference = options.providerReference;
     this.mediaType = options.mediaType;
     this.filename = options.filename;
+    this.byteSize = options.byteSize;
+    this.createdAt = options.createdAt;
+    this.expiresAt = options.expiresAt;
     this.providerMetadata = options.providerMetadata;
     this.warnings = options.warnings;
   }