openai 4.14.2 → 4.15.0

package/src/lib/ChatCompletionRunner.ts

@@ -0,0 +1,42 @@
+import * as Core from "../core";
+import {
+  type Completions,
+  type ChatCompletionMessage,
+  type ChatCompletionMessageParam,
+  type ChatCompletionCreateParamsNonStreaming,
+} from "../resources/chat/completions";
+import { type RunnableFunctions, type BaseFunctionsArgs } from './RunnableFunction';
+import {
+  AbstractChatCompletionRunner,
+  AbstractChatCompletionRunnerEvents,
+} from './AbstractChatCompletionRunner';
+
+export interface ChatCompletionRunnerEvents extends AbstractChatCompletionRunnerEvents {
+  content: (content: string) => void;
+}
+
+export type ChatCompletionFunctionRunnerParams<FunctionsArgs extends BaseFunctionsArgs> = Omit<
+  ChatCompletionCreateParamsNonStreaming,
+  'functions'
+> & {
+  functions: RunnableFunctions<FunctionsArgs>;
+};
+
+export class ChatCompletionRunner extends AbstractChatCompletionRunner<ChatCompletionRunnerEvents> {
+  static runFunctions(
+    completions: Completions,
+    params: ChatCompletionFunctionRunnerParams<any[]>,
+    options?: Core.RequestOptions & { maxChatCompletions?: number },
+  ): ChatCompletionRunner {
+    const runner = new ChatCompletionRunner();
+    runner._run(() => runner._runFunctions(completions, params, options));
+    return runner;
+  }
+
+  override _addMessage(message: ChatCompletionMessage | ChatCompletionMessageParam) {
+    super._addMessage(message);
+    if (message.role === 'assistant' && message.content) {
+      this._emit('content', message.content);
+    }
+  }
+}

package/src/lib/ChatCompletionStream.ts

