erosolar-cli 1.0.1

package/dist/providers/anthropicProvider.js

@@ -0,0 +1,218 @@
+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 = 40_000;
+export class AnthropicMessagesProvider {
+    id = 'anthropic';
+    model;
+    client;
+    maxTokens;
+    temperature;
+    rateLimitMaxRetries;
+    rateLimitInitialDelayMs;
+    constructor(options) {
+        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);
+    }
+    async generate(messages, tools) {
+        const { system, chat } = convertConversation(messages);
+        const response = await this.executeWithRateLimitRetries(() => this.client.messages.create({
+            model: this.model,
+            max_tokens: this.maxTokens,
+            temperature: this.temperature,
+            system: system ?? undefined,
+            messages: chat,
+            tools: tools.length ? tools.map(mapTool) : undefined,
+        }));
+        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 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) {
+    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;
+        }
+    }
+    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 (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+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/providers/googleProvider.js

@@ -0,0 +1,193 @@
+import { GoogleGenAI, } from '@google/genai';
+export class GoogleGenAIProvider {
+    id;
+    model;
+    client;
+    temperature;
+    maxOutputTokens;
+    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 {
+        // Fallback to wrapping raw tool text below.
+    }
+    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 (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}

package/dist/providers/openaiChatCompletionsProvider.js

@@ -0,0 +1,148 @@
+import OpenAI from 'openai';
+export class OpenAIChatCompletionsProvider {
+    id;
+    model;
+    client;
+    constructor(options) {
+        const clientConfig = {
+            apiKey: options.apiKey,
+        };
+        if (options.baseURL) {
+            clientConfig.baseURL = options.baseURL;
+        }
+        this.client = new OpenAI(clientConfig);
+        this.id = options.providerId ?? 'openai';
+        this.model = options.model;
+    }
+    async generate(messages, tools) {
+        const request = {
+            model: this.model,
+            messages: mapMessages(messages),
+            tools: tools.length ? tools.map(mapTool) : undefined,
+            stream: false,
+        };
+        const completion = await this.client.chat.completions.create(request);
+        assertHasChoices(completion);
+        const choice = completion.choices[0];
+        const usage = mapUsage(completion.usage);
+        if (!choice) {
+            return {
+                type: 'message',
+                content: '',
+                usage,
+            };
+        }
+        const toolCalls = (choice.message.tool_calls ?? []).map(mapToolCall);
+        const content = extractMessageContent(choice);
+        if (toolCalls.length > 0) {
+            return {
+                type: 'tool_calls',
+                toolCalls,
+                content,
+                usage,
+            };
+        }
+        return {
+            type: 'message',
+            content,
+            usage,
+        };
+    }
+}
+function mapMessages(messages) {
+    const params = [];
+    for (const message of messages) {
+        switch (message.role) {
+            case 'system':
+            case 'user': {
+                params.push({
+                    role: message.role,
+                    content: message.content,
+                });
+                break;
+            }
+            case 'assistant': {
+                params.push({
+                    role: 'assistant',
+                    content: message.content,
+                    tool_calls: message.toolCalls?.map((call, index) => ({
+                        id: call.id || `call_${index}`,
+                        type: 'function',
+                        function: {
+                            name: call.name,
+                            arguments: JSON.stringify(call.arguments ?? {}),
+                        },
+                    })),
+                });
+                break;
+            }
+            case 'tool': {
+                params.push({
+                    role: 'tool',
+                    content: message.content,
+                    tool_call_id: message.toolCallId,
+                });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return params;
+}
+function mapTool(definition) {
+    const parameters = definition.parameters ??
+        {
+            type: 'object',
+            properties: {},
+        };
+    return {
+        type: 'function',
+        function: {
+            name: definition.name,
+            description: definition.description,
+            parameters,
+        },
+    };
+}
+function extractMessageContent(choice) {
+    const message = choice.message;
+    const content = message?.content;
+    if (typeof content === 'string' && content.trim()) {
+        return content.trim();
+    }
+    const refusal = message?.refusal;
+    if (typeof refusal === 'string' && refusal.trim()) {
+        return refusal.trim();
+    }
+    return '';
+}
+function mapToolCall(call) {
+    let parsed = {};
+    try {
+        parsed = JSON.parse(call.function.arguments ?? '{}');
+    }
+    catch {
+        parsed = {};
+    }
+    return {
+        id: call.id ?? call.function.name,
+        name: call.function.name,
+        arguments: parsed,
+    };
+}
+function mapUsage(usage) {
+    if (!usage) {
+        return null;
+    }
+    return {
+        inputTokens: usage.prompt_tokens,
+        outputTokens: usage.completion_tokens,
+        totalTokens: usage.total_tokens,
+    };
+}
+function assertHasChoices(result) {
+    if (!('choices' in result)) {
+        throw new Error('Streaming responses are not supported in this runtime.');
+    }
+}