modelmix 1.0.2

package/demo/node_modules/openai/src/lib/RunnableFunction.ts

@@ -0,0 +1,134 @@
+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 type RunnableToolFunction<Args extends object | string> =
+  Args extends string ? RunnableToolFunctionWithoutParse
+  : Args extends object ? RunnableToolFunctionWithParse<Args>
+  : never;
+
+export type RunnableToolFunctionWithoutParse = {
+  type: 'function';
+  function: RunnableFunctionWithoutParse;
+};
+export type RunnableToolFunctionWithParse<Args extends object> = {
+  type: 'function';
+  function: RunnableFunctionWithParse<Args>;
+};
+
+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];
+    };
+
+export type RunnableTools<FunctionsArgs extends BaseFunctionsArgs> =
+  [any[]] extends [FunctionsArgs] ? readonly RunnableToolFunction<any>[]
+  : {
+      [Index in keyof FunctionsArgs]: Index extends number ? RunnableToolFunction<FunctionsArgs[Index]>
+      : FunctionsArgs[Index];
+    };
+
+/**
+ * This is helper class for passing a `function` and `parse` where the `function`
+ * argument type matches the `parse` return type.
+ *
+ * @deprecated - please use ParsingToolFunction instead.
+ */
+export class ParsingFunction<Args extends object> {
+  function: RunnableFunctionWithParse<Args>['function'];
+  parse: RunnableFunctionWithParse<Args>['parse'];
+  parameters: RunnableFunctionWithParse<Args>['parameters'];
+  description: RunnableFunctionWithParse<Args>['description'];
+  name?: RunnableFunctionWithParse<Args>['name'];
+
+  constructor(input: RunnableFunctionWithParse<Args>) {
+    this.function = input.function;
+    this.parse = input.parse;
+    this.parameters = input.parameters;
+    this.description = input.description;
+    this.name = input.name;
+  }
+}
+
+/**
+ * This is helper class for passing a `function` and `parse` where the `function`
+ * argument type matches the `parse` return type.
+ */
+export class ParsingToolFunction<Args extends object> {
+  type: 'function';
+  function: RunnableFunctionWithParse<Args>;
+
+  constructor(input: RunnableFunctionWithParse<Args>) {
+    this.type = 'function';
+    this.function = input;
+  }
+}

package/demo/node_modules/openai/src/lib/Util.ts

@@ -0,0 +1,23 @@
+/**
+ * Like `Promise.allSettled()` but throws an error if any promises are rejected.
+ */
+export const allSettledWithThrow = async <R>(promises: Promise<R>[]): Promise<R[]> => {
+  const results = await Promise.allSettled(promises);
+  const rejected = results.filter((result): result is PromiseRejectedResult => result.status === 'rejected');
+  if (rejected.length) {
+    for (const result of rejected) {
+      console.error(result.reason);
+    }
+
+    throw new Error(`${rejected.length} promise(s) failed - see the above errors`);
+  }
+
+  // Note: TS was complaining about using `.filter().map()` here for some reason
+  const values: R[] = [];
+  for (const result of results) {
+    if (result.status === 'fulfilled') {
+      values.push(result.value);
+    }
+  }
+  return values;
+};

package/demo/node_modules/openai/src/lib/chatCompletionUtils.ts

@@ -0,0 +1,28 @@
+import {
+  type ChatCompletionAssistantMessageParam,
+  type ChatCompletionFunctionMessageParam,
+  type ChatCompletionMessageParam,
+  type ChatCompletionToolMessageParam,
+} from "../resources";
+
+export const isAssistantMessage = (
+  message: ChatCompletionMessageParam | null | undefined,
+): message is ChatCompletionAssistantMessageParam => {
+  return message?.role === 'assistant';
+};
+
+export const isFunctionMessage = (
+  message: ChatCompletionMessageParam | null | undefined,
+): message is ChatCompletionFunctionMessageParam => {
+  return message?.role === 'function';
+};
+
+export const isToolMessage = (
+  message: ChatCompletionMessageParam | null | undefined,
+): message is ChatCompletionToolMessageParam => {
+  return message?.role === 'tool';
+};
+
+export function isPresent<T>(obj: T | null | undefined): obj is T {
+  return obj != null;
+}

package/demo/node_modules/openai/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/demo/node_modules/openai/src/pagination.ts

