openai 4.86.2 → 4.87.1

package/src/lib/responses/ResponseStream.ts

@@ -0,0 +1,298 @@
+import {
+  type ParsedResponse,
+  type Response,
+  type ResponseCreateParamsBase,
+  type ResponseCreateParamsStreaming,
+  type ResponseStreamEvent,
+} from '../../resources/responses/responses';
+import * as Core from '../../core';
+import { APIUserAbortError, OpenAIError } from '../../error';
+import OpenAI from '../../index';
+import { type BaseEvents, EventStream } from '../EventStream';
+import { type ResponseFunctionCallArgumentsDeltaEvent, type ResponseTextDeltaEvent } from './EventTypes';
+import { maybeParseResponse } from '../ResponsesParser';
+
+export type ResponseStreamParams = Omit<ResponseCreateParamsBase, 'stream'> & {
+  stream?: true;
+};
+
+type ResponseEvents = BaseEvents &
+  Omit<
+    {
+      [K in ResponseStreamEvent['type']]: (event: Extract<ResponseStreamEvent, { type: K }>) => void;
+    },
+    'response.output_text.delta' | 'response.function_call_arguments.delta'
+  > & {
+    event: (event: ResponseStreamEvent) => void;
+    'response.output_text.delta': (event: ResponseTextDeltaEvent) => void;
+    'response.function_call_arguments.delta': (event: ResponseFunctionCallArgumentsDeltaEvent) => void;
+  };
+
+export type ResponseStreamingParams = Omit<ResponseCreateParamsBase, 'stream'> & {
+  stream?: true;
+};
+
+export class ResponseStream<ParsedT = null>
+  extends EventStream<ResponseEvents>
+  implements AsyncIterable<ResponseStreamEvent>
+{
+  #params: ResponseStreamingParams | null;
+  #currentResponseSnapshot: Response | undefined;
+  #finalResponse: ParsedResponse<ParsedT> | undefined;
+
+  constructor(params: ResponseStreamingParams | null) {
+    super();
+    this.#params = params;
+  }
+
+  static createResponse<ParsedT>(
+    client: OpenAI,
+    params: ResponseStreamParams,
+    options?: Core.RequestOptions,
+  ): ResponseStream<ParsedT> {
+    const runner = new ResponseStream<ParsedT>(params as ResponseCreateParamsStreaming);
+    runner._run(() =>
+      runner._createResponse(client, params, {
+        ...options,
+        headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' },
+      }),
+    );
+    return runner;
+  }
+
+  #beginRequest() {
+    if (this.ended) return;
+    this.#currentResponseSnapshot = undefined;
+  }
+
+  #addEvent(this: ResponseStream<ParsedT>, event: ResponseStreamEvent) {
+    if (this.ended) return;
+
+    const response = this.#accumulateResponse(event);
+    this._emit('event', event);
+
+    switch (event.type) {
+      case 'response.output_text.delta': {
+        const output = response.output[event.output_index];
+        if (!output) {
+          throw new OpenAIError(`missing output at index ${event.output_index}`);
+        }
+        if (output.type === 'message') {
+          const content = output.content[event.content_index];
+          if (!content) {
+            throw new OpenAIError(`missing content at index ${event.content_index}`);
+          }
+          if (content.type !== 'output_text') {
+            throw new OpenAIError(`expected content to be 'output_text', got ${content.type}`);
+          }
+
+          this._emit('response.output_text.delta', {
+            ...event,
+            snapshot: content.text,
+          });
+        }
+        break;
+      }
+      case 'response.function_call_arguments.delta': {
+        const output = response.output[event.output_index];
+        if (!output) {
+          throw new OpenAIError(`missing output at index ${event.output_index}`);
+        }
+        if (output.type === 'function_call') {
+          this._emit('response.function_call_arguments.delta', {
+            ...event,
+            snapshot: output.arguments,
+          });
+        }
+        break;
+      }
+      default:
+        // @ts-ignore
+        this._emit(event.type, event);
+        break;
+    }
+  }
+
+  #endRequest(): ParsedResponse<ParsedT> {
+    if (this.ended) {
+      throw new OpenAIError(`stream has ended, this shouldn't happen`);
+    }
+    const snapshot = this.#currentResponseSnapshot;
+    if (!snapshot) {
+      throw new OpenAIError(`request ended without sending any events`);
+    }
+    this.#currentResponseSnapshot = undefined;
+    const parsedResponse = finalizeResponse<ParsedT>(snapshot, this.#params);
+    this.#finalResponse = parsedResponse;
+
+    return parsedResponse;
+  }
+
+  protected async _createResponse(
+    client: OpenAI,
+    params: ResponseStreamingParams,
+    options?: Core.RequestOptions,
+  ): Promise<ParsedResponse<ParsedT>> {
+    const signal = options?.signal;
+    if (signal) {
+      if (signal.aborted) this.controller.abort();
+      signal.addEventListener('abort', () => this.controller.abort());
+    }
+    this.#beginRequest();
+
+    const stream = await client.responses.create(
+      { ...params, stream: true },
+      { ...options, signal: this.controller.signal },
+    );
+    this._connected();
+    for await (const event of stream) {
+      this.#addEvent(event);
+    }
+    if (stream.controller.signal?.aborted) {
+      throw new APIUserAbortError();
+    }
+    return this.#endRequest();
+  }
+
+  #accumulateResponse(event: ResponseStreamEvent): Response {
+    let snapshot = this.#currentResponseSnapshot;
+    if (!snapshot) {
+      if (event.type !== 'response.created') {
+        throw new OpenAIError(
+          `When snapshot hasn't been set yet, expected 'response.created' event, got ${event.type}`,
+        );
+      }
+      snapshot = this.#currentResponseSnapshot = event.response;
+      return snapshot;
+    }
+
+    switch (event.type) {
+      case 'response.output_item.added': {
+        snapshot.output.push(event.item);
+        break;
+      }
+      case 'response.content_part.added': {
+        const output = snapshot.output[event.output_index];
+        if (!output) {
+          throw new OpenAIError(`missing output at index ${event.output_index}`);
+        }
+        if (output.type === 'message') {
+          output.content.push(event.part);
+        }
+        break;
+      }
+      case 'response.output_text.delta': {
+        const output = snapshot.output[event.output_index];
+        if (!output) {
+          throw new OpenAIError(`missing output at index ${event.output_index}`);
+        }
+        if (output.type === 'message') {
+          const content = output.content[event.content_index];
+          if (!content) {
+            throw new OpenAIError(`missing content at index ${event.content_index}`);
+          }
+          if (content.type !== 'output_text') {
+            throw new OpenAIError(`expected content to be 'output_text', got ${content.type}`);
+          }
+          content.text += event.delta;
+        }
+        break;
+      }
+      case 'response.function_call_arguments.delta': {
+        const output = snapshot.output[event.output_index];
+        if (!output) {
+          throw new OpenAIError(`missing output at index ${event.output_index}`);
+        }
+        if (output.type === 'function_call') {
+          output.arguments += event.delta;
+        }
+        break;
+      }
+      case 'response.completed': {
+        this.#currentResponseSnapshot = event.response;
+        break;
+      }
+    }
+
+    return snapshot;
+  }
+
+  [Symbol.asyncIterator](this: ResponseStream<ParsedT>): AsyncIterator<ResponseStreamEvent> {
+    const pushQueue: ResponseStreamEvent[] = [];
+    const readQueue: {
+      resolve: (event: ResponseStreamEvent | undefined) => void;
+      reject: (err: unknown) => void;
+    }[] = [];
+    let done = false;
+
+    this.on('event', (event) => {
+      const reader = readQueue.shift();
+      if (reader) {
+        reader.resolve(event);
+      } else {
+        pushQueue.push(event);
+      }
+    });
+
+    this.on('end', () => {
+      done = true;
+      for (const reader of readQueue) {
+        reader.resolve(undefined);
+      }
+      readQueue.length = 0;
+    });
+
+    this.on('abort', (err) => {
+      done = true;
+      for (const reader of readQueue) {
+        reader.reject(err);
+      }
+      readQueue.length = 0;
+    });
+
+    this.on('error', (err) => {
+      done = true;
+      for (const reader of readQueue) {
+        reader.reject(err);
+      }
+      readQueue.length = 0;
+    });
+
+    return {
+      next: async (): Promise<IteratorResult<ResponseStreamEvent>> => {
+        if (!pushQueue.length) {
+          if (done) {
+            return { value: undefined, done: true };
+          }
+          return new Promise<ResponseStreamEvent | undefined>((resolve, reject) =>
+            readQueue.push({ resolve, reject }),
+          ).then((event) => (event ? { value: event, done: false } : { value: undefined, done: true }));
+        }
+        const event = pushQueue.shift()!;
+        return { value: event, done: false };
+      },
+      return: async () => {
+        this.abort();
+        return { value: undefined, done: true };
+      },
+    };
+  }
+
+  /**
+   * @returns a promise that resolves with the final Response, or rejects
+   * if an error occurred or the stream ended prematurely without producing a REsponse.
+   */
+  async finalResponse(): Promise<ParsedResponse<ParsedT>> {
+    await this.done();
+    const response = this.#finalResponse;
+    if (!response) throw new OpenAIError('stream ended without producing a ChatCompletion');
+    return response;
+  }
+}
+
+function finalizeResponse<ParsedT>(
+  snapshot: Response,
+  params: ResponseStreamingParams | null,
+): ParsedResponse<ParsedT> {
+  return maybeParseResponse(snapshot, params);
+}

