capsule-ai-cli/dist/providers/base.js

The AI Model Orchestrator - Intelligent multi-model workflows with device-locked licensing

export class BaseProvider {
    apiKey;
    baseUrl;
    constructor(apiKey, baseUrl) {
        this.apiKey = apiKey;
        this.baseUrl = baseUrl;
    }
    async *stream(_messages, _options) {
        yield* [];
        throw new Error(`Streaming not supported by ${this.name}`);
    }
    countTokens(text) {
        return Math.ceil(text.length / 4);
    }
    validateMessages(messages) {
        if (!messages || messages.length === 0) {
            throw new Error('Messages array cannot be empty');
        }
        const validRoles = ['system', 'user', 'assistant', 'tool', 'tool_result'];
        for (const msg of messages) {
            if (!validRoles.includes(msg.role)) {
                throw new Error(`Invalid message role: ${msg.role}`);
            }
        }
    }
    getTextContent(message) {
        if (typeof message.content === 'string') {
            return message.content;
        }
        return message.content
            .filter(c => c.type === 'text')
            .map(c => c.text)
            .join(' ');
    }
    hasMultimodalContent(message) {
        return Array.isArray(message.content) &&
            message.content.some(c => c.type === 'image' || c.type === 'file');
    }
    supportsVision(_model) {
        return false;
    }
    formatTools(tools) {
        return tools;
    }
    parseToolCalls(_response) {
        return undefined;
    }
    async handleRateLimit(retryAfter) {
        console.log(`Rate limited. Waiting ${retryAfter}s...`);
        await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
    }
}
export class ProviderRegistry {
    providers = new Map();
    register(provider) {
        this.providers.set(provider.name, provider);
    }
    get(name) {
        return this.providers.get(name);
    }
    list() {
        return Array.from(this.providers.keys());
    }
    getModels() {
        const models = {};
        for (const [name, provider] of this.providers) {
            models[name] = provider.models;
        }
        return models;
    }
    clear(name) {
        this.providers.delete(name);
    }
    clearAll() {
        this.providers.clear();
    }
}
export const providerRegistry = new ProviderRegistry();
//# sourceMappingURL=base.js.map