ai 3.1.0-canary.1 → 3.1.0-canary.3

package/provider/dist/index.d.mts

@@ -1,5 +1,4 @@
-import OpenAI from 'openai';
-import MistralClient from '@mistralai/mistralai';
+type JsonSchema = Record<string, unknown>;
 
 type LanguageModelV1CallSettings = {
     /**
@@ -29,38 +28,32 @@ type LanguageModelV1CallSettings = {
      */
     topP?: number;
     /**
-     * Presence penalty setting. This is a number between 0 (no penalty)
-     * and 1 (maximum penalty). It affects the likelihood of the model to repeat
-     * information that is already in the prompt.
+     * Presence penalty setting. It affects the likelihood of the model to
+     * repeat information that is already in the prompt.
+     *
+     * The presence penalty is a number between -1 (increase repetition)
+     * and 1 (maximum penalty, decrease repetition). 0 means no penalty.
      */
     presencePenalty?: number;
     /**
-     * Frequency penalty setting. This is a number between 0 (no penalty)
-     * and 1 (maximum penalty). It affects the likelihood of the model to repeatedly
-     * use the same words or phrases.
+     * Frequency penalty setting. It affects the likelihood of the model
+     * to repeatedly use the same words or phrases.
+     *
+     * The frequency penalty is a number between -1 (increase repetition)
+     * and 1 (maximum penalty, decrease repetition). 0 means no penalty.
      */
     frequencyPenalty?: number;
     /**
-     * The seed to use for random sampling. If set and supported by the model,
-     * calls will generate deterministic results.
+     * The seed (integer) to use for random sampling. If set and supported
+     * by the model, calls will generate deterministic results.
      */
     seed?: number;
+    /**
+     * Abort signal for cancelling the operation.
+     */
+    abortSignal?: AbortSignal;
 };
 
-/**
- * Warning from the model provider for this call. The call will proceed, but e.g.
- * some settings might not be supported, which can lead to suboptimal results.
- */
-type LanguageModelV1CallWarning = {
-    type: 'unsupported-setting';
-    setting: keyof LanguageModelV1CallSettings;
-} | {
-    type: 'other';
-    message: string;
-};
-
-type JsonSchema = Record<string, unknown>;
-
 /**
  * A tool has a name, a description, and a set of parameters.
  *
@@ -114,9 +107,9 @@ interface LanguageModelV1TextPart {
 interface LanguageModelV1ImagePart {
     type: 'image';
     /**
-     * Image data as a Uint8Array.
+     * Image data as a Uint8Array (e.g. from a Blob or Buffer) or a URL.
      */
-    image: Uint8Array;
+    image: Uint8Array | URL;
     /**
      * Optional mime type of the image.
      */
@@ -174,7 +167,48 @@ type LanguageModelV1CallOptions = LanguageModelV1CallSettings & {
     prompt: LanguageModelV1Prompt;
 };
 