@@ -0,0 +1,98 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { AbstractPage, Response, APIClient, FinalRequestOptions, PageInfo } from './core';
+
+export interface PageResponse<Item> {
+  data: Array<Item>;
+
+  object: string;
+}
+
+/**
+ * Note: no pagination actually occurs yet, this is for forwards-compatibility.
+ */
+export class Page<Item> extends AbstractPage<Item> implements PageResponse<Item> {
+  data: Array<Item>;
+
+  object: string;
+
+  constructor(client: APIClient, response: Response, body: PageResponse<Item>, options: FinalRequestOptions) {
+    super(client, response, body, options);
+
+    this.data = body.data || [];
+    this.object = body.object;
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.data ?? [];
+  }
+
+  // @deprecated Please use `nextPageInfo()` instead
+  /**
+   * This page represents a response that isn't actually paginated at the API level
+   * so there will never be any next page params.
+   */
+  nextPageParams(): null {
+    return null;
+  }
+
+  nextPageInfo(): null {
+    return null;
+  }
+}
+
+export interface CursorPageResponse<Item> {
+  data: Array<Item>;
+}
+
+export interface CursorPageParams {
+  after?: string;
+
+  limit?: number;
+}
+
+export class CursorPage<Item extends { id: string }>
+  extends AbstractPage<Item>
+  implements CursorPageResponse<Item>
+{
+  data: Array<Item>;
+
+  constructor(
+    client: APIClient,
+    response: Response,
+    body: CursorPageResponse<Item>,
+    options: FinalRequestOptions,
+  ) {
+    super(client, response, body, options);
+
+    this.data = body.data || [];
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.data ?? [];
+  }
+
+  // @deprecated Please use `nextPageInfo()` instead
+  nextPageParams(): Partial<CursorPageParams> | null {
+    const info = this.nextPageInfo();
+    if (!info) return null;
+    if ('params' in info) return info.params;
+    const params = Object.fromEntries(info.url.searchParams);
+    if (!Object.keys(params).length) return null;
+    return params;
+  }
+
+  nextPageInfo(): PageInfo | null {
+    const data = this.getPaginatedItems();
+    if (!data.length) {
+      return null;
+    }
+
+    const id = data[data.length - 1]?.id;
+    if (!id) {
+      return null;
+    }
+
+    return { params: { after: id } };
+  }
+}

package/demo/node_modules/openai/src/resource.ts

@@ -0,0 +1,11 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { OpenAI } from './index';
+
+export class APIResource {
+  protected _client: OpenAI;
+
+  constructor(client: OpenAI) {
+    this._client = client;
+  }
+}

package/demo/node_modules/openai/src/resources/audio/audio.ts

@@ -0,0 +1,23 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as SpeechAPI from './speech';
+import * as TranscriptionsAPI from './transcriptions';
+import * as TranslationsAPI from './translations';
+
+export class Audio extends APIResource {
+  transcriptions: TranscriptionsAPI.Transcriptions = new TranscriptionsAPI.Transcriptions(this._client);
+  translations: TranslationsAPI.Translations = new TranslationsAPI.Translations(this._client);
+  speech: SpeechAPI.Speech = new SpeechAPI.Speech(this._client);
+}
+
+export namespace Audio {
+  export import Transcriptions = TranscriptionsAPI.Transcriptions;
+  export import Transcription = TranscriptionsAPI.Transcription;
+  export import TranscriptionCreateParams = TranscriptionsAPI.TranscriptionCreateParams;
+  export import Translations = TranslationsAPI.Translations;
+  export import Translation = TranslationsAPI.Translation;
+  export import TranslationCreateParams = TranslationsAPI.TranslationCreateParams;
+  export import Speech = SpeechAPI.Speech;
+  export import SpeechCreateParams = SpeechAPI.SpeechCreateParams;
+}

package/demo/node_modules/openai/src/resources/audio/index.ts

@@ -0,0 +1,6 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Audio } from './audio';
+export { SpeechCreateParams, Speech } from './speech';
+export { Transcription, TranscriptionCreateParams, Transcriptions } from './transcriptions';
+export { Translation, TranslationCreateParams, Translations } from './translations';

package/demo/node_modules/openai/src/resources/audio/speech.ts

@@ -0,0 +1,52 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import * as Core from '../../core';
+import { APIResource } from '../../resource';
+import { type Response } from '../../_shims/index';
+import * as SpeechAPI from './speech';
+
+export class Speech extends APIResource {
+  /**
+   * Generates audio from the input text.
+   */
+  create(body: SpeechCreateParams, options?: Core.RequestOptions): Core.APIPromise<Response> {
+    return this._client.post('/audio/speech', { body, ...options, __binaryResponse: true });
+  }
+}
+
+export interface SpeechCreateParams {
+  /**
+   * The text to generate audio for. The maximum length is 4096 characters.
+   */
+  input: string;
+
+  /**
+   * One of the available [TTS models](https://platform.openai.com/docs/models/tts):
+   * `tts-1` or `tts-1-hd`
+   */
+  model: (string & {}) | 'tts-1' | 'tts-1-hd';
+
+  /**
+   * The voice to use when generating the audio. Supported voices are `alloy`,
+   * `echo`, `fable`, `onyx`, `nova`, and `shimmer`. Previews of the voices are
+   * available in the
+   * [Text to speech guide](https://platform.openai.com/docs/guides/text-to-speech/voice-options).
+   */
+  voice: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer';
+
+  /**
+   * The format to audio in. Supported formats are `mp3`, `opus`, `aac`, `flac`,
+   * `wav`, and `pcm`.
+   */
+  response_format?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
+
+  /**
+   * The speed of the generated audio. Select a value from `0.25` to `4.0`. `1.0` is
+   * the default.
+   */
+  speed?: number;
+}
+
+export namespace Speech {
+  export import SpeechCreateParams = SpeechAPI.SpeechCreateParams;
+}