package/src/resources/beta/assistants.ts

@@ -4,10 +4,8 @@ import { APIResource } from '../../resource';
 import { isRequestOptions } from '../../core';
 import * as Core from '../../core';
 import * as Shared from '../shared';
-import * as ChatAPI from '../chat/chat';
 import * as MessagesAPI from './threads/messages';
 import * as ThreadsAPI from './threads/threads';
-import * as VectorStoresAPI from './vector-stores/vector-stores';
 import * as RunsAPI from './threads/runs/runs';
 import * as StepsAPI from './threads/runs/steps';
 import { CursorPage, type CursorPageParams } from '../../pagination';
@@ -1105,7 +1103,7 @@ export interface AssistantCreateParams {
    * [Model overview](https://platform.openai.com/docs/models) for descriptions of
    * them.
    */
-  model: (string & {}) | ChatAPI.ChatModel;
+  model: (string & {}) | Shared.ChatModel;
 
   /**
    * The description of the assistant. The maximum length is 512 characters.
@@ -1134,14 +1132,14 @@ export interface AssistantCreateParams {
   name?: string | null;
 
   /**
-   * **o1 and o3-mini models only**
+   * **o-series models only**
    *
    * Constrains effort on reasoning for
    * [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
    * supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
    * result in faster responses and fewer tokens used on reasoning in a response.
    */
-  reasoning_effort?: 'low' | 'medium' | 'high' | null;
+  reasoning_effort?: Shared.ReasoningEffort | null;
 
   /**
    * Specifies the format that the model must output. Compatible with
@@ -1244,9 +1242,9 @@ export namespace AssistantCreateParams {
       export interface VectorStore {
         /**
          * The chunking strategy used to chunk the file(s). If not set, will use the `auto`
-         * strategy. Only applicable if `file_ids` is non-empty.
+         * strategy.
          */
-        chunking_strategy?: VectorStoresAPI.FileChunkingStrategyParam;
+        chunking_strategy?: VectorStore.Auto | VectorStore.Static;
 
         /**
          * A list of [file](https://platform.openai.com/docs/api-reference/files) IDs to
@@ -1265,6 +1263,45 @@ export namespace AssistantCreateParams {
          */
         metadata?: Shared.Metadata | null;
       }
+
+      export namespace VectorStore {
+        /**
+         * The default strategy. This strategy currently uses a `max_chunk_size_tokens` of
+         * `800` and `chunk_overlap_tokens` of `400`.
+         */
+        export interface Auto {
+          /**
+           * Always `auto`.
+           */
+          type: 'auto';
+        }
+
+        export interface Static {
+          static: Static.Static;
+
+          /**
+           * Always `static`.
+           */
+          type: 'static';
+        }
+
+        export namespace Static {
+          export interface Static {
+            /**
+             * The number of tokens that overlap between chunks. The default value is `400`.
+             *
+             * Note that the overlap must not exceed half of `max_chunk_size_tokens`.
+             */
+            chunk_overlap_tokens: number;
+
+            /**
+             * The maximum number of tokens in each chunk. The default value is `800`. The
+             * minimum value is `100` and the maximum value is `4096`.
+             */
+            max_chunk_size_tokens: number;
+          }
+        }
+      }
     }
   }
 }
