ai 3.0.9 → 3.1.0-canary.0

package/provider/dist/index.d.ts

@@ -0,0 +1,387 @@
+import OpenAI from 'openai';
+import MistralClient from '@mistralai/mistralai';
+
+type LanguageModelV1CallSettings = {
+    /**
+     * Maximum number of tokens to generate.
+     */
+    maxTokens?: number;
+    /**
+     * Temperature setting. This is a number between 0 (almost no randomness) and
+     * 1 (very random).
+     *
+     * Different LLM providers have different temperature
+     * scales, so they'd need to map it (without mapping, the same temperature has
+     * different effects on different models). The provider can also chose to map
+     * this to topP, potentially even using a custom setting on their model.
+     *
+     * Note: This is an example of a setting that requires a clear specification of
+     * the semantics.
+     */
+    temperature?: number;
+    /**
+     * Nucleus sampling. This is a number between 0 and 1.
+     *
+     * E.g. 0.1 would mean that only tokens with the top 10% probability mass
+     * are considered.
+     *
+     * It is recommended to set either `temperature` or `topP`, but not both.
+     */
+    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.
+     */
+    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.
+     */
+    frequencyPenalty?: number;
+    /**
+     * The seed to use for random sampling. If set and supported by the model,
+     * calls will generate deterministic results.
+     */
+    seed?: number;
+};
+
+/**
+ * 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.
+ *
+ * Note: this is **not** the user-facing tool definition. The AI SDK methods will
+ * map the user-facing tool definitions to this format.
+ */
+type LanguageModelV1FunctionTool = {
+    /**
+     * The type of the tool. Only functions for now, but this gives us room to
+     * add more specific tool types in the future and use a discriminated union.
+     */
+    type: 'function';
+    /**
+     * The name of the tool. Unique within this model call.
+     */
+    name: string;
+    description?: string;
+    parameters: JsonSchema;
+};
+
+/**
+ * A prompt is a list of messages.
+ *
+ * Note: Not all models and prompt formats support multi-modal inputs and
+ * tool calls. The validation happens at runtime.
+ *
+ * Note: This is not a user-facing prompt. The AI SDK methods will map the
+ * user-facing prompt types such as chat or instruction prompts to this format.
+ */
+type LanguageModelV1Prompt = Array<LanguageModelV1Message>;
+type LanguageModelV1Message = {
+    role: 'system';
+    content: string;
+} | {
+    role: 'user';
+    content: Array<LanguageModelV1TextPart | LanguageModelV1ImagePart>;
+} | {
+    role: 'assistant';
+    content: Array<LanguageModelV1TextPart | LanguageModelV1ToolCallPart>;
+} | {
+    role: 'tool';
+    content: Array<LanguageModelV1ToolResultPart>;
+};
+interface LanguageModelV1TextPart {
+    type: 'text';
+    /**
+     * The text content.
+     */
+    text: string;
+}
+interface LanguageModelV1ImagePart {
+    type: 'image';
+    /**
+     * Image data as a Uint8Array.
+     */
+    image: Uint8Array;
+    /**
+     * Optional mime type of the image.
+     */
+    mimeType?: string;
+}
+interface LanguageModelV1ToolCallPart {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+}
+interface LanguageModelV1ToolResultPart {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+}
+
+type LanguageModelV1CallOptions = LanguageModelV1CallSettings & {
+    /**
+     * Whether the user provided the input as messages or as
+     * a prompt. This can help guide non-chat models in the
+     * expansion, bc different expansions can be needed for
+     * chat/non-chat use cases.
+     */
+    inputFormat: 'messages' | 'prompt';
+    /**
+     * The mode affects the behavior of the language model. It is required to
+     * support provider-independent streaming and generation of structured objects.
+     * The model can take this information and e.g. configure json mode, the correct
+     * low level grammar, etc. It can also be used to optimize the efficiency of the
+     * streaming, e.g. tool-delta stream parts are only needed in the
+     * object-tool mode.
+     */
+    mode: {
+        type: 'regular';
+        tools?: Array<LanguageModelV1FunctionTool>;
+    } | {
+        type: 'object-json';
+    } | {
+        type: 'object-grammar';
+        schema: JsonSchema;
+    } | {
+        type: 'object-tool';
+        tool: LanguageModelV1FunctionTool;
+    };
+    /**
+     * A language mode prompt is a standardized prompt type.
+     *
+     * Note: This is **not** the user-facing prompt. The AI SDK methods will map the
+     * user-facing prompt types such as chat or instruction prompts to this format.
+     * That approach allows us to evolve the user  facing prompts without breaking
+     * the language model interface.
+     */
+    prompt: LanguageModelV1Prompt;
+};
+
+interface LanguageModel {
+    /**
+     * 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
+     * model. `undefined` can be returned if object generation is not supported.
+     *
+     * This is needed to generate the best objects possible w/o requiring the
+     * user to explicitly specify the object generation mode.
+     */
+    readonly defaultObjectGenerationMode: 'json' | 'tool' | 'grammar' | undefined;
+    doGenerate(options: LanguageModelV1CallOptions): PromiseLike<{
+        text?: string;
+        toolCalls?: Array<LanguageModelToolCall>;
+        warnings: LanguageModelV1CallWarning[];
+    }>;
+    doStream(options: LanguageModelV1CallOptions): PromiseLike<{
+        stream: ReadableStream<LanguageModelStreamPart>;
+        warnings: LanguageModelV1CallWarning[];
+    }>;
+}
+type ErrorStreamPart = {
+    type: 'error';
+    error: unknown;
+};
+type LanguageModelToolCall = {
+    toolCallId: string;
+    toolName: string;
+    args: string;
+};
+type ToolCallStreamPart = {
+    type: 'tool-call';
+} & LanguageModelToolCall;
+type ToolCallDeltaStreamPart = {
+    type: 'tool-call-delta';
+    toolCallId: string;
+    toolName: string;
+    argsTextDelta: string;
+};
+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;
+    /**
+     * The size to which to truncate chat prompts. Earlier user/assistant messages will be
+     * evicted to fit the prompt into this length.
+     *
+     * This should usually be set to a number << the max context size of the model, to allow
+     * enough remaining tokens for generating a response.
+     *
+     * 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.
+     */
+    topK?: 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.
+     */
+    contextLengthExceededBehavior?: 'truncate' | 'error';
+}
+
+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 MistralChatModelId = 'open-mistral-7b' | 'open-mixtral-8x7b' | 'mistral-small-latest' | 'mistral-medium-latest' | 'mistral-large-latest' | (string & {});
+interface MistralChatSettings {
+    /**
+     * The ID of the model to use.
+     */
+    id: MistralChatModelId;
+    /**
+     * Whether to inject a safety prompt before all conversations.
+     *
+     * 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.
+     */
+    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.
+     */
+    id: PerplexityChatModelId;
+    /**
+     * 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.
+     */
+    topK?: number;
+}
+
+declare function chat(settings: PerplexityChatSettings & {
+    client?: OpenAI;
+    apiKey?: string;
+}): OpenAIChatLanguageModel<{
+    id: PerplexityChatModelId;
+    topK?: number | undefined;
+}>;
+
+declare const perplexityFacade_chat: typeof chat;
+declare namespace perplexityFacade {
+  export {
+    perplexityFacade_chat as chat,
+  };
+}
+
+export { fireworksFacade as fireworks, mistralFacade as mistral, openaiFacade as openai, perplexityFacade as perplexity };