erosolar-cli 1.7.55 → 1.7.57

package/dist/bin/providers/anthropicProvider.js

@@ -1,329 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import { APIError, RateLimitError } from '@anthropic-ai/sdk/error.js';
-const DEFAULT_RATE_LIMIT_RETRIES = 4;
-const DEFAULT_RATE_LIMIT_INITIAL_DELAY_MS = 1500;
-const MIN_RATE_LIMIT_DELAY_MS = 750;
-const MAX_RATE_LIMIT_DELAY_MS = 40000;
-export class AnthropicMessagesProvider {
-    constructor(options) {
-        this.id = 'anthropic';
-        this.client = new Anthropic({ apiKey: options.apiKey });
-        this.model = options.model;
-        this.maxTokens = options.maxTokens ?? 2048;
-        this.temperature = options.temperature ?? 0;
-        this.rateLimitMaxRetries = Math.max(0, options.rateLimitMaxRetries ?? DEFAULT_RATE_LIMIT_RETRIES);
-        this.rateLimitInitialDelayMs = Math.max(MIN_RATE_LIMIT_DELAY_MS, options.rateLimitInitialDelayMs ?? DEFAULT_RATE_LIMIT_INITIAL_DELAY_MS);
-        this.enablePromptCaching = options.enablePromptCaching ?? true;
-    }
-    async generate(messages, tools) {
-        const { system, chat } = convertConversation(messages, this.enablePromptCaching);
-        const response = await this.executeWithRateLimitRetries(() => this.client.messages.create({
-            model: this.model,
-            max_tokens: this.maxTokens,
-            temperature: this.temperature,
-            messages: chat,
-            ...(system ? { system } : {}),
-            ...(tools.length ? { tools: tools.map(mapTool) } : {}),
-        }));
-        const usage = mapUsage(response.usage);
-        const toolCalls = response.content
-            .filter((block) => block.type === 'tool_use')
-            .map((block) => ({
-            id: block.id,
-            name: block.name,
-            arguments: toRecord(block.input),
-        }));
-        const textContent = response.content
-            .filter((block) => block.type === 'text')
-            .map((block) => ('text' in block ? block.text : ''))
-            .join('\n')
-            .trim();
-        if (toolCalls.length > 0) {
-            return {
-                type: 'tool_calls',
-                toolCalls,
-                content: textContent,
-                usage,
-            };
-        }
-        return {
-            type: 'message',
-            content: textContent,
-            usage,
-        };
-    }
-    async *generateStream(messages, tools) {
-        const { system, chat } = convertConversation(messages, this.enablePromptCaching);
-        const stream = this.client.messages.stream({
-            model: this.model,
-            max_tokens: this.maxTokens,
-            temperature: this.temperature,
-            messages: chat,
-            ...(system ? { system } : {}),
-            ...(tools.length ? { tools: tools.map(mapTool) } : {}),
-        });
-        let currentToolCall = null;
-        let currentToolCallInput = '';
-        let toolCallId = '';
-        for await (const event of stream) {
-            // Handle different event types
-            if (event.type === 'content_block_start') {
-                const block = event.content_block;
-                if (block.type === 'tool_use') {
-                    toolCallId = block.id;
-                    currentToolCall = {
-                        id: block.id,
-                        name: block.name,
-                        arguments: {},
-                    };
-                    currentToolCallInput = '';
-                }
-            }
-            else if (event.type === 'content_block_delta') {
-                const delta = event.delta;
-                if (delta.type === 'text_delta') {
-                    yield {
-                        type: 'content',
-                        content: delta.text,
-                    };
-                }
-                else if (delta.type === 'input_json_delta' && currentToolCall) {
-                    // accumulate tool input JSON fragments
-                    if (typeof delta.partial_json === 'string' && delta.partial_json) {
-                        currentToolCallInput += delta.partial_json;
-                    }
-                }
-            }
-            else if (event.type === 'content_block_stop') {
-                if (currentToolCall && toolCallId) {
-                    if (currentToolCallInput.trim()) {
-                        try {
-                            currentToolCall.arguments = toRecord(JSON.parse(currentToolCallInput));
-                        }
-                        catch {
-                            currentToolCall.arguments = {};
-                        }
-                    }
-                    yield {
-                        type: 'tool_call',
-                        toolCall: currentToolCall,
-                    };
-                    currentToolCall = null;
-                    currentToolCallInput = '';
-                    toolCallId = '';
-                }
-            }
-            else if (event.type === 'message_stop') {
-                const finalMessage = await stream.finalMessage();
-                const usage = mapUsage(finalMessage.usage);
-                if (usage) {
-                    yield {
-                        type: 'usage',
-                        usage,
-                    };
-                }
-                yield {
-                    type: 'done',
-                };
-            }
-        }
-    }
-    getCapabilities() {
-        return {
-            streaming: true,
-            toolCalling: true,
-            vision: this.model.includes('sonnet') || this.model.includes('opus'),
-            functionCalling: true,
-            maxTokens: this.maxTokens,
-            supportedModalities: ['text', 'image'],
-        };
-    }
-    async executeWithRateLimitRetries(operation) {
-        let retries = 0;
-        let delayMs = this.rateLimitInitialDelayMs;
-        while (true) {
-            try {
-                return await operation();
-            }
-            catch (error) {
-                if (!isRateLimitError(error)) {
-                    throw error;
-                }
-                if (retries >= this.rateLimitMaxRetries) {
-                    throw buildRateLimitFailureError(error, retries);
-                }
-                const waitMs = determineRetryDelay(error.headers, delayMs);
-                await sleep(waitMs);
-                retries += 1;
-                delayMs = Math.min(delayMs * 2, MAX_RATE_LIMIT_DELAY_MS);
-            }
-        }
-    }
-}
-function convertConversation(messages, enablePromptCaching = false) {
-    const systemPrompts = [];
-    const chat = [];
-    for (const message of messages) {
-        switch (message.role) {
-            case 'system': {
-                systemPrompts.push(message.content);
-                break;
-            }
-            case 'user': {
-                chat.push({
-                    role: 'user',
-                    content: [{ type: 'text', text: message.content }],
-                });
-                break;
-            }
-            case 'assistant': {
-                const contentBlocks = [];
-                if (message.content.trim().length > 0) {
-                    contentBlocks.push({ type: 'text', text: message.content });
-                }
-                for (const call of message.toolCalls ?? []) {
-                    contentBlocks.push({
-                        type: 'tool_use',
-                        id: call.id,
-                        name: call.name,
-                        input: call.arguments,
-                    });
-                }
-                chat.push({
-                    role: 'assistant',
-                    content: contentBlocks.length ? contentBlocks : [{ type: 'text', text: '' }],
-                });
-                break;
-            }
-            case 'tool': {
-                const block = {
-                    type: 'tool_result',
-                    tool_use_id: message.toolCallId,
-                    content: [{ type: 'text', text: message.content }],
-                };
-                chat.push({
-                    role: 'user',
-                    content: [block],
-                });
-                break;
-            }
-            default:
-                break;
-        }
-    }
-    // Add cache control breakpoints to optimize costs
-    // Cache the first few user messages (usually contain system context)
-    if (enablePromptCaching && chat.length > 2) {
-        const cacheBreakpoint = Math.min(2, chat.length - 1);
-        for (let i = 0; i < cacheBreakpoint; i++) {
-            const message = chat[i];
-            if (message && message.role === 'user' && Array.isArray(message.content)) {
-                const lastContent = message.content[message.content.length - 1];
-                if (lastContent && 'text' in lastContent) {
-                    lastContent['cache_control'] = { type: 'ephemeral' };
-                }
-            }
-        }
-    }
-    return {
-        system: systemPrompts.length ? systemPrompts.join('\n\n') : null,
-        chat,
-    };
-}
-function mapTool(definition) {
-    return {
-        name: definition.name,
-        description: definition.description,
-        input_schema: definition.parameters ?? {
-            type: 'object',
-            properties: {},
-        },
-    };
-}
-function toRecord(value) {
-    if (isPlainRecord(value)) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (!trimmed) {
-            return {};
-        }
-        try {
-            const parsed = JSON.parse(trimmed);
-            return isPlainRecord(parsed) ? parsed : {};
-        }
-        catch {
-            return {};
-        }
-    }
-    return {};
-}
-function isPlainRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function mapUsage(usage) {
-    if (!usage) {
-        return null;
-    }
-    const total = typeof usage.input_tokens === 'number' && typeof usage.output_tokens === 'number'
-        ? usage.input_tokens + usage.output_tokens
-        : undefined;
-    return {
-        inputTokens: usage.input_tokens,
-        outputTokens: usage.output_tokens,
-        totalTokens: total,
-    };
-}
-function isRateLimitError(error) {
-    if (error instanceof RateLimitError) {
-        return true;
-    }
-    if (error instanceof APIError && error.status === 429) {
-        return true;
-    }
-    return typeof error === 'object' && error !== null && 'status' in error && error.status === 429;
-}
-function determineRetryDelay(headers, fallbackMs) {
-    const retryAfter = parseRetryAfterHeader(headers);
-    if (retryAfter !== null) {
-        return clamp(retryAfter, MIN_RATE_LIMIT_DELAY_MS, MAX_RATE_LIMIT_DELAY_MS);
-    }
-    const jitter = fallbackMs * 0.25;
-    const randomized = fallbackMs + (Math.random() * (2 * jitter) - jitter);
-    return clamp(Math.round(randomized), MIN_RATE_LIMIT_DELAY_MS, MAX_RATE_LIMIT_DELAY_MS);
-}
-function parseRetryAfterHeader(headers) {
-    if (!headers || typeof headers.get !== 'function') {
-        return null;
-    }
-    const retryAfter = headers.get('retry-after');
-    if (!retryAfter) {
-        return null;
-    }
-    const numeric = Number(retryAfter);
-    if (Number.isFinite(numeric) && numeric >= 0) {
-        return numeric * 1000;
-    }
-    const parsedDate = Date.parse(retryAfter);
-    if (Number.isFinite(parsedDate)) {
-        return Math.max(0, parsedDate - Date.now());
-    }
-    return null;
-}
-function clamp(value, min, max) {
-    return Math.max(min, Math.min(max, value));
-}
-async function sleep(durationMs) {
-    await new Promise((resolve) => setTimeout(resolve, durationMs));
-}
-function buildRateLimitFailureError(error, retries) {
-    const baseMessage = 'Anthropic rejected the request because the per-minute token rate limit was exceeded.';
-    const retryDetails = retries > 0 ? ` Waited and retried ${retries} time${retries === 1 ? '' : 's'} without success.` : '';
-    const advisory = ' Reduce the prompt size or wait for usage to reset before trying again. ' +
-        'See https://docs.claude.com/en/api/rate-limits for quota guidance.';
-    const original = error.message ? `\nOriginal message: ${error.message}` : '';
-    return new Error(`${baseMessage}${retryDetails}${advisory}${original}`, {
-        cause: error,
-    });
-}

