openai 4.53.2 → 4.55.0

package/src/lib/AssistantStream.ts

@@ -19,10 +19,6 @@ import {
   RunSubmitToolOutputsParamsBase,
   RunSubmitToolOutputsParamsStreaming,
 } from "../resources/beta/threads/runs/runs";
-import {
-  AbstractAssistantRunnerEvents,
-  AbstractAssistantStreamRunner,
-} from './AbstractAssistantStreamRunner';
 import { type ReadableStream } from "../_shims/index";
 import { Stream } from "../streaming";
 import { APIUserAbortError, OpenAIError } from "../error";
@@ -34,9 +30,12 @@ import {
 } from "../resources/beta/assistants";
 import { RunStep, RunStepDelta, ToolCall, ToolCallDelta } from "../resources/beta/threads/runs/steps";
 import { ThreadCreateAndRunParamsBase, Threads } from "../resources/beta/threads/threads";
+import { BaseEvents, EventStream } from './EventStream';
 import MessageDelta = Messages.MessageDelta;
 
-export interface AssistantStreamEvents extends AbstractAssistantRunnerEvents {
+export interface AssistantStreamEvents extends BaseEvents {
+  run: (run: Run) => void;
+
   //New event structure
   messageCreated: (message: Message) => void;
   messageDelta: (message: MessageDelta, snapshot: Message) => void;
@@ -57,8 +56,6 @@ export interface AssistantStreamEvents extends AbstractAssistantRunnerEvents {
   //No created or delta as this is not streamed
   imageFileDone: (content: ImageFile, snapshot: Message) => void;
 
-  end: () => void;
-
   event: (event: AssistantStreamEvent) => void;
 }
 
@@ -75,7 +72,7 @@ export type RunSubmitToolOutputsParamsStream = Omit<RunSubmitToolOutputsParamsBa
 };
 
 export class AssistantStream
-  extends AbstractAssistantStreamRunner<AssistantStreamEvents>
+  extends EventStream<AssistantStreamEvents>
   implements AsyncIterable<AssistantStreamEvent>
 {
   //Track all events in a single list for reference
@@ -194,12 +191,12 @@ export class AssistantStream
     threadId: string,
     runId: string,
     runs: Runs,
-    body: RunSubmitToolOutputsParamsStream,
+    params: RunSubmitToolOutputsParamsStream,
     options: RequestOptions | undefined,
   ) {
     const runner = new AssistantStream();
     runner._run(() =>
-      runner._runToolAssistantStream(threadId, runId, runs, body, {
+      runner._runToolAssistantStream(threadId, runId, runs, params, {
         ...options,
         headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' },
       }),
@@ -207,7 +204,7 @@ export class AssistantStream
     return runner;
   }
 
-  protected override async _createToolAssistantStream(
+  protected async _createToolAssistantStream(
     run: Runs,
     threadId: string,
     runId: string,
@@ -239,13 +236,13 @@ export class AssistantStream
   }
 
   static createThreadAssistantStream(
-    body: ThreadCreateAndRunParamsBaseStream,
+    params: ThreadCreateAndRunParamsBaseStream,
     thread: Threads,
     options?: RequestOptions,
   ) {
     const runner = new AssistantStream();
     runner._run(() =>
-      runner._threadAssistantStream(body, thread, {
+      runner._threadAssistantStream(params, thread, {
         ...options,
         headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' },
       }),
@@ -304,7 +301,7 @@ export class AssistantStream
     return this.#finalRun;
   }
 
-  protected override async _createThreadAssistantStream(
+  protected async _createThreadAssistantStream(
     thread: Threads,
     params: ThreadCreateAndRunParamsBase,
     options?: Core.RequestOptions,
@@ -330,7 +327,7 @@ export class AssistantStream
     return this._addRun(this.#endRequest());
   }
 
-  protected override async _createAssistantStream(
+  protected async _createAssistantStream(
     run: Runs,
     threadId: string,
     params: RunCreateParamsBase,
@@ -417,7 +414,7 @@ export class AssistantStream
     return this.#finalRun;
   }
 
-  #handleMessage(event: MessageStreamEvent) {
+  #handleMessage(this: AssistantStream, event: MessageStreamEvent) {
     const [accumulatedMessage, newContent] = this.#accumulateMessage(event, this.#messageSnapshot);
     this.#messageSnapshot = accumulatedMessage;
     this.#messageSnapshots[accumulatedMessage.id] = accumulatedMessage;
@@ -500,7 +497,7 @@ export class AssistantStream
     }
   }
 
-  #handleRunStep(event: RunStepStreamEvent) {
+  #handleRunStep(this: AssistantStream, event: RunStepStreamEvent) {
     const accumulatedRunStep = this.#accumulateRunStep(event);
     this.#currentRunStepSnapshot = accumulatedRunStep;
 
@@ -556,7 +553,7 @@ export class AssistantStream
     }
   }
 
-  #handleEvent(event: AssistantStreamEvent) {
+  #handleEvent(this: AssistantStream, event: AssistantStreamEvent) {
     this.#events.push(event);
     this._emit('event', event);
   }
@@ -696,7 +693,7 @@ export class AssistantStream
     return acc;
   }
 
-  #handleRun(event: RunStreamEvent) {
+  #handleRun(this: AssistantStream, event: RunStreamEvent) {
     this.#currentRunSnapshot = event.data;
     switch (event.event) {
       case 'thread.run.created':
@@ -720,4 +717,35 @@ export class AssistantStream
         break;
     }
   }
+
+  protected _addRun(run: Run): Run {
+    return run;
+  }
+
+  protected async _threadAssistantStream(
+    params: ThreadCreateAndRunParamsBase,
+    thread: Threads,
+    options?: Core.RequestOptions,
+  ): Promise<Run> {
+    return await this._createThreadAssistantStream(thread, params, options);
+  }
+
+  protected async _runAssistantStream(
+    threadId: string,
+    runs: Runs,
+    params: RunCreateParamsBase,
+    options?: Core.RequestOptions,
+  ): Promise<Run> {
+    return await this._createAssistantStream(runs, threadId, params, options);
+  }
+
+  protected async _runToolAssistantStream(
+    threadId: string,
+    runId: string,
+    runs: Runs,
+    params: RunSubmitToolOutputsParamsStream,
+    options?: Core.RequestOptions,
+  ): Promise<Run> {
+    return await this._createToolAssistantStream(runs, threadId, runId, params, options);
+  }
 }

package/src/lib/ChatCompletionRunner.ts

@@ -1,5 +1,4 @@
 import {
-  type Completions,
   type ChatCompletionMessageParam,
   type ChatCompletionCreateParamsNonStreaming,
 } from "../resources/chat/completions";
@@ -10,6 +9,8 @@ import {
   RunnerOptions,
 } from './AbstractChatCompletionRunner';
 import { isAssistantMessage } from './chatCompletionUtils';
+import OpenAI from "../index";
+import { AutoParseableTool } from "./parser";
 
 export interface ChatCompletionRunnerEvents extends AbstractChatCompletionRunnerEvents {
   content: (content: string) => void;
@@ -26,40 +27,43 @@ export type ChatCompletionToolRunnerParams<FunctionsArgs extends BaseFunctionsAr
   ChatCompletionCreateParamsNonStreaming,
   'tools'
 > & {
-  tools: RunnableTools<FunctionsArgs>;
+  tools: RunnableTools<FunctionsArgs> | AutoParseableTool<any, true>[];
 };
 
-export class ChatCompletionRunner extends AbstractChatCompletionRunner<ChatCompletionRunnerEvents> {
+export class ChatCompletionRunner<ParsedT = null> extends AbstractChatCompletionRunner<
+  ChatCompletionRunnerEvents,
+  ParsedT
+> {
   /** @deprecated - please use `runTools` instead. */
   static runFunctions(
-    completions: Completions,
+    client: OpenAI,
     params: ChatCompletionFunctionRunnerParams<any[]>,
     options?: RunnerOptions,
-  ): ChatCompletionRunner {
+  ): ChatCompletionRunner<null> {
     const runner = new ChatCompletionRunner();
     const opts = {
       ...options,
       headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'runFunctions' },
     };
-    runner._run(() => runner._runFunctions(completions, params, opts));
+    runner._run(() => runner._runFunctions(client, params, opts));
     return runner;
   }
 
-  static runTools(
-    completions: Completions,
+  static runTools<ParsedT>(
+    client: OpenAI,
     params: ChatCompletionToolRunnerParams<any[]>,
     options?: RunnerOptions,
-  ): ChatCompletionRunner {
-    const runner = new ChatCompletionRunner();
+  ): ChatCompletionRunner<ParsedT> {
+    const runner = new ChatCompletionRunner<ParsedT>();
     const opts = {
       ...options,
       headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'runTools' },
     };
-    runner._run(() => runner._runTools(completions, params, opts));
+    runner._run(() => runner._runTools(client, params, opts));
     return runner;
   }
 
-  override _addMessage(message: ChatCompletionMessageParam) {
+  override _addMessage(this: ChatCompletionRunner<ParsedT>, message: ChatCompletionMessageParam) {
     super._addMessage(message);
     if (isAssistantMessage(message) && message.content) {
       this._emit('content', message.content as string);