@@ -1337,14 +1374,14 @@ export interface AssistantUpdateParams {
   name?: string | null;
 
   /**
-   * **o1 and o3-mini models only**
+   * **o-series models only**
    *
    * Constrains effort on reasoning for
    * [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
    * supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
    * result in faster responses and fewer tokens used on reasoning in a response.
    */
-  reasoning_effort?: 'low' | 'medium' | 'high' | null;
+  reasoning_effort?: Shared.ReasoningEffort | null;
 
   /**
    * Specifies the format that the model must output. Compatible with

package/src/resources/beta/beta.ts

@@ -40,36 +40,16 @@ import {
   ThreadUpdateParams,
   Threads,
 } from './threads/threads';
-import * as VectorStoresAPI from './vector-stores/vector-stores';
-import {
-  AutoFileChunkingStrategyParam,
-  FileChunkingStrategy,
-  FileChunkingStrategyParam,
-  OtherFileChunkingStrategyObject,
-  StaticFileChunkingStrategy,
-  StaticFileChunkingStrategyObject,
-  StaticFileChunkingStrategyObjectParam,
-  VectorStore,
-  VectorStoreCreateParams,
-  VectorStoreDeleted,
-  VectorStoreListParams,
-  VectorStoreUpdateParams,
-  VectorStores,
-  VectorStoresPage,
-} from './vector-stores/vector-stores';
 import { Chat } from './chat/chat';
 
 export class Beta extends APIResource {
   realtime: RealtimeAPI.Realtime = new RealtimeAPI.Realtime(this._client);
-  vectorStores: VectorStoresAPI.VectorStores = new VectorStoresAPI.VectorStores(this._client);
   chat: ChatAPI.Chat = new ChatAPI.Chat(this._client);
   assistants: AssistantsAPI.Assistants = new AssistantsAPI.Assistants(this._client);
   threads: ThreadsAPI.Threads = new ThreadsAPI.Threads(this._client);
 }
 
 Beta.Realtime = Realtime;
-Beta.VectorStores = VectorStores;
-Beta.VectorStoresPage = VectorStoresPage;
 Beta.Assistants = Assistants;
 Beta.AssistantsPage = AssistantsPage;
 Beta.Threads = Threads;
@@ -77,23 +57,6 @@ Beta.Threads = Threads;
 export declare namespace Beta {
   export { Realtime as Realtime };
 
-  export {
-    VectorStores as VectorStores,
-    type AutoFileChunkingStrategyParam as AutoFileChunkingStrategyParam,
-    type FileChunkingStrategy as FileChunkingStrategy,
-    type FileChunkingStrategyParam as FileChunkingStrategyParam,
-    type OtherFileChunkingStrategyObject as OtherFileChunkingStrategyObject,
-    type StaticFileChunkingStrategy as StaticFileChunkingStrategy,
-    type StaticFileChunkingStrategyObject as StaticFileChunkingStrategyObject,
-    type StaticFileChunkingStrategyObjectParam as StaticFileChunkingStrategyObjectParam,
-    type VectorStore as VectorStore,
-    type VectorStoreDeleted as VectorStoreDeleted,
-    VectorStoresPage as VectorStoresPage,
-    type VectorStoreCreateParams as VectorStoreCreateParams,
-    type VectorStoreUpdateParams as VectorStoreUpdateParams,
-    type VectorStoreListParams as VectorStoreListParams,
-  };
-
   export { Chat };
 
   export {

package/src/resources/beta/index.ts

@@ -37,19 +37,3 @@ export {
   type ThreadCreateAndRunPollParams,
   type ThreadCreateAndRunStreamParams,
 } from './threads/index';
-export {
-  VectorStoresPage,
-  VectorStores,
-  type AutoFileChunkingStrategyParam,
-  type FileChunkingStrategy,
-  type FileChunkingStrategyParam,
-  type OtherFileChunkingStrategyObject,
-  type StaticFileChunkingStrategy,
-  type StaticFileChunkingStrategyObject,
-  type StaticFileChunkingStrategyObjectParam,
-  type VectorStore,
-  type VectorStoreDeleted,
-  type VectorStoreCreateParams,
-  type VectorStoreUpdateParams,
-  type VectorStoreListParams,
-} from './vector-stores/index';

package/src/resources/beta/threads/runs/runs.ts

@@ -10,7 +10,6 @@ import { RunSubmitToolOutputsParamsStream } from '../../../../lib/AssistantStrea
 import * as RunsAPI from './runs';
 import * as Shared from '../../../shared';
 import * as AssistantsAPI from '../../assistants';
-import * as ChatAPI from '../../../chat/chat';
 import * as MessagesAPI from '../messages';
 import * as ThreadsAPI from '../threads';
 import * as StepsAPI from './steps';
@@ -722,7 +721,7 @@ export interface RunCreateParamsBase {
    * associated with the assistant. If not, the model associated with the assistant
    * will be used.
    */
-  model?: (string & {}) | ChatAPI.ChatModel | null;
+  model?: (string & {}) | Shared.ChatModel | null;
 
   /**
    * Body param: Whether to enable
@@ -732,14 +731,14 @@ export interface RunCreateParamsBase {
   parallel_tool_calls?: boolean;
 
   /**
-   * Body param: **o1 and o3-mini models only**
+   * Body param: **o-series models only**
    *
    * Constrains effort on reasoning for
    * [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
    * supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
    * result in faster responses and fewer tokens used on reasoning in a response.
    */
-  reasoning_effort?: 'low' | 'medium' | 'high' | null;
+  reasoning_effort?: Shared.ReasoningEffort | null;
 
   /**
    * Body param: Specifies the format that the model must output. Compatible with

package/src/resources/beta/threads/threads.ts

@@ -8,7 +8,6 @@ import * as Core from '../../../core';
 import * as ThreadsAPI from './threads';
 import * as Shared from '../../shared';
 import * as AssistantsAPI from '../assistants';
-import * as ChatAPI from '../../chat/chat';
 import * as MessagesAPI from './messages';
 import {
   Annotation,
@@ -45,7 +44,6 @@ import {
   TextDelta,
   TextDeltaBlock,
 } from './messages';
-import * as VectorStoresAPI from '../vector-stores/vector-stores';
 import * as RunsAPI from './runs/runs';
 import {
   RequiredActionFunctionToolCall,
@@ -441,9 +439,9 @@ export namespace ThreadCreateParams {
       export interface VectorStore {
         /**
          * The chunking strategy used to chunk the file(s). If not set, will use the `auto`
-         * strategy. Only applicable if `file_ids` is non-empty.
+         * strategy.
          */
-        chunking_strategy?: VectorStoresAPI.FileChunkingStrategyParam;
+        chunking_strategy?: VectorStore.Auto | VectorStore.Static;
 
         /**
          * A list of [file](https://platform.openai.com/docs/api-reference/files) IDs to
@@ -462,6 +460,45 @@ export namespace ThreadCreateParams {
          */
         metadata?: Shared.Metadata | null;
       }
