@llmbridge/core/dist/types.d.ts

Core package for unified LLM interface

export type ResponseFormat = {
    type: "json_object";
} | {
    type: "json_schema";
    json_schema: any;
};
export type Model = `${string}/${string}`;
export interface Provider {
    run(providerName: string, model: string, systemPrompt: string | null, messages: Message[], checkAbort: () => void, plugins: Plugins, options: Options): Promise<Response>;
    getEmbeddings(model: string, plugins: Plugins, text: string): Promise<number[]>;
}
export interface Options {
    maxTokens: number;
    temperature: number;
    tools?: Tools;
    /**
     * The effort of the reasoning process. OpenAI uses enum values, Anthropic uses a budget of tokens.
     * Estimates for conversion:
     * - Numbers to OpenAI: < 1000 -> 'low', 1000-2500 -> 'medium', 2500+ -> 'high'
     * - Anthropic: 'low' -> 500, 'medium' -> 1500, 'high' -> 5000
     */
    reasoningEffort?: 'low' | 'medium' | 'high' | number;
    responseFormat?: ResponseFormat;
}
export interface MessageGeneric {
    model?: string;
    timestamp?: number;
}
export interface TextMessage extends MessageGeneric {
    role: 'user' | 'assistant' | 'model' | 'function' | 'system';
    content: string;
}
export interface ImageContent {
    type: 'image';
    media_type: 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp';
    data: string;
}
export interface TextContent {
    type: 'text';
    text: string;
}
export type MediaMessageContent = ImageContent | TextContent;
export interface MediaMessage extends MessageGeneric {
    role: 'user' | 'assistant';
    content: MediaMessageContent[];
}
export interface ToolRequest extends MessageGeneric {
    id: string;
    name: string;
    comment?: string;
    input: any;
}
export interface ToolResponse extends MessageGeneric {
    id: string;
    name?: string;
    output: any;
}
export type Message = TextMessage | MediaMessage | ToolRequest | ToolResponse;
export declare function isToolRequest(message: Message): message is ToolRequest;
export declare function isToolResponse(message: Message): message is ToolResponse;
export declare function isTextMessage(message: Message): message is TextMessage;
export declare function isMediaMessage(message: Message): message is MediaMessage;
export interface ToolImageTextResult {
    type: 'text';
    text: string;
}
export interface ToolImageContentResult {
    type: 'image';
    source: {
        "type": "base64";
        "media_type": string;
        "data": string;
    };
}
export type ToolImageResult = [ToolImageTextResult, ToolImageContentResult];
export type ToolTextResult = string;
export interface Tools {
    tool_choice: {
        type: 'auto';
    } | {
        type: 'any';
    } | {
        type: 'tool';
        name: string;
    };
    tools: Array<Tool>;
    usesLimit: number;
}
export interface Tool {
    name: string;
    description: string;
    input_schema: any;
    callback(input: any, context: Message[]): Promise<void | ToolTextResult | ToolImageResult>;
    instructions: string;
}
export interface Response {
    messages: Message[];
    tokenUsage: TokenUsage;
}
export interface TokenUsage {
    inputTokens: number;
    outputTokens: number;
    totalTokens: number;
    cachedTokens: number;
}
export type TokenUsageRecord = Partial<Record<Model, TokenUsage>>;
export interface PluginCompletionContext {
    model: string;
    systemPrompt: string | null;
    messages: Message[];
    options: Options;
    provider: Provider;
    providerName: string;
    tokenUsage?: TokenUsage;
}
export interface PluginEmbeddingsContext {
    model: string;
    provider: Provider;
}
export interface AfterRunParams<T> {
    response: Response;
    beforeResponse: T;
    context: PluginCompletionContext;
}
export interface AfterExecParams<T> {
    response: any;
    beforeResponse: T;
    context: PluginCompletionContext;
}
export interface AfterToolExecParams<T> {
    response: any;
    tool: Tool;
    counter: number;
    beforeResponse: T;
    context: PluginCompletionContext;
}
export interface AfterGetEmbeddingsParams<T> {
    response: any;
    beforeResponse: T;
    context: PluginEmbeddingsContext;
}
export interface Plugin<T1, T2, T3, T4> {
    beforeRun?: (context: PluginCompletionContext) => Promise<T1>;
    afterRun?: (params: AfterRunParams<T1>) => Promise<void>;
    beforeExec?: (params: any, context: PluginCompletionContext) => Promise<T2>;
    afterExec?: (params: AfterExecParams<T2>) => Promise<void>;
    beforeToolExec?: (tool: Tool, counter: number, input: any, context: PluginCompletionContext) => Promise<T3>;
    afterToolExec?: (params: AfterToolExecParams<T3>) => Promise<void>;
    beforeGetEmbeddings?: (params: any, context: PluginEmbeddingsContext) => Promise<T4>;
    afterGetEmbeddings?: (params: AfterGetEmbeddingsParams<T4>) => Promise<void>;
}
export interface Plugins {
    beforeRun(context: PluginCompletionContext): Promise<any[]>;
    afterRun(response: Response, beforeResponses: any[], context: PluginCompletionContext): Promise<void>;
    beforeExec(params: any, context: PluginCompletionContext): Promise<any[]>;
    afterExec(response: any, beforeResponses: any[], context: PluginCompletionContext): Promise<void>;
    beforeToolExec(tool: Tool, counter: number, input: any, context: PluginCompletionContext): Promise<any[]>;
    afterToolExec(response: any, tool: Tool, counter: number, beforeResponses: any[], context: PluginCompletionContext): Promise<void>;
    beforeGetEmbeddings(params: any, context: PluginEmbeddingsContext): Promise<any[]>;
    afterGetEmbeddings(response: any, beforeResponses: any[], context: PluginEmbeddingsContext): Promise<void>;
}
//# sourceMappingURL=types.d.ts.map