cactus-ai-sdk-provider/dist/index.d.cts

Cactus provider for Vercel AI SDK - enables on-device LLM inference in React Native

import { LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2Content, LanguageModelV2FinishReason, LanguageModelV2Usage, LanguageModelV2CallWarning, LanguageModelV2ResponseMetadata, SharedV2Headers, LanguageModelV2StreamPart, ProviderV2 } from '@ai-sdk/provider';
export { LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2FinishReason, LanguageModelV2Message, LanguageModelV2Prompt, LanguageModelV2Usage } from '@ai-sdk/provider';

interface ModelEntry {
    url: string;
    localPath: string;
    status: 'pending' | 'ready' | 'error';
}
interface DownloadOptions {
    onProgress?: (progress: number) => void;
}
declare class ModelManager {
    private rnfs;
    private cache;
    constructor();
    /**
     * Check if RNFS is available for model management features
     */
    get isRNFSAvailable(): boolean;
    /**
     * Get the local file path for a model URL
     * @throws Error if RNFS is not available
     */
    getModelPath(urlOrPath: string): string;
    /**
     * Download a model from a URL
     * @throws Error if RNFS is not available
     */
    downloadModel(url: string, options?: DownloadOptions): Promise<string>;
    /**
     * Check if a model is downloaded
     */
    isDownloaded(urlOrPath: string): Promise<boolean>;
    /**
     * Delete a downloaded model
     */
    deleteModel(urlOrPath: string): Promise<void>;
    /**
     * List all downloaded models
     */
    listModels(): Promise<ModelEntry[]>;
    /**
     * Get storage info for all models
     */
    getStorageInfo(): Promise<{
        totalSize: number;
        modelCount: number;
    }>;
}

declare enum ModelStatus {
    IDLE = 0,
    DOWNLOADING = 1,
    INITIALIZING = 2,
    READY = 3,
    ERROR = 4
}
interface CactusChatLanguageModelConfig {
    provider: string;
    generateId?: () => string;
}
declare class CactusChatLanguageModel implements LanguageModelV2 {
    private readonly settings;
    private readonly config;
    readonly specificationVersion = "v2";
    readonly provider: string;
    readonly modelId: string;
    readonly modelUrl: string;
    private lm;
    private status;
    private lastError;
    private modelManager;
    constructor(modelUrlOrPath: string, settings: CactusChatSettings, config: CactusChatLanguageModelConfig);
    getStatus(): ModelStatus;
    getLastError(): Error | null;
    /**
     * List all downloaded models
     */
    listDownloadedModels(): Promise<ModelEntry[]>;
    /**
     * Get storage info for all downloaded models
     */
    getStorageInfo(): Promise<{
        totalSize: number;
        modelCount: number;
    }>;
    /**
     * Download the model if it's a URL
     */
    downloadModel(options?: DownloadOptions): Promise<string>;
    /**
     * Delete the downloaded model
     */
    deleteModel(): Promise<void>;
    initialize(): Promise<void>;
    private assertIsReady;
    private convertToCactusMessages;
    private getCactusParams;
    get supportedUrls(): Record<string, RegExp[]>;
    doGenerate(options: LanguageModelV2CallOptions): Promise<{
        content: Array<LanguageModelV2Content>;
        finishReason: LanguageModelV2FinishReason;
        usage: LanguageModelV2Usage;
        warnings: Array<LanguageModelV2CallWarning>;
        request?: {
            body?: unknown;
        };
        response?: LanguageModelV2ResponseMetadata & {
            headers?: SharedV2Headers;
            body?: unknown;
        };
    }>;
    doStream(options: LanguageModelV2CallOptions): Promise<{
        stream: ReadableStream<LanguageModelV2StreamPart>;
        warnings: Array<LanguageModelV2CallWarning>;
        request?: {
            body?: unknown;
        };
        response?: {
            headers?: SharedV2Headers;
        };
    }>;
}

interface CactusChatSettings {
}
interface CactusProvider extends ProviderV2 {
    (modelUrl: string, settings?: CactusChatSettings): CactusChatLanguageModel;
    languageModel(modelUrl: string, settings?: CactusChatSettings): CactusChatLanguageModel;
}
interface CactusProviderSettings {
    model?: any;
    generateId?: () => string;
}
declare function createCactus(options?: CactusProviderSettings): CactusProvider;
declare const cactus: CactusProvider;

export { CactusChatLanguageModel, type CactusChatLanguageModelConfig, type CactusChatSettings, type CactusProvider, type CactusProviderSettings, type DownloadOptions, type ModelEntry, ModelManager, ModelStatus, cactus, createCactus };