+
+      export namespace VectorStore {
+        /**
+         * The default strategy. This strategy currently uses a `max_chunk_size_tokens` of
+         * `800` and `chunk_overlap_tokens` of `400`.
+         */
+        export interface Auto {
+          /**
+           * Always `auto`.
+           */
+          type: 'auto';
+        }
+
+        export interface Static {
+          static: Static.Static;
+
+          /**
+           * Always `static`.
+           */
+          type: 'static';
+        }
+
+        export namespace Static {
+          export interface Static {
+            /**
+             * The number of tokens that overlap between chunks. The default value is `400`.
+             *
+             * Note that the overlap must not exceed half of `max_chunk_size_tokens`.
+             */
+            chunk_overlap_tokens: number;
+
+            /**
+             * The maximum number of tokens in each chunk. The default value is `800`. The
+             * minimum value is `100` and the maximum value is `4096`.
+             */
+            max_chunk_size_tokens: number;
+          }
+        }
+      }
     }
   }
 }
@@ -573,7 +610,7 @@ export interface ThreadCreateAndRunParamsBase {
    * model associated with the assistant. If not, the model associated with the
    * assistant will be used.
    */
-  model?: (string & {}) | ChatAPI.ChatModel | null;
+  model?: (string & {}) | Shared.ChatModel | null;
 
   /**
    * Whether to enable
@@ -800,9 +837,9 @@ export namespace ThreadCreateAndRunParams {
         export interface VectorStore {
           /**
            * The chunking strategy used to chunk the file(s). If not set, will use the `auto`
-           * strategy. Only applicable if `file_ids` is non-empty.
+           * strategy.
            */
-          chunking_strategy?: VectorStoresAPI.FileChunkingStrategyParam;
+          chunking_strategy?: VectorStore.Auto | VectorStore.Static;
 
           /**
            * A list of [file](https://platform.openai.com/docs/api-reference/files) IDs to
@@ -821,6 +858,45 @@ export namespace ThreadCreateAndRunParams {
            */
           metadata?: Shared.Metadata | null;
         }
+
+        export namespace VectorStore {
+          /**
+           * The default strategy. This strategy currently uses a `max_chunk_size_tokens` of
+           * `800` and `chunk_overlap_tokens` of `400`.
+           */
+          export interface Auto {
+            /**
+             * Always `auto`.
+             */
+            type: 'auto';
+          }
+
+          export interface Static {
+            static: Static.Static;
+
+            /**
+             * Always `static`.
+             */
+            type: 'static';
+          }
+
+          export namespace Static {
+            export interface Static {
+              /**
+               * The number of tokens that overlap between chunks. The default value is `400`.
+               *
+               * Note that the overlap must not exceed half of `max_chunk_size_tokens`.
+               */
+              chunk_overlap_tokens: number;
+
+              /**
+               * The maximum number of tokens in each chunk. The default value is `800`. The
+               * minimum value is `100` and the maximum value is `4096`.
+               */
+              max_chunk_size_tokens: number;
+            }
+          }
+        }
       }
     }
   }