@@ -0,0 +1,327 @@
+import * as Core from "../core";
+import { OpenAIError, APIUserAbortError } from "../error";
+import {
+  Completions,
+  type ChatCompletion,
+  type ChatCompletionChunk,
+  type ChatCompletionCreateParams,
+  ChatCompletionCreateParamsBase,
+} from "../resources/chat/completions";
+import {
+  AbstractChatCompletionRunner,
+  type AbstractChatCompletionRunnerEvents,
+} from './AbstractChatCompletionRunner';
+import { type ReadableStream } from "../_shims/index";
+import { Stream } from "../streaming";
+
+export interface ChatCompletionStreamEvents extends AbstractChatCompletionRunnerEvents {
+  content: (contentDelta: string, contentSnapshot: string) => void;
+  chunk: (chunk: ChatCompletionChunk, snapshot: ChatCompletionSnapshot) => void;
+}
+
+export type ChatCompletionStreamParams = Omit<ChatCompletionCreateParamsBase, 'stream'> & {
+  stream?: true;
+};
+
+export class ChatCompletionStream
+  extends AbstractChatCompletionRunner<ChatCompletionStreamEvents>
+  implements AsyncIterable<ChatCompletionChunk>
+{
+  #currentChatCompletionSnapshot: ChatCompletionSnapshot | undefined;
+
+  get currentChatCompletionSnapshot(): ChatCompletionSnapshot | undefined {
+    return this.#currentChatCompletionSnapshot;
+  }
+
+  /**
+   * Intended for use on the frontend, consuming a stream produced with
+   * `.toReadableStream()` on the backend.
+   *
+   * Note that messages sent to the model do not appear in `.on('message')`
+   * in this context.
+   */
+  static fromReadableStream(stream: ReadableStream): ChatCompletionStream {
+    const runner = new ChatCompletionStream();
+    runner._run(() => runner._fromReadableStream(stream));
+    return runner;
+  }
+
+  static createChatCompletion(
+    completions: Completions,
+    params: ChatCompletionStreamParams,
+    options?: Core.RequestOptions,
+  ): ChatCompletionStream {
+    const runner = new ChatCompletionStream();
+    runner._run(() => runner._runChatCompletion(completions, { ...params, stream: true }, options));
+    return runner;
+  }
+
+  #beginRequest() {
+    if (this.ended) return;
+    this.#currentChatCompletionSnapshot = undefined;
+  }
+  #addChunk(chunk: ChatCompletionChunk) {
+    if (this.ended) return;
+    const completion = this.#accumulateChatCompletion(chunk);
+    this._emit('chunk', chunk, completion);
+    const delta = chunk.choices[0]?.delta.content;
+    const snapshot = completion.choices[0]?.message;
+    if (delta != null && snapshot?.role === 'assistant' && snapshot?.content) {
+      this._emit('content', delta, snapshot.content);
+    }
+  }
+  #endRequest(): ChatCompletion {
+    if (this.ended) {
+      throw new OpenAIError(`stream has ended, this shouldn't happen`);
+    }
+    const snapshot = this.#currentChatCompletionSnapshot;
+    if (!snapshot) {
+      throw new OpenAIError(`request ended without sending any chunks`);
+    }
+    this.#currentChatCompletionSnapshot = undefined;
+    return finalizeChatCompletion(snapshot);
+  }
+
+  protected override async _createChatCompletion(
+    completions: Completions,
+    params: ChatCompletionCreateParams,
+    options?: Core.RequestOptions,
+  ): Promise<ChatCompletion> {
+    const signal = options?.signal;
+    if (signal) {
+      if (signal.aborted) this.controller.abort();
+      signal.addEventListener('abort', () => this.controller.abort());
+    }
+    this.#beginRequest();
+    const stream = await completions.create(
+      { ...params, stream: true },
+      { ...options, signal: this.controller.signal },
+    );
+    this._connected();
+    for await (const chunk of stream) {
+      this.#addChunk(chunk);
+    }
+    if (stream.controller.signal?.aborted) {
+      throw new APIUserAbortError();
+    }
+    return this._addChatCompletion(this.#endRequest());
+  }
+
+  protected async _fromReadableStream(
+    readableStream: ReadableStream,
+    options?: Core.RequestOptions,
+  ): Promise<ChatCompletion> {
+    const signal = options?.signal;
+    if (signal) {
+      if (signal.aborted) this.controller.abort();
+      signal.addEventListener('abort', () => this.controller.abort());
+    }
+    this.#beginRequest();
+    this._connected();
+    const stream = Stream.fromReadableStream<ChatCompletionChunk>(readableStream, this.controller);
+    let chatId;
+    for await (const chunk of stream) {
+      if (chatId && chatId !== chunk.id) {
+        // A new request has been made.
+        this._addChatCompletion(this.#endRequest());
+      }
+
+      this.#addChunk(chunk);
+      chatId = chunk.id;
+    }
+    if (stream.controller.signal?.aborted) {
+      throw new APIUserAbortError();
+    }
+    return this._addChatCompletion(this.#endRequest());
+  }
+
+  #accumulateChatCompletion(chunk: ChatCompletionChunk): ChatCompletionSnapshot {
+    let snapshot = this.#currentChatCompletionSnapshot;
+    if (!snapshot) {
+      const { choices, ...rest } = chunk;
+      this.#currentChatCompletionSnapshot = snapshot = {
+        ...rest,
+        choices: [],
+      };
+    }
+    for (const { delta, finish_reason, index } of chunk.choices) {
+      let choice = snapshot.choices[index];
+      if (!choice) snapshot.choices[index] = choice = { finish_reason, index, message: delta };
+      else {
+        if (finish_reason) choice.finish_reason = finish_reason;
+        const { content, function_call, role } = delta;
+        if (content) choice.message.content = (choice.message.content || '') + content;
+        if (role) choice.message.role = role;
+        if (function_call) {
+          if (!choice.message.function_call) choice.message.function_call = function_call;
+          else {
+            if (function_call.arguments)
+              choice.message.function_call.arguments =
+                (choice.message.function_call.arguments || '') + function_call.arguments;
+            if (function_call.name) choice.message.function_call.name = function_call.name;
+          }
+        }
+      }
+    }
+    return snapshot;
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<ChatCompletionChunk> {
+    const pushQueue: ChatCompletionChunk[] = [];
+    const readQueue: ((chunk: ChatCompletionChunk | undefined) => void)[] = [];
+    let done = false;
+
+    this.on('chunk', (chunk) => {
+      const reader = readQueue.shift();
+      if (reader) {
+        reader(chunk);
+      } else {
+        pushQueue.push(chunk);
+      }
+    });
+
+    this.on('end', () => {
+      done = true;
+      for (const reader of readQueue) {
+        reader(undefined);
+      }
+      readQueue.length = 0;
+    });
+
+    return {
+      next: async (): Promise<IteratorResult<ChatCompletionChunk>> => {
+        if (!pushQueue.length) {
+          if (done) {
+            return { value: undefined, done: true };
+          }
+          return new Promise<ChatCompletionChunk | undefined>((resolve) => readQueue.push(resolve)).then(
+            (chunk) => (chunk ? { value: chunk, done: false } : { value: undefined, done: true }),
+          );
+        }
+        const chunk = pushQueue.shift()!;
+        return { value: chunk, done: false };
+      },
+    };
+  }
+
+  toReadableStream(): ReadableStream {
+    const stream = new Stream(this[Symbol.asyncIterator].bind(this), this.controller);
+    return stream.toReadableStream();
+  }
+}
+
+function finalizeChatCompletion(snapshot: ChatCompletionSnapshot): ChatCompletion {
+  const { id, choices, created, model } = snapshot;
+  return {
+    id,
+    choices: choices.map(({ message, finish_reason, index }): ChatCompletion.Choice => {
+      if (!finish_reason) throw new OpenAIError(`missing finish_reason for choice ${index}`);
+      const { content = null, function_call, role } = message;
+      if (!role) throw new OpenAIError(`missing role for choice ${index}`);
+      if (function_call) {
+        const { arguments: args, name } = function_call;
+        if (args == null) throw new OpenAIError(`missing function_call.arguments for choice ${index}`);
+        if (!name) throw new OpenAIError(`missing function_call.name for choice ${index}`);
+        return { message: { content, function_call: { arguments: args, name }, role }, finish_reason, index };
+      }
+      return { message: { content: content, role }, finish_reason, index };
+    }),
+    created,
+    model,
+    object: 'chat.completion',
+  };
+}
+
+/**
+ * Represents a streamed chunk of a chat completion response returned by model,
+ * based on the provided input.
+ */
+export interface ChatCompletionSnapshot {
+  /**
+   * A unique identifier for the chat completion.
+   */
+  id: string;
+
+  /**
+   * A list of chat completion choices. Can be more than one if `n` is greater
+   * than 1.
+   */
+  choices: Array<ChatCompletionSnapshot.Choice>;
+
+  /**
+   * The Unix timestamp (in seconds) of when the chat completion was created.
+   */
+  created: number;
+
+  /**
+   * The model to generate the completion.
+   */
+  model: string;
+}
+
+export namespace ChatCompletionSnapshot {
+  export interface Choice {
+    /**
+     * A chat completion delta generated by streamed model responses.
+     */
+    message: Choice.Message;
+
+    /**
+     * The reason the model stopped generating tokens. This will be `stop` if the model
+     * hit a natural stop point or a provided stop sequence, `length` if the maximum
+     * number of tokens specified in the request was reached, `content_filter` if
+     * content was omitted due to a flag from our content filters, or `function_call`
+     * if the model called a function.
+     */
+    finish_reason: 'stop' | 'length' | 'function_call' | 'content_filter' | null;
+
+    /**
+     * The index of the choice in the list of choices.
+     */
+    index: number;
+  }
+
+  export namespace Choice {
+    /**
+     * A chat completion delta generated by streamed model responses.
+     */
+    export interface Message {
+      /**
+       * The contents of the chunk message.
+       */
+      content?: string | null;
+
+      /**
+       * The name and arguments of a function that should be called, as generated by the
+       * model.
+       */
+      function_call?: Message.FunctionCall;
+
+      /**
+       * The role of the author of this message.
+       */
+      role?: 'system' | 'user' | 'assistant' | 'function';
+    }
+
+    export namespace Message {
+      /**
+       * The name and arguments of a function that should be called, as generated by the
+       * model.
+       */
+      export interface FunctionCall {
+        /**
+         * The arguments to call the function with, as generated by the model in JSON
+         * format. Note that the model does not always generate valid JSON, and may
+         * hallucinate parameters not defined by your function schema. Validate the
+         * arguments in your code before calling your function.
+         */
+        arguments?: string;
+
+        /**
+         * The name of the function to call.
+         */
+        name?: string;
+      }
+    }
+  }
+}

package/src/lib/ChatCompletionStreamingRunner.ts

@@ -0,0 +1,43 @@
+import * as Core from "../core";
+import {
+  Completions,
+  type ChatCompletionChunk,
+  type ChatCompletionCreateParamsStreaming,
+} from "../resources/chat/completions";
+import { type AbstractChatCompletionRunnerEvents } from './AbstractChatCompletionRunner';
+import { type ReadableStream } from "../_shims/index";
+import { type BaseFunctionsArgs, type RunnableFunctions } from './RunnableFunction';
+import { ChatCompletionSnapshot, ChatCompletionStream } from './ChatCompletionStream';
+
+export interface ChatCompletionStreamEvents extends AbstractChatCompletionRunnerEvents {
+  content: (contentDelta: string, contentSnapshot: string) => void;
+  chunk: (chunk: ChatCompletionChunk, snapshot: ChatCompletionSnapshot) => void;
+}
+
+export type ChatCompletionStreamingFunctionRunnerParams<FunctionsArgs extends BaseFunctionsArgs> = Omit<
+  ChatCompletionCreateParamsStreaming,
+  'functions'
+> & {
+  functions: RunnableFunctions<FunctionsArgs>;
+};
+
+export class ChatCompletionStreamingRunner
+  extends ChatCompletionStream
+  implements AsyncIterable<ChatCompletionChunk>
+{
+  static override fromReadableStream(stream: ReadableStream): ChatCompletionStreamingRunner {
+    const runner = new ChatCompletionStreamingRunner();
+    runner._run(() => runner._fromReadableStream(stream));
+    return runner;
+  }
+
+  static runFunctions<T extends (string | object)[]>(
+    completions: Completions,
+    params: ChatCompletionStreamingFunctionRunnerParams<T>,
+    options?: Core.RequestOptions & { maxChatCompletions?: number },
+  ): ChatCompletionStreamingRunner {
+    const runner = new ChatCompletionStreamingRunner();
+    runner._run(() => runner._runFunctions(completions, params, options));
+    return runner;
+  }
+}

package/src/lib/RunnableFunction.ts

@@ -0,0 +1,96 @@
+import { type ChatCompletionRunner } from './ChatCompletionRunner';
+import { type ChatCompletionStreamingRunner } from './ChatCompletionStreamingRunner';
+import { JSONSchema } from './jsonschema';
+
+type PromiseOrValue<T> = T | Promise<T>;
+
+export type RunnableFunctionWithParse<Args extends object> = {
+  /**
+   * @param args the return value from `parse`.
+   * @param runner the runner evaluating this callback.
+   * @returns a string to send back to OpenAI.
+   */
+  function: (
+    args: Args,
+    runner: ChatCompletionRunner | ChatCompletionStreamingRunner,
+  ) => PromiseOrValue<unknown>;
+  /**
+   * @param input the raw args from the OpenAI function call.
+   * @returns the parsed arguments to pass to `function`
+   */
+  parse: (input: string) => PromiseOrValue<Args>;
+  /**
+   * The parameters the function accepts, describes as a JSON Schema object.
+   */
+  parameters: JSONSchema;
+  /**
+   * A description of what the function does, used by the model to choose when and how to call the function.
+   */
+  description: string;
+  /**
+   * The name of the function to be called. Will default to function.name if omitted.
+   */
+  name?: string | undefined;
+};
+
+export type RunnableFunctionWithoutParse = {
+  /**
+   * @param args the raw args from the OpenAI function call.
+   * @returns a string to send back to OpenAI
+   */
+  function: (
+    args: string,
+    runner: ChatCompletionRunner | ChatCompletionStreamingRunner,
+  ) => PromiseOrValue<unknown>;
+  /**
+   * The parameters the function accepts, describes as a JSON Schema object.
+   */
+  parameters: JSONSchema;
+  /**
+   * A description of what the function does, used by the model to choose when and how to call the function.
+   */
+  description: string;
+  /**
+   * The name of the function to be called. Will default to function.name if omitted.
+   */
+  name?: string | undefined;
+};
+
+export type RunnableFunction<Args extends object | string> =
+  Args extends string ? RunnableFunctionWithoutParse
+  : Args extends object ? RunnableFunctionWithParse<Args>
+  : never;
+
+export function isRunnableFunctionWithParse<Args extends object>(
+  fn: any,
+): fn is RunnableFunctionWithParse<Args> {
+  return typeof (fn as any).parse === 'function';
+}
+
+export type BaseFunctionsArgs = readonly (object | string)[];
+
+export type RunnableFunctions<FunctionsArgs extends BaseFunctionsArgs> =
+  [any[]] extends [FunctionsArgs] ? readonly RunnableFunction<any>[]
+  : {
+      [Index in keyof FunctionsArgs]: Index extends number ? RunnableFunction<FunctionsArgs[Index]>
+      : FunctionsArgs[Index];
+    };
+
+/**
+ * This is helper class for passing a `function` and `parse` where the `function`
+ * argument type matches the `parse` return type.
+ */
+export class ParsingFunction<Args extends object> {
+  constructor(input: RunnableFunctionWithParse<Args>) {
+    this.function = input.function;
+    this.parse = input.parse;
+    this.parameters = input.parameters;
+    this.description = input.description;
+    this.name = input.name;
+  }
+  function: RunnableFunctionWithParse<Args>['function'];
+  parse: RunnableFunctionWithParse<Args>['parse'];
+  parameters: RunnableFunctionWithParse<Args>['parameters'];
+  description: RunnableFunctionWithParse<Args>['description'];
+  name?: RunnableFunctionWithParse<Args>['name'];
+}

package/src/lib/jsonschema.ts

@@ -0,0 +1,148 @@
+// File mostly copied from @types/json-schema, but stripped down a bit for brevity
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/817274f3280152ba2929a6067c93df8b34c4c9aa/types/json-schema/index.d.ts
+//
+// ==================================================================================================
+// JSON Schema Draft 07
+// ==================================================================================================
+// https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+// --------------------------------------------------------------------------------------------------
+
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+export type JSONSchemaTypeName =
+  | ({} & string)
+  | 'string'
+  | 'number'
+  | 'integer'
+  | 'boolean'
+  | 'object'
+  | 'array'
+  | 'null';
+
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+export type JSONSchemaType =
+  | string //
+  | number
+  | boolean
+  | JSONSchemaObject
+  | JSONSchemaArray
+  | null;
+
+// Workaround for infinite type recursion
+export interface JSONSchemaObject {
+  [key: string]: JSONSchemaType;
+}
+
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+export interface JSONSchemaArray extends Array<JSONSchemaType> {}
+
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-07/schema#'
+ * - 'http://json-schema.org/draft-07/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+export type JSONSchemaVersion = string;
+
+/**
+ * JSON Schema v7
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+ */
+export type JSONSchemaDefinition = JSONSchema | boolean;
+export interface JSONSchema {
+  $id?: string | undefined;
+  $comment?: string | undefined;
+
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1
+   */
+  type?: JSONSchemaTypeName | JSONSchemaTypeName[] | undefined;
+  enum?: JSONSchemaType[] | undefined;
+  const?: JSONSchemaType | undefined;
+
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2
+   */
+  multipleOf?: number | undefined;
+  maximum?: number | undefined;
+  exclusiveMaximum?: number | undefined;
+  minimum?: number | undefined;
+  exclusiveMinimum?: number | undefined;
+
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3
+   */
+  maxLength?: number | undefined;
+  minLength?: number | undefined;
+  pattern?: string | undefined;
+
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4
+   */
+  items?: JSONSchemaDefinition | JSONSchemaDefinition[] | undefined;
+  additionalItems?: JSONSchemaDefinition | undefined;
+  maxItems?: number | undefined;
+  minItems?: number | undefined;
+  uniqueItems?: boolean | undefined;
+  contains?: JSONSchemaDefinition | undefined;
+
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5
+   */
+  maxProperties?: number | undefined;
+  minProperties?: number | undefined;
+  required?: string[] | undefined;
+  properties?:
+    | {
+        [key: string]: JSONSchemaDefinition;
+      }
+    | undefined;
+  patternProperties?:
+    | {
+        [key: string]: JSONSchemaDefinition;
+      }
+    | undefined;
+  additionalProperties?: JSONSchemaDefinition | undefined;
+  propertyNames?: JSONSchemaDefinition | undefined;
+
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6
+   */
+  if?: JSONSchemaDefinition | undefined;
+  then?: JSONSchemaDefinition | undefined;
+  else?: JSONSchemaDefinition | undefined;
+
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7
+   */
+  allOf?: JSONSchemaDefinition[] | undefined;
+  anyOf?: JSONSchemaDefinition[] | undefined;
+  oneOf?: JSONSchemaDefinition[] | undefined;
+  not?: JSONSchemaDefinition | undefined;
+
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7
+   */
+  format?: string | undefined;
+
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
+   */
+  title?: string | undefined;
+  description?: string | undefined;
+  default?: JSONSchemaType | undefined;
+  readOnly?: boolean | undefined;
+  writeOnly?: boolean | undefined;
+  examples?: JSONSchemaType | undefined;
+}

package/src/resources/beta/beta.ts

@@ -0,0 +1,12 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import { APIResource } from "../../resource";
+import * as ChatAPI from "./chat/chat";
+
+export class Beta extends APIResource {
+  chat: ChatAPI.Chat = new ChatAPI.Chat(this.client);
+}
+
+export namespace Beta {
+  export import Chat = ChatAPI.Chat;
+}

package/src/resources/beta/chat/chat.ts

@@ -0,0 +1,12 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import { APIResource } from "../../../resource";
+import * as CompletionsAPI from "./completions";
+
+export class Chat extends APIResource {
+  completions: CompletionsAPI.Completions = new CompletionsAPI.Completions(this.client);
+}
+
+export namespace Chat {
+  export import Completions = CompletionsAPI.Completions;
+}