@depup/openai 6.31.0-depup.0

package/src/lib/responses/EventTypes.ts

@@ -0,0 +1,74 @@
+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,
+  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
+  | ResponseTextDeltaEvent
+  | ResponseTextDoneEvent
+  | ResponseWebSearchCallCompletedEvent
+  | ResponseWebSearchCallInProgressEvent
+  | ResponseWebSearchCallSearchingEvent;

package/src/lib/responses/ResponseStream.ts

@@ -0,0 +1,368 @@
+import {
+  ResponseTextConfig,
+  type ParsedResponse,
+  type Response,
+  type ResponseCreateParamsBase,
+  type ResponseCreateParamsStreaming,
+  type ResponseStreamEvent,
+} from '../../resources/responses/responses';
+import { RequestOptions } from '../../internal/request-options';
+import { APIUserAbortError, OpenAIError } from '../../error';
+import OpenAI from '../../index';
+import { type BaseEvents, EventStream } from '../EventStream';
+import { type ResponseFunctionCallArgumentsDeltaEvent, type ResponseTextDeltaEvent } from './EventTypes';
+import { maybeParseResponse, ParseableToolsParams } from '../ResponsesParser';
+import { Stream } from '../../streaming';
+
+export type ResponseStreamParams = ResponseCreateAndStreamParams | ResponseStreamByIdParams;
+
+export type ResponseCreateAndStreamParams = Omit<ResponseCreateParamsBase, 'stream'> & {
+  stream?: true;
+};
+
+export type ResponseStreamByIdParams = {
+  /**
+   * The ID of the response to stream.
+   */
+  response_id: string;
+  /**
+   * If provided, the stream will start after the event with the given sequence number.
+   */
+  starting_after?: number;
+  /**
+   * Configuration options for a text response from the model. Can be plain text or
+   * structured JSON data. Learn more:
+   *
+   * - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+   * - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+   */
+  text?: ResponseTextConfig;
+
+  /**
+   * An array of tools the model may call while generating a response. When continuing a stream, provide
+   * the same tools as the original request.
+   */
+  tools?: ParseableToolsParams;
+};
+
+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?: RequestOptions,
+  ): ResponseStream<ParsedT> {
+    const runner = new ResponseStream<ParsedT>(params as ResponseCreateParamsStreaming);
+    runner._run(() =>
+      runner._createOrRetrieveResponse(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, starting_after: number | null) {
+    if (this.ended) return;
+
+    const maybeEmit = (name: string, event: ResponseStreamEvent & { snapshot?: string }) => {
+      if (starting_after == null || event.sequence_number > starting_after) {
+        this._emit(name as any, event);
+      }
+    };
+
+    const response = this.#accumulateResponse(event);
+    maybeEmit('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}`);
+          }
+
+          maybeEmit('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') {
+          maybeEmit('response.function_call_arguments.delta', {
+            ...event,
+            snapshot: output.arguments,
+          });
+        }
+        break;
+      }
+      default:
+        maybeEmit(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 _createOrRetrieveResponse(
+    client: OpenAI,
+    params: ResponseStreamParams,
+    options?: RequestOptions,
+  ): Promise<ParsedResponse<ParsedT>> {
+    const signal = options?.signal;
+    if (signal) {
+      if (signal.aborted) this.controller.abort();
+      signal.addEventListener('abort', () => this.controller.abort());
+    }
+    this.#beginRequest();
+
+    let stream: Stream<ResponseStreamEvent> | undefined;
+    let starting_after: number | null = null;
+    if ('response_id' in params) {
+      stream = await client.responses.retrieve(
+        params.response_id,
+        { stream: true },
+        { ...options, signal: this.controller.signal, stream: true },
+      );
+      starting_after = params.starting_after ?? null;
+    } else {
+      stream = await client.responses.create(
+        { ...params, stream: true },
+        { ...options, signal: this.controller.signal },
+      );
+    }
+
+    this._connected();
+    for await (const event of stream) {
+      this.#addEvent(event, starting_after);
+    }
+    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}`);
+        }
+        const type = output.type;
+        const part = event.part;
+        if (type === 'message' && part.type !== 'reasoning_text') {
+          output.content.push(part);
+        } else if (type === 'reasoning' && part.type === 'reasoning_text') {
+          if (!output.content) {
+            output.content = [];
+          }
+          output.content.push(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.reasoning_text.delta': {
+        const output = snapshot.output[event.output_index];
+        if (!output) {
+          throw new OpenAIError(`missing output at index ${event.output_index}`);
+        }
+        if (output.type === 'reasoning') {
+          const content = output.content?.[event.content_index];
+          if (!content) {
+            throw new OpenAIError(`missing content at index ${event.content_index}`);
+          }
+          if (content.type !== 'reasoning_text') {
+            throw new OpenAIError(`expected content to be 'reasoning_text', got ${content.type}`);
+          }
+          content.text += 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/lib/transform.ts

@@ -0,0 +1,193 @@
+import type { JSONSchema, JSONSchemaDefinition } from './jsonschema';
+
+export function toStrictJsonSchema(schema: JSONSchema): JSONSchema {
+  if (schema.type !== 'object') {
+    throw new Error(
+      `Root schema must have type: 'object' but got type: ${schema.type ? `'${schema.type}'` : 'undefined'}`,
+    );
+  }
+
+  const schemaCopy = structuredClone(schema);
+  return ensureStrictJsonSchema(schemaCopy, [], schemaCopy);
+}
+
+function isNullable(schema: JSONSchemaDefinition): boolean {
+  if (typeof schema === 'boolean') {
+    return false;
+  }
+  if (schema.type === 'null') {
+    return true;
+  }
+  for (const oneOfVariant of schema.oneOf ?? []) {
+    if (isNullable(oneOfVariant)) {
+      return true;
+    }
+  }
+  for (const allOfVariant of schema.anyOf ?? []) {
+    if (isNullable(allOfVariant)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Mutates the given JSON schema to ensure it conforms to the `strict` standard
+ * that the API expects.
+ */
+function ensureStrictJsonSchema(
+  jsonSchema: JSONSchemaDefinition,
+  path: string[],
+  root: JSONSchema,
+): JSONSchema {
+  if (typeof jsonSchema === 'boolean') {
+    throw new TypeError(`Expected object schema but got boolean; path=${path.join('/')}`);
+  }
+
+  if (!isObject(jsonSchema)) {
+    throw new TypeError(`Expected ${JSON.stringify(jsonSchema)} to be an object; path=${path.join('/')}`);
+  }
+
+  // Handle $defs (non-standard but sometimes used)
+  const defs = (jsonSchema as any).$defs;
+  if (isObject(defs)) {
+    for (const [defName, defSchema] of Object.entries(defs)) {
+      ensureStrictJsonSchema(defSchema as JSONSchema, [...path, '$defs', defName], root);
+    }
+  }
+
+  // Handle definitions (draft-04 style, deprecated in draft-07 but still used)
+  const definitions = (jsonSchema as any).definitions;
+  if (isObject(definitions)) {
+    for (const [definitionName, definitionSchema] of Object.entries(definitions)) {
+      ensureStrictJsonSchema(definitionSchema as JSONSchema, [...path, 'definitions', definitionName], root);
+    }
+  }
+
+  // Add additionalProperties: false to object types
+  const typ = jsonSchema.type;
+  if (typ === 'object' && !('additionalProperties' in jsonSchema)) {
+    jsonSchema.additionalProperties = false;
+  }
+
+  const required = jsonSchema.required ?? [];
+
+  // Handle object properties
+  const properties = jsonSchema.properties;
+  if (isObject(properties)) {
+    for (const [key, value] of Object.entries(properties)) {
+      if (!isNullable(value) && !required.includes(key)) {
+        throw new Error(
+          `Zod field at \`${[...path, 'properties', key].join(
+            '/',
+          )}\` uses \`.optional()\` without \`.nullable()\` which is not supported by the API. See: https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses#all-fields-must-be-required`,
+        );
+      }
+    }
+    jsonSchema.required = Object.keys(properties);
+    jsonSchema.properties = Object.fromEntries(
+      Object.entries(properties).map(([key, propSchema]) => [
+        key,
+        ensureStrictJsonSchema(propSchema, [...path, 'properties', key], root),
+      ]),
+    );
+  }
+
+  // Handle arrays
+  const items = jsonSchema.items;
+  if (isObject(items)) {
+    jsonSchema.items = ensureStrictJsonSchema(items, [...path, 'items'], root);
+  }
+
+  // Handle unions (anyOf)
+  const anyOf = jsonSchema.anyOf;
+  if (Array.isArray(anyOf)) {
+    jsonSchema.anyOf = anyOf.map((variant, i) =>
+      ensureStrictJsonSchema(variant, [...path, 'anyOf', String(i)], root),
+    );
+  }
+
+  // Handle intersections (allOf)
+  const allOf = jsonSchema.allOf;
+  if (Array.isArray(allOf)) {
+    if (allOf.length === 1) {
+      const resolved = ensureStrictJsonSchema(allOf[0]!, [...path, 'allOf', '0'], root);
+      Object.assign(jsonSchema, resolved);
+      delete jsonSchema.allOf;
+    } else {
+      jsonSchema.allOf = allOf.map((entry, i) =>
+        ensureStrictJsonSchema(entry, [...path, 'allOf', String(i)], root),
+      );
+    }
+  }
+
+  // Strip `null` defaults as there's no meaningful distinction
+  if (jsonSchema.default === null) {
+    delete jsonSchema.default;
+  }
+
+  // Handle $ref with additional properties
+  const ref = (jsonSchema as any).$ref;
+  if (ref && hasMoreThanNKeys(jsonSchema, 1)) {
+    if (typeof ref !== 'string') {
+      throw new TypeError(`Received non-string $ref - ${ref}; path=${path.join('/')}`);
+    }
+
+    const resolved = resolveRef(root, ref);
+    if (typeof resolved === 'boolean') {
+      throw new Error(`Expected \`$ref: ${ref}\` to resolve to an object schema but got boolean`);
+    }
+    if (!isObject(resolved)) {
+      throw new Error(
+        `Expected \`$ref: ${ref}\` to resolve to an object but got ${JSON.stringify(resolved)}`,
+      );
+    }
+
+    // Properties from the json schema take priority over the ones on the `$ref`
+    Object.assign(jsonSchema, { ...resolved, ...jsonSchema });
+    delete (jsonSchema as any).$ref;
+
+    // Since the schema expanded from `$ref` might not have `additionalProperties: false` applied,
+    // we call `ensureStrictJsonSchema` again to fix the inlined schema and ensure it's valid.
+    return ensureStrictJsonSchema(jsonSchema, path, root);
+  }
+
+  return jsonSchema;
+}
+
+function resolveRef(root: JSONSchema, ref: string): JSONSchemaDefinition {
+  if (!ref.startsWith('#/')) {
+    throw new Error(`Unexpected $ref format ${JSON.stringify(ref)}; Does not start with #/`);
+  }
+
+  const pathParts = ref.slice(2).split('/');
+  let resolved: any = root;
+
+  for (const key of pathParts) {
+    if (!isObject(resolved)) {
+      throw new Error(`encountered non-object entry while resolving ${ref} - ${JSON.stringify(resolved)}`);
+    }
+    const value = resolved[key];
+    if (value === undefined) {
+      throw new Error(`Key ${key} not found while resolving ${ref}`);
+    }
+    resolved = value;
+  }
+
+  return resolved;
+}
+
+function isObject<T>(obj: T | Array<any>): obj is Extract<T, Record<string, any>> {
+  return typeof obj === 'object' && obj !== null && !Array.isArray(obj);
+}
+
+function hasMoreThanNKeys(obj: Record<string, any>, n: number): boolean {
+  let i = 0;
+  for (const _ in obj) {
+    i++;
+    if (i > n) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/pagination.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/pagination instead */
+export * from './core/pagination';

package/src/realtime/index.ts

@@ -0,0 +1 @@
+export { OpenAIRealtimeError } from './internal-base';