openai 4.86.2 → 4.87.1

package/src/index.ts

@@ -65,14 +65,34 @@ import {
 } from './resources/moderations';
 import { Audio, AudioModel, AudioResponseFormat } from './resources/audio/audio';
 import { Beta } from './resources/beta/beta';
-import { Chat, ChatModel } from './resources/chat/chat';
+import { Chat } from './resources/chat/chat';
 import { FineTuning } from './resources/fine-tuning/fine-tuning';
+import { Responses } from './resources/responses/responses';
 import {
   Upload,
   UploadCompleteParams,
   UploadCreateParams,
   Uploads as UploadsAPIUploads,
 } from './resources/uploads/uploads';
+import {
+  AutoFileChunkingStrategyParam,
+  FileChunkingStrategy,
+  FileChunkingStrategyParam,
+  OtherFileChunkingStrategyObject,
+  StaticFileChunkingStrategy,
+  StaticFileChunkingStrategyObject,
+  StaticFileChunkingStrategyObjectParam,
+  VectorStore,
+  VectorStoreCreateParams,
+  VectorStoreDeleted,
+  VectorStoreListParams,
+  VectorStoreSearchParams,
+  VectorStoreSearchResponse,
+  VectorStoreSearchResponsesPage,
+  VectorStoreUpdateParams,
+  VectorStores,
+  VectorStoresPage,
+} from './resources/vector-stores/vector-stores';
 import {
   ChatCompletion,
   ChatCompletionAssistantMessageParam,
@@ -98,7 +118,6 @@ import {
   ChatCompletionModality,
   ChatCompletionNamedToolChoice,
   ChatCompletionPredictionContent,
-  ChatCompletionReasoningEffort,
   ChatCompletionRole,
   ChatCompletionStoreMessage,
   ChatCompletionStreamOptions,
@@ -267,9 +286,11 @@ export class OpenAI extends Core.APIClient {
   moderations: API.Moderations = new API.Moderations(this);
   models: API.Models = new API.Models(this);
   fineTuning: API.FineTuning = new API.FineTuning(this);
+  vectorStores: API.VectorStores = new API.VectorStores(this);
   beta: API.Beta = new API.Beta(this);
   batches: API.Batches = new API.Batches(this);
   uploads: API.Uploads = new API.Uploads(this);
+  responses: API.Responses = new API.Responses(this);
 
   protected override defaultQuery(): Core.DefaultQuery | undefined {
     return this._options.defaultQuery;
@@ -325,10 +346,14 @@ OpenAI.Moderations = Moderations;
 OpenAI.Models = Models;
 OpenAI.ModelsPage = ModelsPage;
 OpenAI.FineTuning = FineTuning;
+OpenAI.VectorStores = VectorStores;
+OpenAI.VectorStoresPage = VectorStoresPage;
+OpenAI.VectorStoreSearchResponsesPage = VectorStoreSearchResponsesPage;
 OpenAI.Beta = Beta;
 OpenAI.Batches = Batches;
 OpenAI.BatchesPage = BatchesPage;
 OpenAI.Uploads = UploadsAPIUploads;
+OpenAI.Responses = Responses;
 export declare namespace OpenAI {
   export type RequestOptions = Core.RequestOptions;
 
@@ -350,7 +375,6 @@ export declare namespace OpenAI {
 
   export {
     Chat as Chat,
-    type ChatModel as ChatModel,
     type ChatCompletion as ChatCompletion,
     type ChatCompletionAssistantMessageParam as ChatCompletionAssistantMessageParam,
     type ChatCompletionAudio as ChatCompletionAudio,
@@ -371,7 +395,6 @@ export declare namespace OpenAI {
     type ChatCompletionModality as ChatCompletionModality,
     type ChatCompletionNamedToolChoice as ChatCompletionNamedToolChoice,
     type ChatCompletionPredictionContent as ChatCompletionPredictionContent,
-    type ChatCompletionReasoningEffort as ChatCompletionReasoningEffort,
     type ChatCompletionRole as ChatCompletionRole,
     type ChatCompletionStoreMessage as ChatCompletionStoreMessage,
     type ChatCompletionStreamOptions as ChatCompletionStreamOptions,
@@ -440,6 +463,26 @@ export declare namespace OpenAI {
 
   export { FineTuning as FineTuning };
 
+  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,
+    type VectorStoreSearchResponse as VectorStoreSearchResponse,
+    VectorStoresPage as VectorStoresPage,
+    VectorStoreSearchResponsesPage as VectorStoreSearchResponsesPage,
+    type VectorStoreCreateParams as VectorStoreCreateParams,
+    type VectorStoreUpdateParams as VectorStoreUpdateParams,
+    type VectorStoreListParams as VectorStoreListParams,
+    type VectorStoreSearchParams as VectorStoreSearchParams,
+  };
+
   export { Beta as Beta };
 
   export {
@@ -459,10 +502,17 @@ export declare namespace OpenAI {
     type UploadCompleteParams as UploadCompleteParams,
   };
 
+  export { Responses as Responses };
+
+  export type ChatModel = API.ChatModel;
+  export type ComparisonFilter = API.ComparisonFilter;
+  export type CompoundFilter = API.CompoundFilter;
   export type ErrorObject = API.ErrorObject;
   export type FunctionDefinition = API.FunctionDefinition;
   export type FunctionParameters = API.FunctionParameters;
   export type Metadata = API.Metadata;
+  export type Reasoning = API.Reasoning;
+  export type ReasoningEffort = API.ReasoningEffort;
   export type ResponseFormatJSONObject = API.ResponseFormatJSONObject;
   export type ResponseFormatJSONSchema = API.ResponseFormatJSONSchema;
   export type ResponseFormatText = API.ResponseFormatText;

package/src/lib/ResponsesParser.ts

@@ -0,0 +1,262 @@
+import { OpenAIError } from '../error';
+import type { ChatCompletionTool } from '../resources/chat/completions';
+import {
+  type FunctionTool,
+  type ParsedContent,
+  type ParsedResponse,
+  type ParsedResponseFunctionToolCall,
+  type ParsedResponseOutputItem,
+  type Response,
+  type ResponseCreateParamsBase,
+  type ResponseCreateParamsNonStreaming,
+  type ResponseFunctionToolCall,
+  type Tool,
+} from '../resources/responses/responses';
+import { type AutoParseableTextFormat, isAutoParsableResponseFormat } from '../lib/parser';
+
+type ParseableToolsParams = Array<Tool> | ChatCompletionTool | null;
+
+export type ResponseCreateParamsWithTools = ResponseCreateParamsBase & {
+  tools?: ParseableToolsParams;
+};
+
+export type ExtractParsedContentFromParams<Params extends ResponseCreateParamsWithTools> =
+  NonNullable<Params['text']>['format'] extends AutoParseableTextFormat<infer P> ? P : null;
+
+export function maybeParseResponse<
+  Params extends ResponseCreateParamsBase | null,
+  ParsedT = Params extends null ? null : ExtractParsedContentFromParams<NonNullable<Params>>,
+>(response: Response, params: Params): ParsedResponse<ParsedT> {
+  if (!params || !hasAutoParseableInput(params)) {
+    return {
+      ...response,
+      output_parsed: null,
+      output: response.output.map((item) => {
+        if (item.type === 'function_call') {
+          return {
+            ...item,
+            parsed_arguments: null,
+          };
+        }
+
+        if (item.type === 'message') {
+          return {
+            ...item,
+            content: item.content.map((content) => ({
+              ...content,
+              parsed: null,
+            })),
+          };
+        } else {
+          return item;
+        }
+      }),
+    };
+  }
+
+  return parseResponse(response, params);
+}
+
+export function parseResponse<
+  Params extends ResponseCreateParamsBase,
+  ParsedT = ExtractParsedContentFromParams<Params>,
+>(response: Response, params: Params): ParsedResponse<ParsedT> {
+  const output: Array<ParsedResponseOutputItem<ParsedT>> = response.output.map(
+    (item): ParsedResponseOutputItem<ParsedT> => {
+      if (item.type === 'function_call') {
+        return {
+          ...item,
+          parsed_arguments: parseToolCall(params, item),
+        };
+      }
+      if (item.type === 'message') {
+        const content: Array<ParsedContent<ParsedT>> = item.content.map((content) => {
+          if (content.type === 'output_text') {
+            return {
+              ...content,
+              parsed: parseTextFormat(params, content.text),
+            };
+          }
+
+          return content;
+        });
+
+        return {
+          ...item,
+          content,
+        };
+      }
+
+      return item;
+    },
+  );
+
+  const parsed: Omit<ParsedResponse<ParsedT>, 'output_parsed'> = Object.assign({}, response, { output });
+  if (!Object.getOwnPropertyDescriptor(response, 'output_text')) {
+    addOutputText(parsed);
+  }
+
+  Object.defineProperty(parsed, 'output_parsed', {
+    enumerable: true,
+    get() {
+      for (const output of parsed.output) {
+        if (output.type !== 'message') {
+          continue;
+        }
+
+        for (const content of output.content) {
+          if (content.type === 'output_text' && content.parsed !== null) {
+            return content.parsed;
+          }
+        }
+      }
+
+      return null;
+    },
+  });
+
+  return parsed as ParsedResponse<ParsedT>;
+}
+
+function parseTextFormat<
+  Params extends ResponseCreateParamsBase,
+  ParsedT = ExtractParsedContentFromParams<Params>,
+>(params: Params, content: string): ParsedT | null {
+  if (params.text?.format?.type !== 'json_schema') {
+    return null;
+  }
+
+  if ('$parseRaw' in params.text?.format) {
+    const text_format = params.text?.format as unknown as AutoParseableTextFormat<ParsedT>;
+    return text_format.$parseRaw(content);
+  }
+
+  return JSON.parse(content);
+}
+
+export function hasAutoParseableInput(params: ResponseCreateParamsWithTools): boolean {
+  if (isAutoParsableResponseFormat(params.text?.format)) {
+    return true;
+  }
+
+  return false;
+}
+
+type ToolOptions = {
+  name: string;
+  arguments: any;
+  function?: ((args: any) => any) | undefined;
+};
+
+export type AutoParseableResponseTool<
+  OptionsT extends ToolOptions,
+  HasFunction = OptionsT['function'] extends Function ? true : false,
+> = FunctionTool & {
+  __arguments: OptionsT['arguments']; // type-level only
+  __name: OptionsT['name']; // type-level only
+
+  $brand: 'auto-parseable-tool';
+  $callback: ((args: OptionsT['arguments']) => any) | undefined;
+  $parseRaw(args: string): OptionsT['arguments'];
+};
+
+export function makeParseableResponseTool<OptionsT extends ToolOptions>(
+  tool: FunctionTool,
+  {
+    parser,
+    callback,
+  }: {
+    parser: (content: string) => OptionsT['arguments'];
+    callback: ((args: any) => any) | undefined;
+  },
+): AutoParseableResponseTool<OptionsT['arguments']> {
+  const obj = { ...tool };
+
+  Object.defineProperties(obj, {
+    $brand: {
+      value: 'auto-parseable-tool',
+      enumerable: false,
+    },
+    $parseRaw: {
+      value: parser,
+      enumerable: false,
+    },
+    $callback: {
+      value: callback,
+      enumerable: false,
+    },
+  });
+
+  return obj as AutoParseableResponseTool<OptionsT['arguments']>;
+}
+
+export function isAutoParsableTool(tool: any): tool is AutoParseableResponseTool<any> {
+  return tool?.['$brand'] === 'auto-parseable-tool';
+}
+
+function getInputToolByName(input_tools: Array<Tool>, name: string): FunctionTool | undefined {
+  return input_tools.find((tool) => tool.type === 'function' && tool.name === name) as
+    | FunctionTool
+    | undefined;
+}
+
+function parseToolCall<Params extends ResponseCreateParamsBase>(
+  params: Params,
+  toolCall: ResponseFunctionToolCall,
+): ParsedResponseFunctionToolCall {
+  const inputTool = getInputToolByName(params.tools ?? [], toolCall.name);
+
+  return {
+    ...toolCall,
+    ...toolCall,
+    parsed_arguments:
+      isAutoParsableTool(inputTool) ? inputTool.$parseRaw(toolCall.arguments)
+      : inputTool?.strict ? JSON.parse(toolCall.arguments)
+      : null,
+  };
+}
+
+export function shouldParseToolCall(
+  params: ResponseCreateParamsNonStreaming | null | undefined,
+  toolCall: ResponseFunctionToolCall,
+): boolean {
+  if (!params) {
+    return false;
+  }
+
+  const inputTool = getInputToolByName(params.tools ?? [], toolCall.name);
+  return isAutoParsableTool(inputTool) || inputTool?.strict || false;
+}
+
+export function validateInputTools(tools: ChatCompletionTool[] | undefined) {
+  for (const tool of tools ?? []) {
+    if (tool.type !== 'function') {
+      throw new OpenAIError(
+        `Currently only \`function\` tool types support auto-parsing; Received \`${tool.type}\``,
+      );
+    }
+
+    if (tool.function.strict !== true) {
+      throw new OpenAIError(
+        `The \`${tool.function.name}\` tool is not marked with \`strict: true\`. Only strict function tools can be auto-parsed`,
+      );
+    }
+  }
+}
+
+export function addOutputText(rsp: Response): void {
+  const texts: string[] = [];
+  for (const output of rsp.output) {
+    if (output.type !== 'message') {
+      continue;
+    }
+
+    for (const content of output.content) {
+      if (content.type === 'output_text') {
+        texts.push(content.text);
+      }
+    }
+  }
+
+  rsp.output_text = texts.join('');
+}

package/src/lib/parser.ts

@@ -14,6 +14,7 @@ import {
 } from '../resources/beta/chat/completions';
 import { ResponseFormatJSONSchema } from '../resources/shared';
 import { ContentFilterFinishReasonError, LengthFinishReasonError, OpenAIError } from '../error';
+import { type ResponseFormatTextJSONSchemaConfig } from '../resources/responses/responses';
 
 type AnyChatCompletionCreateParams =
   | ChatCompletionCreateParams
@@ -51,6 +52,33 @@ export function makeParseableResponseFormat<ParsedT>(
   return obj as AutoParseableResponseFormat<ParsedT>;
 }
 
+export type AutoParseableTextFormat<ParsedT> = ResponseFormatTextJSONSchemaConfig & {
+  __output: ParsedT; // type-level only
+
+  $brand: 'auto-parseable-response-format';
+  $parseRaw(content: string): ParsedT;
+};
+
+export function makeParseableTextFormat<ParsedT>(
+  response_format: ResponseFormatTextJSONSchemaConfig,
+  parser: (content: string) => ParsedT,
+): AutoParseableTextFormat<ParsedT> {
+  const obj = { ...response_format };
+
+  Object.defineProperties(obj, {
+    $brand: {
+      value: 'auto-parseable-response-format',
+      enumerable: false,
+    },
+    $parseRaw: {
+      value: parser,
+      enumerable: false,
+    },
+  });
+
+  return obj as AutoParseableTextFormat<ParsedT>;
+}
+
 export function isAutoParsableResponseFormat<ParsedT>(
   response_format: any,
 ): response_format is AutoParseableResponseFormat<ParsedT> {

package/src/lib/responses/EventTypes.ts

@@ -0,0 +1,76 @@
+import {
+  ResponseAudioDeltaEvent,
+  ResponseAudioDoneEvent,
+  ResponseAudioTranscriptDeltaEvent,
+  ResponseAudioTranscriptDoneEvent,
+  ResponseCodeInterpreterCallCodeDeltaEvent,
+  ResponseCodeInterpreterCallCodeDoneEvent,
+  ResponseCodeInterpreterCallCompletedEvent,
+  ResponseCodeInterpreterCallInProgressEvent,
+  ResponseCodeInterpreterCallInterpretingEvent,
+  ResponseCompletedEvent,
+  ResponseContentPartAddedEvent,
+  ResponseContentPartDoneEvent,
+  ResponseCreatedEvent,
+  ResponseErrorEvent,
+  ResponseFailedEvent,
+  ResponseFileSearchCallCompletedEvent,
+  ResponseFileSearchCallInProgressEvent,
+  ResponseFileSearchCallSearchingEvent,
+  ResponseFunctionCallArgumentsDeltaEvent as RawResponseFunctionCallArgumentsDeltaEvent,
+  ResponseFunctionCallArgumentsDoneEvent,
+  ResponseInProgressEvent,
+  ResponseOutputItemAddedEvent,
+  ResponseOutputItemDoneEvent,
+  ResponseRefusalDeltaEvent,
+  ResponseRefusalDoneEvent,
+  ResponseTextAnnotationDeltaEvent,
+  ResponseTextDeltaEvent as RawResponseTextDeltaEvent,
+  ResponseTextDoneEvent,
+  ResponseIncompleteEvent,
+  ResponseWebSearchCallCompletedEvent,
+  ResponseWebSearchCallInProgressEvent,
+  ResponseWebSearchCallSearchingEvent,
+} from '../../resources/responses/responses';
+
+export type ResponseFunctionCallArgumentsDeltaEvent = RawResponseFunctionCallArgumentsDeltaEvent & {
+  snapshot: string;
+};
+
+export type ResponseTextDeltaEvent = RawResponseTextDeltaEvent & {
+  snapshot: string;
+};
+
+export type ParsedResponseStreamEvent =
+  | ResponseAudioDeltaEvent
+  | ResponseAudioDoneEvent
+  | ResponseAudioTranscriptDeltaEvent
+  | ResponseAudioTranscriptDoneEvent
+  | ResponseCodeInterpreterCallCodeDeltaEvent
+  | ResponseCodeInterpreterCallCodeDoneEvent
+  | ResponseCodeInterpreterCallCompletedEvent
+  | ResponseCodeInterpreterCallInProgressEvent
+  | ResponseCodeInterpreterCallInterpretingEvent
+  | ResponseCompletedEvent
+  | ResponseContentPartAddedEvent
+  | ResponseContentPartDoneEvent
+  | ResponseCreatedEvent
+  | ResponseErrorEvent
+  | ResponseFileSearchCallCompletedEvent
+  | ResponseFileSearchCallInProgressEvent
+  | ResponseFileSearchCallSearchingEvent
+  | ResponseFunctionCallArgumentsDeltaEvent
+  | ResponseFunctionCallArgumentsDoneEvent
+  | ResponseInProgressEvent
+  | ResponseFailedEvent
+  | ResponseIncompleteEvent
+  | ResponseOutputItemAddedEvent
+  | ResponseOutputItemDoneEvent
+  | ResponseRefusalDeltaEvent
+  | ResponseRefusalDoneEvent
+  | ResponseTextAnnotationDeltaEvent
+  | ResponseTextDeltaEvent
+  | ResponseTextDoneEvent
+  | ResponseWebSearchCallCompletedEvent
+  | ResponseWebSearchCallInProgressEvent
+  | ResponseWebSearchCallSearchingEvent;