openai 4.28.4 → 4.29.0

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

@@ -55,10 +55,54 @@ export class Steps extends APIResource {
 
 export class RunStepsPage extends CursorPage<RunStep> {}
 
+/**
+ * Text output from the Code Interpreter tool call as part of a run step.
+ */
+export interface CodeInterpreterLogs {
+  /**
+   * The index of the output in the outputs array.
+   */
+  index: number;
+
+  /**
+   * Always `logs`.
+   */
+  type: 'logs';
+
+  /**
+   * The text output from the Code Interpreter tool call.
+   */
+  logs?: string;
+}
+
+export interface CodeInterpreterOutputImage {
+  /**
+   * The index of the output in the outputs array.
+   */
+  index: number;
+
+  /**
+   * Always `image`.
+   */
+  type: 'image';
+
+  image?: CodeInterpreterOutputImage.Image;
+}
+
+export namespace CodeInterpreterOutputImage {
+  export interface Image {
+    /**
+     * The [file](https://platform.openai.com/docs/api-reference/files) ID of the
+     * image.
+     */
+    file_id?: string;
+  }
+}
+
 /**
  * Details of the Code Interpreter tool call the run step was involved in.
  */
-export interface CodeToolCall {
+export interface CodeInterpreterToolCall {
   /**
    * The ID of the tool call.
    */
@@ -67,7 +111,7 @@ export interface CodeToolCall {
   /**
    * The Code Interpreter tool call definition.
    */
-  code_interpreter: CodeToolCall.CodeInterpreter;
+  code_interpreter: CodeInterpreterToolCall.CodeInterpreter;
 
   /**
    * The type of tool call. This is always going to be `code_interpreter` for this
@@ -76,7 +120,7 @@ export interface CodeToolCall {
   type: 'code_interpreter';
 }
 
-export namespace CodeToolCall {
+export namespace CodeInterpreterToolCall {
   /**
    * The Code Interpreter tool call definition.
    */
@@ -131,6 +175,51 @@ export namespace CodeToolCall {
   }
 }
 
+/**
+ * Details of the Code Interpreter tool call the run step was involved in.
+ */
+export interface CodeInterpreterToolCallDelta {
+  /**
+   * The index of the tool call in the tool calls array.
+   */
+  index: number;
+
+  /**
+   * The type of tool call. This is always going to be `code_interpreter` for this
+   * type of tool call.
+   */
+  type: 'code_interpreter';
+
+  /**
+   * The ID of the tool call.
+   */
+  id?: string;
+
+  /**
+   * The Code Interpreter tool call definition.
+   */
+  code_interpreter?: CodeInterpreterToolCallDelta.CodeInterpreter;
+}
+
+export namespace CodeInterpreterToolCallDelta {
+  /**
+   * The Code Interpreter tool call definition.
+   */
+  export interface CodeInterpreter {
+    /**
+     * The input to the Code Interpreter tool call.
+     */
+    input?: string;
+
+    /**
+     * The outputs from the Code Interpreter tool call. Code Interpreter can output one
+     * or more items, including text (`logs`) or images (`image`). Each of these are
+     * represented by a different object type.
+     */
+    outputs?: Array<StepsAPI.CodeInterpreterLogs | StepsAPI.CodeInterpreterOutputImage>;
+  }
+}
+
 export interface FunctionToolCall {
   /**
    * The ID of the tool call object.
@@ -173,6 +262,53 @@ export namespace FunctionToolCall {
   }
 }
 
+export interface FunctionToolCallDelta {
+  /**
+   * The index of the tool call in the tool calls array.
+   */
+  index: number;
+
+  /**
+   * The type of tool call. This is always going to be `function` for this type of
+   * tool call.
+   */
+  type: 'function';
+
+  /**
+   * The ID of the tool call object.
+   */
+  id?: string;
+
+  /**
+   * The definition of the function that was called.
+   */
+  function?: FunctionToolCallDelta.Function;
+}
+
+export namespace FunctionToolCallDelta {
+  /**
+   * The definition of the function that was called.
+   */
+  export interface Function {
+    /**
+     * The arguments passed to the function.
+     */
+    arguments?: string;
+
+    /**
+     * The name of the function.
+     */
+    name?: string;
+
+    /**
+     * The output of the function. This will be `null` if the outputs have not been
+     * [submitted](https://platform.openai.com/docs/api-reference/runs/submitToolOutputs)
+     * yet.
+     */
+    output?: string | null;
+  }
+}
+
 /**
  * Details of the message creation by the run step.
  */
@@ -212,6 +348,29 @@ export interface RetrievalToolCall {
   type: 'retrieval';
 }
 
+export interface RetrievalToolCallDelta {
+  /**
+   * The index of the tool call in the tool calls array.
+   */
+  index: number;
+
+  /**
+   * The type of tool call. This is always going to be `retrieval` for this type of
+   * tool call.
+   */
+  type: 'retrieval';
+
+  /**
+   * The ID of the tool call object.
+   */
+  id?: string;
+
+  /**
+   * For now, this is always going to be an empty object.
+   */
+  retrieval?: unknown;
+}
+
 /**
  * Represents a step in execution of a run.
  */
@@ -347,6 +506,85 @@ export namespace RunStep {
   }
 }
 
+/**
+ * The delta containing the fields that have changed on the run step.
+ */
+export interface RunStepDelta {
+  /**
+   * The details of the run step.
+   */
+  step_details?: RunStepDeltaMessageDelta | ToolCallDeltaObject;
+}
+
+/**
+ * Represents a run step delta i.e. any changed fields on a run step during
+ * streaming.
+ */
+export interface RunStepDeltaEvent {
+  /**
+   * The identifier of the run step, which can be referenced in API endpoints.
+   */
+  id: string;
+
+  /**
+   * The delta containing the fields that have changed on the run step.
+   */
+  delta: RunStepDelta;
+
+  /**
+   * The object type, which is always `thread.run.step.delta`.
+   */
+  object: 'thread.run.step.delta';
+}
+
+/**
+ * Details of the message creation by the run step.
+ */
+export interface RunStepDeltaMessageDelta {
+  /**
+   * Always `message_creation`.
+   */
+  type: 'message_creation';
+
+  message_creation?: RunStepDeltaMessageDelta.MessageCreation;
+}
+
+export namespace RunStepDeltaMessageDelta {
+  export interface MessageCreation {
+    /**
+     * The ID of the message that was created by this run step.
+     */
+    message_id?: string;
+  }
+}
+
+/**
+ * Details of the Code Interpreter tool call the run step was involved in.
+ */
+export type ToolCall = CodeInterpreterToolCall | RetrievalToolCall | FunctionToolCall;
+
+/**
+ * Details of the Code Interpreter tool call the run step was involved in.
+ */
+export type ToolCallDelta = CodeInterpreterToolCallDelta | RetrievalToolCallDelta | FunctionToolCallDelta;
+
+/**
+ * Details of the tool call.
+ */
+export interface ToolCallDeltaObject {
+  /**
+   * Always `tool_calls`.
+   */
+  type: 'tool_calls';
+
+  /**
+   * An array of tool calls the run step was involved in. These can be associated
+   * with one of three types of tools: `code_interpreter`, `retrieval`, or
+   * `function`.
+   */
+  tool_calls?: Array<ToolCallDelta>;
+}
+
 /**
  * Details of the tool call.
  */
@@ -356,7 +594,7 @@ export interface ToolCallsStepDetails {
    * with one of three types of tools: `code_interpreter`, `retrieval`, or
    * `function`.
    */
-  tool_calls: Array<CodeToolCall | RetrievalToolCall | FunctionToolCall>;
+  tool_calls: Array<ToolCall>;
 
   /**
    * Always `tool_calls`.
@@ -381,11 +619,22 @@ export interface StepListParams extends CursorPageParams {
 }
 
 export namespace Steps {
-  export import CodeToolCall = StepsAPI.CodeToolCall;
+  export import CodeInterpreterLogs = StepsAPI.CodeInterpreterLogs;
+  export import CodeInterpreterOutputImage = StepsAPI.CodeInterpreterOutputImage;
+  export import CodeInterpreterToolCall = StepsAPI.CodeInterpreterToolCall;
+  export import CodeInterpreterToolCallDelta = StepsAPI.CodeInterpreterToolCallDelta;
   export import FunctionToolCall = StepsAPI.FunctionToolCall;
+  export import FunctionToolCallDelta = StepsAPI.FunctionToolCallDelta;
   export import MessageCreationStepDetails = StepsAPI.MessageCreationStepDetails;
   export import RetrievalToolCall = StepsAPI.RetrievalToolCall;
+  export import RetrievalToolCallDelta = StepsAPI.RetrievalToolCallDelta;
   export import RunStep = StepsAPI.RunStep;
+  export import RunStepDelta = StepsAPI.RunStepDelta;
+  export import RunStepDeltaEvent = StepsAPI.RunStepDeltaEvent;
+  export import RunStepDeltaMessageDelta = StepsAPI.RunStepDeltaMessageDelta;
+  export import ToolCall = StepsAPI.ToolCall;
+  export import ToolCallDelta = StepsAPI.ToolCallDelta;
+  export import ToolCallDeltaObject = StepsAPI.ToolCallDeltaObject;
   export import ToolCallsStepDetails = StepsAPI.ToolCallsStepDetails;
   export import RunStepsPage = StepsAPI.RunStepsPage;
   export import StepListParams = StepsAPI.StepListParams;

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

@@ -1,12 +1,15 @@
 // File generated from our OpenAPI spec by Stainless.
 
 import * as Core from "../../../core";
+import { APIPromise } from "../../../core";
 import { APIResource } from "../../../resource";
 import { isRequestOptions } from "../../../core";
+import { AssistantStream, ThreadCreateAndRunParamsBaseStream } from "../../../lib/AssistantStream";
 import * as ThreadsAPI from "./threads";
-import * as Shared from "../../shared";
+import * as AssistantsAPI from "../assistants/assistants";
 import * as MessagesAPI from "./messages/messages";
 import * as RunsAPI from "./runs/runs";
+import { Stream } from "../../../streaming";
 
 export class Threads extends APIResource {
   runs: RunsAPI.Runs = new RunsAPI.Runs(this._client);
@@ -65,12 +68,38 @@ export class Threads extends APIResource {
   /**
    * Create a thread and run it in one request.
    */
-  createAndRun(body: ThreadCreateAndRunParams, options?: Core.RequestOptions): Core.APIPromise<RunsAPI.Run> {
+  createAndRun(
+    body: ThreadCreateAndRunParamsNonStreaming,
+    options?: Core.RequestOptions,
+  ): APIPromise<RunsAPI.Run>;
+  createAndRun(
+    body: ThreadCreateAndRunParamsStreaming,
+    options?: Core.RequestOptions,
+  ): APIPromise<Stream<AssistantsAPI.AssistantStreamEvent>>;
+  createAndRun(
+    body: ThreadCreateAndRunParamsBase,
+    options?: Core.RequestOptions,
+  ): APIPromise<Stream<AssistantsAPI.AssistantStreamEvent> | RunsAPI.Run>;
+  createAndRun(
+    body: ThreadCreateAndRunParams,
+    options?: Core.RequestOptions,
+  ): APIPromise<RunsAPI.Run> | APIPromise<Stream<AssistantsAPI.AssistantStreamEvent>> {
     return this._client.post('/threads/runs', {
       body,
       ...options,
       headers: { 'OpenAI-Beta': 'assistants=v1', ...options?.headers },
-    });
+      stream: body.stream ?? false,
+    }) as APIPromise<RunsAPI.Run> | APIPromise<Stream<AssistantsAPI.AssistantStreamEvent>>;
+  }
+
+  /**
+   * Create a thread and stream the run back
+   */
+  createAndRunStream(
+    body: ThreadCreateAndRunParamsBaseStream,
+    options?: Core.RequestOptions,
+  ): AssistantStream {
+    return AssistantStream.createThreadAssistantStream(body, this._client.beta.threads, options);
   }
 }
 
@@ -168,7 +197,11 @@ export interface ThreadUpdateParams {
   metadata?: unknown | null;
 }
 
-export interface ThreadCreateAndRunParams {
+export type ThreadCreateAndRunParams =
+  | ThreadCreateAndRunParamsNonStreaming
+  | ThreadCreateAndRunParamsStreaming;
+
+export interface ThreadCreateAndRunParamsBase {
   /**
    * The ID of the
    * [assistant](https://platform.openai.com/docs/api-reference/assistants) to use to
@@ -198,6 +231,13 @@ export interface ThreadCreateAndRunParams {
    */
   model?: string | null;
 
+  /**
+   * If `true`, returns a stream of events that happen during the Run as server-sent
+   * events, terminating when the Run enters a terminal state with a `data: [DONE]`
+   * message.
+   */
+  stream?: boolean | null;
+
   /**
    * If no thread is provided, an empty thread will be created.
    */
@@ -208,9 +248,7 @@ export interface ThreadCreateAndRunParams {
    * modifying the behavior on a per-run basis.
    */
   tools?: Array<
-    | ThreadCreateAndRunParams.AssistantToolsCode
-    | ThreadCreateAndRunParams.AssistantToolsRetrieval
-    | ThreadCreateAndRunParams.AssistantToolsFunction
+    AssistantsAPI.CodeInterpreterTool | AssistantsAPI.RetrievalTool | AssistantsAPI.FunctionTool
   > | null;
 }
 
@@ -265,27 +303,121 @@ export namespace ThreadCreateAndRunParams {
     }
   }
 
-  export interface AssistantToolsCode {
+  export type ThreadCreateAndRunParamsNonStreaming = ThreadsAPI.ThreadCreateAndRunParamsNonStreaming;
+  export type ThreadCreateAndRunParamsStreaming = ThreadsAPI.ThreadCreateAndRunParamsStreaming;
+}
+
+export interface ThreadCreateAndRunParamsNonStreaming extends ThreadCreateAndRunParamsBase {
+  /**
+   * If `true`, returns a stream of events that happen during the Run as server-sent
+   * events, terminating when the Run enters a terminal state with a `data: [DONE]`
+   * message.
+   */
+  stream?: false | null;
+}
+
+export interface ThreadCreateAndRunParamsStreaming extends ThreadCreateAndRunParamsBase {
+  /**
+   * If `true`, returns a stream of events that happen during the Run as server-sent
+   * events, terminating when the Run enters a terminal state with a `data: [DONE]`
+   * message.
+   */
+  stream: true;
+}
+
+export interface ThreadCreateAndRunStreamParams {
+  /**
+   * The ID of the
+   * [assistant](https://platform.openai.com/docs/api-reference/assistants) to use to
+   * execute this run.
+   */
+  assistant_id: string;
+
+  /**
+   * Override the default system message of the assistant. This is useful for
+   * modifying the behavior on a per-run basis.
+   */
+  instructions?: string | null;
+
+  /**
+   * Set of 16 key-value pairs that can be attached to an object. This can be useful
+   * for storing additional information about the object in a structured format. Keys
+   * can be a maximum of 64 characters long and values can be a maxium of 512
+   * characters long.
+   */
+  metadata?: unknown | null;
+
+  /**
+   * The ID of the [Model](https://platform.openai.com/docs/api-reference/models) to
+   * be used to execute this run. If a value is provided here, it will override the
+   * model associated with the assistant. If not, the model associated with the
+   * assistant will be used.
+   */
+  model?: string | null;
+
+  /**
+   * If no thread is provided, an empty thread will be created.
+   */
+  thread?: ThreadCreateAndRunStreamParams.Thread;
+
+  /**
+   * Override the tools the assistant can use for this run. This is useful for
+   * modifying the behavior on a per-run basis.
+   */
+  tools?: Array<
+    AssistantsAPI.CodeInterpreterTool | AssistantsAPI.RetrievalTool | AssistantsAPI.FunctionTool
+  > | null;
+}
+
+export namespace ThreadCreateAndRunStreamParams {
+  /**
+   * If no thread is provided, an empty thread will be created.
+   */
+  export interface Thread {
     /**
-     * The type of tool being defined: `code_interpreter`
+     * A list of [messages](https://platform.openai.com/docs/api-reference/messages) to
+     * start the thread with.
      */
-    type: 'code_interpreter';
-  }
+    messages?: Array<Thread.Message>;
 
-  export interface AssistantToolsRetrieval {
     /**
-     * The type of tool being defined: `retrieval`
+     * Set of 16 key-value pairs that can be attached to an object. This can be useful
+     * for storing additional information about the object in a structured format. Keys
+     * can be a maximum of 64 characters long and values can be a maxium of 512
+     * characters long.
      */
-    type: 'retrieval';
+    metadata?: unknown | null;
   }
 
-  export interface AssistantToolsFunction {
-    function: Shared.FunctionDefinition;
+  export namespace Thread {
+    export interface Message {
+      /**
+       * The content of the message.
+       */
+      content: string;
+
+      /**
+       * The role of the entity that is creating the message. Currently only `user` is
+       * supported.
+       */
+      role: 'user';
 
-    /**
-     * The type of tool being defined: `function`
-     */
-    type: 'function';
+      /**
+       * A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
+       * the message should use. There can be a maximum of 10 files attached to a
+       * message. Useful for tools like `retrieval` and `code_interpreter` that can
+       * access and use files.
+       */
+      file_ids?: Array<string>;
+
+      /**
+       * Set of 16 key-value pairs that can be attached to an object. This can be useful
+       * for storing additional information about the object in a structured format. Keys
+       * can be a maximum of 64 characters long and values can be a maxium of 512
+       * characters long.
+       */
+      metadata?: unknown | null;
+    }
   }
 }
 
@@ -295,21 +427,46 @@ export namespace Threads {
   export import ThreadCreateParams = ThreadsAPI.ThreadCreateParams;
   export import ThreadUpdateParams = ThreadsAPI.ThreadUpdateParams;
   export import ThreadCreateAndRunParams = ThreadsAPI.ThreadCreateAndRunParams;
+  export import ThreadCreateAndRunParamsNonStreaming = ThreadsAPI.ThreadCreateAndRunParamsNonStreaming;
+  export import ThreadCreateAndRunParamsStreaming = ThreadsAPI.ThreadCreateAndRunParamsStreaming;
+  export import ThreadCreateAndRunStreamParams = ThreadsAPI.ThreadCreateAndRunStreamParams;
   export import Runs = RunsAPI.Runs;
   export import RequiredActionFunctionToolCall = RunsAPI.RequiredActionFunctionToolCall;
   export import Run = RunsAPI.Run;
   export import RunStatus = RunsAPI.RunStatus;
   export import RunsPage = RunsAPI.RunsPage;
   export import RunCreateParams = RunsAPI.RunCreateParams;
+  export import RunCreateParamsNonStreaming = RunsAPI.RunCreateParamsNonStreaming;
+  export import RunCreateParamsStreaming = RunsAPI.RunCreateParamsStreaming;
   export import RunUpdateParams = RunsAPI.RunUpdateParams;
   export import RunListParams = RunsAPI.RunListParams;
+  export import RunCreateAndStreamParams = RunsAPI.RunCreateAndStreamParams;
   export import RunSubmitToolOutputsParams = RunsAPI.RunSubmitToolOutputsParams;
+  export import RunSubmitToolOutputsParamsNonStreaming = RunsAPI.RunSubmitToolOutputsParamsNonStreaming;
+  export import RunSubmitToolOutputsParamsStreaming = RunsAPI.RunSubmitToolOutputsParamsStreaming;
+  export import RunSubmitToolOutputsStreamParams = RunsAPI.RunSubmitToolOutputsStreamParams;
   export import Messages = MessagesAPI.Messages;
-  export import MessageContentImageFile = MessagesAPI.MessageContentImageFile;
-  export import MessageContentText = MessagesAPI.MessageContentText;
-  export import ThreadMessage = MessagesAPI.ThreadMessage;
-  export import ThreadMessageDeleted = MessagesAPI.ThreadMessageDeleted;
-  export import ThreadMessagesPage = MessagesAPI.ThreadMessagesPage;
+  export import Annotation = MessagesAPI.Annotation;
+  export import AnnotationDelta = MessagesAPI.AnnotationDelta;
+  export import FileCitationAnnotation = MessagesAPI.FileCitationAnnotation;
+  export import FileCitationDeltaAnnotation = MessagesAPI.FileCitationDeltaAnnotation;
+  export import FilePathAnnotation = MessagesAPI.FilePathAnnotation;
+  export import FilePathDeltaAnnotation = MessagesAPI.FilePathDeltaAnnotation;
+  export import ImageFile = MessagesAPI.ImageFile;
+  export import ImageFileContentBlock = MessagesAPI.ImageFileContentBlock;
+  export import ImageFileDelta = MessagesAPI.ImageFileDelta;
+  export import ImageFileDeltaBlock = MessagesAPI.ImageFileDeltaBlock;
+  export import Message = MessagesAPI.Message;
+  export import MessageContent = MessagesAPI.MessageContent;
+  export import MessageContentDelta = MessagesAPI.MessageContentDelta;
+  export import MessageDeleted = MessagesAPI.MessageDeleted;
+  export import MessageDelta = MessagesAPI.MessageDelta;
+  export import MessageDeltaEvent = MessagesAPI.MessageDeltaEvent;
+  export import Text = MessagesAPI.Text;
+  export import TextContentBlock = MessagesAPI.TextContentBlock;
+  export import TextDelta = MessagesAPI.TextDelta;
+  export import TextDeltaBlock = MessagesAPI.TextDeltaBlock;
+  export import MessagesPage = MessagesAPI.MessagesPage;
   export import MessageCreateParams = MessagesAPI.MessageCreateParams;
   export import MessageUpdateParams = MessagesAPI.MessageUpdateParams;
   export import MessageListParams = MessagesAPI.MessageListParams;