package/dist/bin/providers/googleProvider.js

@@ -1,203 +0,0 @@
-import { GoogleGenAI, } from '@google/genai';
-export class GoogleGenAIProvider {
-    constructor(options) {
-        this.client = new GoogleGenAI({
-            apiKey: options.apiKey,
-        });
-        this.id = options.providerId ?? 'google';
-        this.model = options.model;
-        this.temperature = options.temperature;
-        this.maxOutputTokens = options.maxOutputTokens;
-    }
-    async generate(messages, tools) {
-        const { contents, systemInstruction } = mapConversation(messages);
-        const config = {};
-        if (systemInstruction) {
-            config.systemInstruction = systemInstruction;
-        }
-        if (typeof this.temperature === 'number') {
-            config.temperature = this.temperature;
-        }
-        if (typeof this.maxOutputTokens === 'number') {
-            config.maxOutputTokens = this.maxOutputTokens;
-        }
-        const mappedTools = mapTools(tools);
-        if (mappedTools.length > 0) {
-            config.tools = mappedTools;
-        }
-        const response = await this.client.models.generateContent({
-            model: this.model,
-            contents: contents.length ? contents : createEmptyUserContent(),
-            config: Object.keys(config).length ? config : undefined,
-        });
-        const usage = mapUsage(response.usageMetadata);
-        const toolCalls = mapFunctionCalls(response.functionCalls ?? []);
-        const content = response.text?.trim() ?? '';
-        if (toolCalls.length > 0) {
-            return {
-                type: 'tool_calls',
-                toolCalls,
-                content,
-                usage,
-            };
-        }
-        return {
-            type: 'message',
-            content,
-            usage,
-        };
-    }
-}
-function mapConversation(messages) {
-    const contents = [];
-    const systemPrompts = [];
-    for (const message of messages) {
-        switch (message.role) {
-            case 'system': {
-                if (message.content.trim()) {
-                    systemPrompts.push(message.content.trim());
-                }
-                break;
-            }
-            case 'user': {
-                contents.push({
-                    role: 'user',
-                    parts: [{ text: message.content }],
-                });
-                break;
-            }
-            case 'assistant': {
-                contents.push(mapAssistantMessage(message));
-                break;
-            }
-            case 'tool': {
-                const content = mapToolMessage(message);
-                if (content) {
-                    contents.push(content);
-                }
-                break;
-            }
-            default:
-                break;
-        }
-    }
-    return {
-        contents,
-        systemInstruction: systemPrompts.length ? systemPrompts.join('\n\n') : undefined,
-    };
-}
-function mapAssistantMessage(message) {
-    const parts = [];
-    const text = message.content.trim();
-    if (text) {
-        parts.push({ text });
-    }
-    for (const call of message.toolCalls ?? []) {
-        parts.push({
-            functionCall: {
-                id: call.id || undefined,
-                name: call.name,
-                args: toRecord(call.arguments),
-            },
-        });
-    }
-    return {
-        role: 'model',
-        parts: parts.length ? parts : [{ text: '' }],
-    };
-}
-function mapToolMessage(message) {
-    if (!message.toolCallId) {
-        return null;
-    }
-    return {
-        role: 'user',
-        parts: [
-            {
-                functionResponse: {
-                    id: message.toolCallId,
-                    name: message.name,
-                    response: parseToolResponse(message.content),
-                },
-            },
-        ],
-    };
-}
-function parseToolResponse(content) {
-    const trimmed = content.trim();
-    if (!trimmed) {
-        return { output: '' };
-    }
-    try {
-        const parsed = JSON.parse(trimmed);
-        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-            return parsed;
-        }
-    }
-    catch {
-    }
-    return { output: content };
-}
-function mapFunctionCalls(calls) {
-    return calls
-        .filter((call) => Boolean(call.name))
-        .map((call) => ({
-        id: call.id || call.name || 'function_call',
-        name: call.name ?? 'function_call',
-        arguments: toRecord(call.args),
-    }));
-}
-function createEmptyUserContent() {
-    return [
-        {
-            role: 'user',
-            parts: [{ text: '' }],
-        },
-    ];
-}
-function mapTools(tools) {
-    if (!tools.length) {
-        return [];
-    }
-    return [
-        {
-            functionDeclarations: tools.map((tool) => ({
-                name: tool.name,
-                description: tool.description,
-                parametersJsonSchema: tool.parameters ?? { type: 'object', properties: {} },
-            })),
-        },
-    ];
-}
-function mapUsage(metadata) {
-    if (!metadata) {
-        return null;
-    }
-    return {
-        inputTokens: metadata.promptTokenCount ?? undefined,
-        outputTokens: metadata.candidatesTokenCount ?? undefined,
-        totalTokens: metadata.totalTokenCount ?? undefined,
-    };
-}
-function toRecord(value) {
-    if (isPlainRecord(value)) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (!trimmed) {
-            return {};
-        }
-        try {
-            const parsed = JSON.parse(trimmed);
-            return isPlainRecord(parsed) ? parsed : {};
-        }
-        catch {
-            return {};
-        }
-    }
-    return {};
-}
-function isPlainRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}