-interface LanguageModel {
+/**
+ * Warning from the model provider for this call. The call will proceed, but e.g.
+ * some settings might not be supported, which can lead to suboptimal results.
+ */
+type LanguageModelV1CallWarning = {
+    type: 'unsupported-setting';
+    setting: keyof LanguageModelV1CallSettings;
+} | {
+    type: 'other';
+    message: string;
+};
+
+type LanguageModelV1FinishReason = 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other';
+
+type LanguageModelV1FunctionToolCall = {
+    toolCallType: 'function';
+    toolCallId: string;
+    toolName: string;
+    /**
+     * Stringified JSON object with the tool call arguments. Must match the
+     * parameters schema of the tool.
+     */
+    args: string;
+};
+
+type LanguageModelV1 = {
+    /**
+     * The language model must specify which language model interface
+     * version it implements. This will allow us to evolve the language
+     * model interface and retain backwards compatibility. The different
+     * implementation versions can be handled as a discriminated union
+     * on our side.
+     */
+    readonly specificationVersion: 'v1';
+    /**
+     * Name of the provider for logging purposes.
+     */
+    readonly provider: string;
+    /**
+     * Provider-specific model ID for logging purposes.
+     */
+    readonly modelId: string;
     /**
      * Default object generation mode that should be used with this model when
      * no mode is specified. Should be the mode with the best results for this
@@ -184,204 +218,212 @@ interface LanguageModel {
      * user to explicitly specify the object generation mode.
      */
     readonly defaultObjectGenerationMode: 'json' | 'tool' | 'grammar' | undefined;
+    /**
+     * Generates a language model output (non-streaming).
+     *
+     * Naming: "do" prefix to prevent accidental direct usage of the method
+     * by the user.
+     */
     doGenerate(options: LanguageModelV1CallOptions): PromiseLike<{
+        /**
+         * Text that the model has generated. Can be undefined if the model
+         * has only generated tool calls.
+         */
         text?: string;
-        toolCalls?: Array<LanguageModelToolCall>;
-        warnings: LanguageModelV1CallWarning[];
+        /**
+         * Tool calls that the model has generated. Can be undefined if the
+         * model has only generated text.
+         */
+        toolCalls?: Array<LanguageModelV1FunctionToolCall>;
+        /**
+         * Finish reason.
+         */
+        finishReason: LanguageModelV1FinishReason;
+        /**
+         * Usage information.
+         */
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+        };
+        /**
+         * Raw prompt and setting information for observability provider integration.
+         */
+        rawCall: {
+            /**
+             * Raw prompt after expansion and conversion to the format that the
+             * provider uses to send the information to their API.
+             */
+            rawPrompt: unknown;
+            /**
+             * Raw settings that are used for the API call. Includes provider-specific
+             * settings.
+             */
+            rawSettings: Record<string, unknown>;
+        };
+        warnings?: LanguageModelV1CallWarning[];
     }>;
+    /**
+     * Generates a language model output (streaming).
+     *
+     * Naming: "do" prefix to prevent accidental direct usage of the method
+     * by the user.
+     *
+     * @return A stream of higher-level language model output parts.
+     */
     doStream(options: LanguageModelV1CallOptions): PromiseLike<{
-        stream: ReadableStream<LanguageModelStreamPart>;
-        warnings: LanguageModelV1CallWarning[];
+        stream: ReadableStream<LanguageModelV1StreamPart>;
+        /**
+         * Raw prompt and setting information for observability provider integration.
+         */
+        rawCall: {
+            /**
+             * Raw prompt after expansion and conversion to the format that the
+             * provider uses to send the information to their API.
+             */
+            rawPrompt: unknown;
+            /**
+             * Raw settings that are used for the API call. Includes provider-specific
+             * settings.
+             */
+            rawSettings: Record<string, unknown>;
+        };
+        warnings?: LanguageModelV1CallWarning[];
     }>;
-}
-type ErrorStreamPart = {
-    type: 'error';
-    error: unknown;
-};
-type LanguageModelToolCall = {
-    toolCallId: string;
-    toolName: string;
-    args: string;
 };
