openai 7.5.0 → 7.6.0

package/src/resources/vector-stores/file-batches.ts

@@ -8,9 +8,9 @@ import { APIPromise } from '../../core/api-promise';
 import { CursorPage, type CursorPageParams, PagePromise } from '../../core/pagination';
 import { buildHeaders } from '../../internal/headers';
 import { RequestOptions } from '../../internal/request-options';
-import { sleep } from '../../internal/utils/sleep';
 import { type Uploadable } from '../../uploads';
-import { allSettledWithThrow } from '../../lib/Util';
+import { pollVectorStoreFileBatch } from '../../lib/vector-store-polling';
+import { uploadAndPollVectorStoreFileBatch } from '../../lib/vector-store-upload';
 import { path } from '../../internal/utils/path';
 
 export class FileBatches extends APIResource {
@@ -107,47 +107,7 @@ export class FileBatches extends APIResource {
     batchID: string,
     options?: RequestOptions & { pollIntervalMs?: number },
   ): Promise<VectorStoreFileBatch> {
-    const headers = buildHeaders([
-      options?.headers,
-      {
-        'X-Stainless-Poll-Helper': 'true',
-        'X-Stainless-Custom-Poll-Interval': options?.pollIntervalMs?.toString() ?? undefined,
-      },
-    ]);
-
-    while (true) {
-      const { data: batch, response } = await this.retrieve(
-        batchID,
-        { vector_store_id: vectorStoreID },
-        {
-          ...options,
-          headers,
-        },
-      ).withResponse();
-
-      switch (batch.status) {
-        case 'in_progress':
-          let sleepInterval = 5000;
-
-          if (options?.pollIntervalMs) {
-            sleepInterval = options.pollIntervalMs;
-          } else {
-            const headerInterval = response.headers.get('openai-poll-after-ms');
-            if (headerInterval) {
-              const headerIntervalMs = parseInt(headerInterval);
-              if (!isNaN(headerIntervalMs)) {
-                sleepInterval = headerIntervalMs;
-              }
-            }
-          }
-          await sleep(sleepInterval);
-          break;
-        case 'failed':
-        case 'cancelled':
-        case 'completed':
-          return batch;
-      }
-    }
+    return await pollVectorStoreFileBatch(this, vectorStoreID, batchID, options);
   }
 
   /**
@@ -160,41 +120,12 @@ export class FileBatches extends APIResource {
     { files, fileIds = [] }: { files: Uploadable[]; fileIds?: string[] },
     options?: RequestOptions & { pollIntervalMs?: number; maxConcurrency?: number },
   ): Promise<VectorStoreFileBatch> {
-    if (files == null || files.length == 0) {
-      throw new Error(
-        `No \`files\` provided to process. If you've already uploaded files you should use \`.createAndPoll()\` instead`,
-      );
-    }
-
-    const configuredConcurrency = options?.maxConcurrency ?? 5;
-
-    // We cap the number of workers at the number of files (so we don't start any unnecessary workers)
-    const concurrencyLimit = Math.min(configuredConcurrency, files.length);
-
-    const client = this._client;
-    const fileIterator = files.values();
-    const allFileIds: string[] = [...fileIds];
-
-    // This code is based on this design. The libraries don't accommodate our environment limits.
-    // https://stackoverflow.com/questions/40639432/what-is-the-best-way-to-limit-concurrency-when-using-es6s-promise-all
-    async function processFiles(iterator: IterableIterator<Uploadable>) {
-      for (let item of iterator) {
-        const fileObj = await client.files.create({ file: item, purpose: 'assistants' }, options);
-        allFileIds.push(fileObj.id);
-      }
-    }
-
-    // Start workers to process results
-    const workers = Array(concurrencyLimit).fill(fileIterator).map(processFiles);
-
-    // Wait for all processing to complete.
-    await allSettledWithThrow(workers);
-
-    return await this.createAndPoll(
+    return await uploadAndPollVectorStoreFileBatch(
+      this,
+      this._client,
       vectorStoreId,
-      {
-        file_ids: allFileIds,
-      },
+      files,
+      fileIds,
       options,
     );
   }

package/src/resources/vector-stores/files.ts

@@ -3,11 +3,11 @@
 import { APIResource } from '../../core/resource';
 import * as VectorStoresAPI from './vector-stores';
 import { APIPromise } from '../../core/api-promise';
-import { CursorPage, type CursorPageParams, PagePromise, Page } from '../../core/pagination';
+import { CursorPage, type CursorPageParams, Page, PagePromise } from '../../core/pagination';
 import { buildHeaders } from '../../internal/headers';
 import { RequestOptions } from '../../internal/request-options';
-import { sleep } from '../../internal/utils';
 import { Uploadable } from '../../uploads';
+import { pollVectorStoreFile } from '../../lib/vector-store-polling';
 import { path } from '../../internal/utils/path';
 
 export class Files extends APIResource {
@@ -115,47 +115,7 @@ export class Files extends APIResource {
     fileID: string,
     options?: RequestOptions & { pollIntervalMs?: number },
   ): Promise<VectorStoreFile> {
-    const headers = buildHeaders([
-      options?.headers,
-      {
-        'X-Stainless-Poll-Helper': 'true',
-        'X-Stainless-Custom-Poll-Interval': options?.pollIntervalMs?.toString() ?? undefined,
-      },
-    ]);
-
-    while (true) {
-      const fileResponse = await this.retrieve(
-        fileID,
-        {
-          vector_store_id: vectorStoreID,
-        },
-        { ...options, headers },
-      ).withResponse();
-
-      const file = fileResponse.data;
-
-      switch (file.status) {
-        case 'in_progress':
-          let sleepInterval = 5000;
-
-          if (options?.pollIntervalMs) {
-            sleepInterval = options.pollIntervalMs;
-          } else {
-            const headerInterval = fileResponse.response.headers.get('openai-poll-after-ms');
-            if (headerInterval) {
-              const headerIntervalMs = parseInt(headerInterval);
-              if (!isNaN(headerIntervalMs)) {
-                sleepInterval = headerIntervalMs;
-              }
-            }
-          }
-          await sleep(sleepInterval);
-          break;
-        case 'failed':
-        case 'completed':
-          return file;
-      }
-    }
+    return await pollVectorStoreFile(this, vectorStoreID, fileID, options);
   }
   /**
    * Upload a file to the `files` API and then attach it to the given vector store.

package/src/resources/webhooks/webhooks.ts

@@ -1,10 +1,8 @@
 // File generated from our OpenAPI spec by Castiron. See CONTRIBUTING.md for details.
 
-import { InvalidWebhookSignatureError } from '../../error';
 import { APIResource } from '../../core/resource';
 import { buildHeaders, HeadersLike } from '../../internal/headers';
-import { fromBase64 } from '../../internal/utils/base64';
-import { encodeUTF8 } from '../../internal/utils/bytes';
+import { verifyWebhookSignature, webhookSignatureRequiresSigning } from '../../lib/webhook-signature';
 
 export class Webhooks extends APIResource {
   /**
@@ -39,7 +37,7 @@ export class Webhooks extends APIResource {
   ): Promise<void> {
     if (
       typeof crypto === 'undefined' ||
-      typeof crypto.subtle.importKey !== 'function' ||
+      typeof crypto.subtle?.importKey !== 'function' ||
       typeof crypto.subtle.verify !== 'function'
     ) {
       throw new Error('Webhook signature verification is only supported when the `crypto` global is defined');
@@ -52,65 +50,11 @@ export class Webhooks extends APIResource {
     const timestamp = this.#getRequiredHeader(headersObj, 'webhook-timestamp');
     const webhookId = this.#getRequiredHeader(headersObj, 'webhook-id');
 
-    // Validate timestamp to prevent replay attacks
-    const timestampSeconds = parseInt(timestamp, 10);
-    if (isNaN(timestampSeconds)) {
-      throw new InvalidWebhookSignatureError('Invalid webhook timestamp format');
-    }
-
-    const nowSeconds = Math.floor(Date.now() / 1000);
-
-    if (nowSeconds - timestampSeconds > tolerance) {
-      throw new InvalidWebhookSignatureError('Webhook timestamp is too old');
-    }
-
-    if (timestampSeconds > nowSeconds + tolerance) {
-      throw new InvalidWebhookSignatureError('Webhook timestamp is too new');
-    }
-
-    // Extract signatures from v1,<base64> format
-    // The signature header can have multiple values, separated by spaces.
-    // Each value is in the format v1,<base64>. We should accept if any match.
-    const signatures = signatureHeader
-      .split(' ')
-      .map((part) => (part.startsWith('v1,') ? part.substring(3) : part));
-
-    // Decode the secret if it starts with whsec_
-    const decodedSecret = Uint8Array.from(
-      secret.startsWith('whsec_') ? fromBase64(secret.slice('whsec_'.length)) : encodeUTF8(secret),
-    );
-
-    // Create the signed payload: {webhook_id}.{timestamp}.{payload}
-    const signedPayload = webhookId ? `${webhookId}.${timestamp}.${payload}` : `${timestamp}.${payload}`;
-    const signedPayloadBytes = Uint8Array.from(encodeUTF8(signedPayload));
-
-    // Import the secret as a cryptographic key for HMAC
-    const key = await crypto.subtle.importKey(
-      'raw',
-      decodedSecret,
-      { name: 'HMAC', hash: 'SHA-256' },
-      false,
-      ['verify'],
-    );
-
-    // Check if any signature matches using timing-safe WebCrypto verify
-    for (const signature of signatures) {
-      try {
-        const signatureBytes = Uint8Array.from(fromBase64(signature));
-        const isValid = await crypto.subtle.verify('HMAC', key, signatureBytes, signedPayloadBytes);
-
-        if (isValid) {
-          return; // Valid signature found
-        }
-      } catch {
-        // Invalid base64 or signature format, continue to next signature
-        continue;
-      }
+    if (webhookSignatureRequiresSigning(signatureHeader) && typeof crypto.subtle.sign !== 'function') {
+      throw new Error('Webhook signature verification is only supported when the `crypto` global is defined');
     }
 
-    throw new InvalidWebhookSignatureError(
-      'The given webhook signature does not match the expected signature',
-    );
+    return await verifyWebhookSignature(payload, signatureHeader, timestamp, webhookId, secret, tolerance);
   }
 
   #validateSecret(secret: string | null | undefined): asserts secret is string {

package/src/version.ts

@@ -1,2 +1,2 @@
 /** Version of the installed OpenAI SDK package. */
-export const VERSION = '7.5.0'; // x-release-please-version
+export const VERSION = '7.6.0'; // x-release-please-version

package/version.d.mts

@@ -1,3 +1,3 @@
 /** Version of the installed OpenAI SDK package. */
-export declare const VERSION = "7.5.0";
+export declare const VERSION = "7.6.0";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,3 +1,3 @@
 /** Version of the installed OpenAI SDK package. */
-export declare const VERSION = "7.5.0";
+export declare const VERSION = "7.6.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 /** Version of the installed OpenAI SDK package. */
-exports.VERSION = '7.5.0'; // x-release-please-version
+exports.VERSION = '7.6.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,3 +1,3 @@
 /** Version of the installed OpenAI SDK package. */
-export const VERSION = '7.5.0'; // x-release-please-version
+export const VERSION = '7.6.0'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map