package/demo/node_modules/openai/src/resources/audio/transcriptions.ts

@@ -0,0 +1,84 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import * as Core from '../../core';
+import { APIResource } from '../../resource';
+import * as TranscriptionsAPI from './transcriptions';
+import { type Uploadable, multipartFormRequestOptions } from '../../core';
+
+export class Transcriptions extends APIResource {
+  /**
+   * Transcribes audio into the input language.
+   */
+  create(body: TranscriptionCreateParams, options?: Core.RequestOptions): Core.APIPromise<Transcription> {
+    return this._client.post('/audio/transcriptions', multipartFormRequestOptions({ body, ...options }));
+  }
+}
+
+/**
+ * Represents a transcription response returned by model, based on the provided
+ * input.
+ */
+export interface Transcription {
+  /**
+   * The transcribed text.
+   */
+  text: string;
+}
+
+export interface TranscriptionCreateParams {
+  /**
+   * The audio file object (not file name) to transcribe, in one of these formats:
+   * flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
+   */
+  file: Uploadable;
+
+  /**
+   * ID of the model to use. Only `whisper-1` (which is powered by our open source
+   * Whisper V2 model) is currently available.
+   */
+  model: (string & {}) | 'whisper-1';
+
+  /**
+   * The language of the input audio. Supplying the input language in
+   * [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) format will
+   * improve accuracy and latency.
+   */
+  language?: string;
+
+  /**
+   * An optional text to guide the model's style or continue a previous audio
+   * segment. The
+   * [prompt](https://platform.openai.com/docs/guides/speech-to-text/prompting)
+   * should match the audio language.
+   */
+  prompt?: string;
+
+  /**
+   * The format of the transcript output, in one of these options: `json`, `text`,
+   * `srt`, `verbose_json`, or `vtt`.
+   */
+  response_format?: 'json' | 'text' | 'srt' | 'verbose_json' | 'vtt';
+
+  /**
+   * The sampling temperature, between 0 and 1. Higher values like 0.8 will make the
+   * output more random, while lower values like 0.2 will make it more focused and
+   * deterministic. If set to 0, the model will use
+   * [log probability](https://en.wikipedia.org/wiki/Log_probability) to
+   * automatically increase the temperature until certain thresholds are hit.
+   */
+  temperature?: number;
+
+  /**
+   * The timestamp granularities to populate for this transcription.
+   * `response_format` must be set `verbose_json` to use timestamp granularities.
+   * Either or both of these options are supported: `word`, or `segment`. Note: There
+   * is no additional latency for segment timestamps, but generating word timestamps
+   * incurs additional latency.
+   */
+  timestamp_granularities?: Array<'word' | 'segment'>;
+}
+
+export namespace Transcriptions {
+  export import Transcription = TranscriptionsAPI.Transcription;
+  export import TranscriptionCreateParams = TranscriptionsAPI.TranscriptionCreateParams;
+}

package/demo/node_modules/openai/src/resources/audio/translations.ts

@@ -0,0 +1,61 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import * as Core from '../../core';
+import { APIResource } from '../../resource';
+import * as TranslationsAPI from './translations';
+import { type Uploadable, multipartFormRequestOptions } from '../../core';
+
+export class Translations extends APIResource {
+  /**
+   * Translates audio into English.
+   */
+  create(body: TranslationCreateParams, options?: Core.RequestOptions): Core.APIPromise<Translation> {
+    return this._client.post('/audio/translations', multipartFormRequestOptions({ body, ...options }));
+  }
+}
+
+export interface Translation {
+  text: string;
+}
+
+export interface TranslationCreateParams {
+  /**
+   * The audio file object (not file name) translate, in one of these formats: flac,
+   * mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
+   */
+  file: Uploadable;
+
+  /**
+   * ID of the model to use. Only `whisper-1` (which is powered by our open source
+   * Whisper V2 model) is currently available.
+   */
+  model: (string & {}) | 'whisper-1';
+
+  /**
+   * An optional text to guide the model's style or continue a previous audio
+   * segment. The
+   * [prompt](https://platform.openai.com/docs/guides/speech-to-text/prompting)
+   * should be in English.
+   */
+  prompt?: string;
+
+  /**
+   * The format of the transcript output, in one of these options: `json`, `text`,
+   * `srt`, `verbose_json`, or `vtt`.
+   */
+  response_format?: string;
+
+  /**
+   * The sampling temperature, between 0 and 1. Higher values like 0.8 will make the
+   * output more random, while lower values like 0.2 will make it more focused and
+   * deterministic. If set to 0, the model will use
+   * [log probability](https://en.wikipedia.org/wiki/Log_probability) to
+   * automatically increase the temperature until certain thresholds are hit.
+   */
+  temperature?: number;
+}
+
+export namespace Translations {
+  export import Translation = TranslationsAPI.Translation;
+  export import TranslationCreateParams = TranslationsAPI.TranslationCreateParams;
+}