-type ToolCallStreamPart = {
+type LanguageModelV1StreamPart = {
+    type: 'text-delta';
+    textDelta: string;
+} | ({
     type: 'tool-call';
-} & LanguageModelToolCall;
-type ToolCallDeltaStreamPart = {
+} & LanguageModelV1FunctionToolCall) | {
     type: 'tool-call-delta';
     toolCallId: string;
     toolName: string;
     argsTextDelta: string;
+} | {
+    type: 'finish-metadata';
+    finishReason: LanguageModelV1FinishReason;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+} | {
+    type: 'error';
+    error: unknown;
 };
-type TextDeltaStreamPart = {
-    type: 'text-delta';
-    textDelta: string;
-};
-type LanguageModelStreamPart = TextDeltaStreamPart | ToolCallDeltaStreamPart | ToolCallStreamPart | ErrorStreamPart;
-
-declare class OpenAIChatLanguageModel<SETTINGS> implements LanguageModel {
-    readonly settings: SETTINGS;
-    readonly defaultObjectGenerationMode = "tool";
-    private readonly getClient;
-    private readonly mapSettings;
-    constructor(settings: SETTINGS, config: {
-        client: () => Promise<OpenAI>;
-        mapSettings: (settings: SETTINGS) => Record<string, unknown> & {
-            model: string;
-        };
-    });
-    private get basePrompt();
-    private getArgs;
-    doGenerate(options: Parameters<LanguageModel['doGenerate']>[0]): Promise<Awaited<ReturnType<LanguageModel['doGenerate']>>>;
-    doStream(options: Parameters<LanguageModel['doStream']>[0]): Promise<Awaited<ReturnType<LanguageModel['doStream']>>>;
-}
 
-type FireworksChatModelId = `accounts/${string}/models/${string}`;
-/**
- * @see https://readme.fireworks.ai/reference/createchatcompletion
- */
-interface FireworksChatSettings {
-    /**
-     * The ID of the model to use.
-     */
-    id: FireworksChatModelId;
+type OpenAIChatModelId = 'gpt-4' | 'gpt-4-0314' | 'gpt-4-0613' | 'gpt-4-turbo-preview' | 'gpt-4-1106-preview' | 'gpt-4-0125-preview' | 'gpt-4-vision-preview' | 'gpt-4-32k' | 'gpt-4-32k-0314' | 'gpt-4-32k-0613' | 'gpt-3.5-turbo' | 'gpt-3.5-turbo-0125' | 'gpt-3.5-turbo-1106' | 'gpt-3.5-turbo-0301' | 'gpt-3.5-turbo-0613' | 'gpt-3.5-turbo-16k' | 'gpt-3.5-turbo-16k-0613' | (string & {});
+interface OpenAIChatSettings {
     /**
-     * The size to which to truncate chat prompts. Earlier user/assistant messages will be
-     * evicted to fit the prompt into this length.
+     * Modify the likelihood of specified tokens appearing in the completion.
      *
-     * This should usually be set to a number << the max context size of the model, to allow
-     * enough remaining tokens for generating a response.
+     * Accepts a JSON object that maps tokens (specified by their token ID in
+     * the GPT tokenizer) to an associated bias value from -100 to 100. You
+     * can use this tokenizer tool to convert text to token IDs. Mathematically,
+     * the bias is added to the logits generated by the model prior to sampling.
+     * The exact effect will vary per model, but values between -1 and 1 should
+     * decrease or increase likelihood of selection; values like -100 or 100
+     * should result in a ban or exclusive selection of the relevant token.
      *
-     * If omitted, you may receive "prompt too long" errors in your responses as
-     * conversations grow. Note that even with this set, you may still receive "prompt too long"
-     * errors if individual messages are too long for the model context window.
-     */
-    promptTruncateLength?: number;
-    /**
-     * Top-k sampling is another sampling method where the k most probable next tokens are filtered
-     * and the probability mass is redistributed among only those k next tokens. The value of k
-     * controls the number of candidates for the next token at each step during text generation.
+     * As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
+     * token from being generated.
      */
-    topK?: number;
+    logitBias?: Record<number, number>;
     /**
-     * What to do if the token count of prompt plus max_tokens exceeds the model's context window.
-     *
-     * Passing truncate limits the max_tokens to at most context_window_length - prompt_length.
-     * This is the default.
-     *
-     * Passing error would trigger a request error.
-     *
-     * The default of 'truncate' is selected as it allows to ask for high max_tokens value while
-     * respecting the context window length without having to do client-side prompt tokenization.
-     *
-     * Note, that it differs from OpenAI's behavior that matches that of error.
+     * A unique identifier representing your end-user, which can help OpenAI to
+     * monitor and detect abuse. Learn more.
      */
-    contextLengthExceededBehavior?: 'truncate' | 'error';
+    user?: string;
 }
 
-declare function chat$3(settings: Omit<FireworksChatSettings, 'client'> & {
-    client?: OpenAI;
-    apiKey?: string;
-}): OpenAIChatLanguageModel<{
-    id: `accounts/${string}/models/${string}`;
-    promptTruncateLength?: number | undefined;
-    topK?: number | undefined;
-    contextLengthExceededBehavior?: "error" | "truncate" | undefined;
-}>;
-
-declare namespace fireworksFacade {
-  export {
-    chat$3 as chat,
-  };
+type OpenAIChatConfig = {
+    provider: string;
+    baseUrl: string;
+    headers: () => Record<string, string | undefined>;
+};
+declare class OpenAIChatLanguageModel implements LanguageModelV1 {
+    readonly specificationVersion = "v1";
+    readonly defaultObjectGenerationMode = "tool";
+    readonly modelId: OpenAIChatModelId;
+    readonly settings: OpenAIChatSettings;
+    private readonly config;
+    constructor(modelId: OpenAIChatModelId, settings: OpenAIChatSettings, config: OpenAIChatConfig);
+    get provider(): string;
+    private getArgs;
+    doGenerate(options: Parameters<LanguageModelV1['doGenerate']>[0]): Promise<Awaited<ReturnType<LanguageModelV1['doGenerate']>>>;
+    doStream(options: Parameters<LanguageModelV1['doStream']>[0]): Promise<Awaited<ReturnType<LanguageModelV1['doStream']>>>;
 }
 
-type MistralChatModelId = 'open-mistral-7b' | 'open-mixtral-8x7b' | 'mistral-small-latest' | 'mistral-medium-latest' | 'mistral-large-latest' | (string & {});
-interface MistralChatSettings {
+type OpenAICompletionModelId = 'gpt-3.5-turbo-instruct' | (string & {});
+interface OpenAICompletionSettings {
     /**
-     * The ID of the model to use.
+     * Echo back the prompt in addition to the completion
      */
-    id: MistralChatModelId;
+    echo?: boolean;
     /**
-     * Whether to inject a safety prompt before all conversations.
+     * Modify the likelihood of specified tokens appearing in the completion.
      *
-     * Default: false
-     */
-    safePrompt?: boolean;
-}
-
-declare class MistralChatLanguageModel implements LanguageModel {
-    readonly settings: MistralChatSettings;
-    readonly defaultObjectGenerationMode = "json";
-    private readonly getClient;
-    constructor(settings: MistralChatSettings, config: {
-        client: () => Promise<MistralClient>;
-    });
-    private get basePrompt();
-    private getArgs;
-    doGenerate(options: Parameters<LanguageModel['doGenerate']>[0]): Promise<Awaited<ReturnType<LanguageModel['doGenerate']>>>;
-    doStream(options: Parameters<LanguageModel['doStream']>[0]): Promise<Awaited<ReturnType<LanguageModel['doStream']>>>;
-}
-
-declare function chat$2(settings: Omit<MistralChatSettings, 'client'> & {
-    client?: MistralClient;
-    apiKey?: string;
-}): MistralChatLanguageModel;
-
-declare namespace mistralFacade {
-  export {
-    chat$2 as chat,
-  };
-}
-
-type OpenAIChatModelId = 'gpt-4' | 'gpt-4-0314' | 'gpt-4-0613' | 'gpt-4-turbo-preview' | 'gpt-4-1106-preview' | 'gpt-4-0125-preview' | 'gpt-4-vision-preview' | 'gpt-4-32k' | 'gpt-4-32k-0314' | 'gpt-4-32k-0613' | 'gpt-3.5-turbo' | 'gpt-3.5-turbo-0125' | 'gpt-3.5-turbo-1106' | 'gpt-3.5-turbo-0301' | 'gpt-3.5-turbo-0613' | 'gpt-3.5-turbo-16k' | 'gpt-3.5-turbo-16k-0613' | (string & {});
-interface OpenAIChatSettings {
-    /**
-     * The ID of the model to use.
+     * Accepts a JSON object that maps tokens (specified by their token ID in
+     * the GPT tokenizer) to an associated bias value from -100 to 100. You
+     * can use this tokenizer tool to convert text to token IDs. Mathematically,
+     * the bias is added to the logits generated by the model prior to sampling.
+     * The exact effect will vary per model, but values between -1 and 1 should
+     * decrease or increase likelihood of selection; values like -100 or 100
+     * should result in a ban or exclusive selection of the relevant token.
+     *
+     * As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
+     * token from being generated.
      */
-    id: OpenAIChatModelId;
     logitBias?: Record<number, number>;
-}
-
-declare function chat$1(settings: OpenAIChatSettings & {
-    client?: OpenAI;
-    apiKey?: string;
-}): OpenAIChatLanguageModel<OpenAIChatSettings>;
-
-declare namespace openaiFacade {
-  export {
-    chat$1 as chat,
-  };
-}
-
-type PerplexityChatModelId = 'sonar-small-chat' | 'sonar-small-online' | 'sonar-medium-chat' | 'sonar-medium-online' | 'mistral-7b-instruct' | 'mixtral-8x7b-instruct' | (string & {});
-/**
- * @see https://docs.perplexity.ai/reference/post_chat_completions
- */
-interface PerplexityChatSettings {
     /**
-     * The ID of the model to use.
+     * The suffix that comes after a completion of inserted text.
      */
-    id: PerplexityChatModelId;
+    suffix?: string;
     /**
-     * The number of tokens to keep for highest top-k filtering, specified as an
-     * integer between 0 and 2048 inclusive. If set to 0, top-k filtering is disabled.
-     * We recommend either altering top_k or top_p, but not both.
+     * A unique identifier representing your end-user, which can help OpenAI to
+     * monitor and detect abuse. Learn more.
      */
-    topK?: number;
+    user?: string;
 }
 
-declare function chat(settings: PerplexityChatSettings & {
-    client?: OpenAI;
-    apiKey?: string;
-}): OpenAIChatLanguageModel<{
-    id: PerplexityChatModelId;
-    topK?: number | undefined;
-}>;
+type OpenAICompletionConfig = {
+    provider: string;
+    baseUrl: string;
+    headers: () => Record<string, string | undefined>;
+};
+declare class OpenAICompletionLanguageModel implements LanguageModelV1 {
+    readonly specificationVersion = "v1";
+    readonly defaultObjectGenerationMode: undefined;
+    readonly modelId: OpenAICompletionModelId;
+    readonly settings: OpenAICompletionSettings;
+    private readonly config;
+    constructor(modelId: OpenAICompletionModelId, settings: OpenAICompletionSettings, config: OpenAICompletionConfig);
+    get provider(): string;
+    private getArgs;
+    doGenerate(options: Parameters<LanguageModelV1['doGenerate']>[0]): Promise<Awaited<ReturnType<LanguageModelV1['doGenerate']>>>;
+    doStream(options: Parameters<LanguageModelV1['doStream']>[0]): Promise<Awaited<ReturnType<LanguageModelV1['doStream']>>>;
+}
 
-declare const perplexityFacade_chat: typeof chat;
-declare namespace perplexityFacade {
-  export {
-    perplexityFacade_chat as chat,
-  };
+/**
+ * OpenAI provider.
+ */
+declare class OpenAI {
+    readonly baseUrl?: string;
+    readonly apiKey?: string;
+    readonly organization?: string;
+    constructor(options?: {
+        baseUrl?: string;
+        apiKey?: string;
+        organization?: string;
+    });
+    private get baseConfig();
+    chat(modelId: OpenAIChatModelId, settings?: OpenAIChatSettings): OpenAIChatLanguageModel;
+    completion(modelId: OpenAICompletionModelId, settings?: OpenAICompletionSettings): OpenAICompletionLanguageModel;
 }
+/**
+ * Default OpenAI provider instance.
+ */
+declare const openai: OpenAI;
 
-export { fireworksFacade as fireworks, mistralFacade as mistral, openaiFacade as openai, perplexityFacade as perplexity };
+export { OpenAI, openai };