erosolar-cli 1.7.55 → 1.7.57

package/dist/bin/providers/openaiChatCompletionsProvider.js

@@ -1,208 +0,0 @@
-import OpenAI from 'openai';
-export class OpenAIChatCompletionsProvider {
-    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 = {};
-    const rawArgs = call.function.arguments ?? '{}';
-    try {
-        parsed = JSON.parse(rawArgs);
-    }
-    catch (error) {
-        // Try to recover malformed JSON (common with some models)
-        const recovered = tryRecoverMalformedJson(rawArgs);
-        if (recovered) {
-            parsed = recovered;
-        }
-        else {
-            // Log warning for debugging but continue with empty args
-            console.warn(`[tool-call] Failed to parse arguments for ${call.function.name}: ${rawArgs.slice(0, 100)}...`);
-        }
-    }
-    return {
-        id: call.id ?? call.function.name,
-        name: call.function.name,
-        arguments: parsed,
-    };
-}
-/**
- * Try to recover malformed JSON from tool call arguments.
- * Some models return truncated or malformed JSON that can be fixed.
- */
-function tryRecoverMalformedJson(raw) {
-    if (!raw || !raw.trim()) {
-        return null;
-    }
-    const attempts = [
-        // Try adding missing closing braces/quotes
-        raw + '"}',
-        raw + '}',
-        raw + '"' + '}',
-        raw + '"}}',
-        raw + '}}',
-    ];
-    for (const attempt of attempts) {
-        try {
-            const parsed = JSON.parse(attempt);
-            if (typeof parsed === 'object' && parsed !== null) {
-                return parsed;
-            }
-        }
-        catch {
-            // Continue to next attempt
-        }
-    }
-    // Try regex extraction as last resort
-    try {
-        const pairs = raw.matchAll(/"([^"]+)":\s*(?:"([^"]*)"?|(\d+(?:\.\d+)?)|(\btrue\b|\bfalse\b|\bnull\b))/g);
-        const result = {};
-        for (const match of pairs) {
-            const [, key, strVal, numVal, boolVal] = match;
-            if (key) {
-                if (strVal !== undefined) {
-                    result[key] = strVal;
-                }
-                else if (numVal) {
-                    result[key] = numVal.includes('.') ? parseFloat(numVal) : parseInt(numVal, 10);
-                }
-                else if (boolVal) {
-                    result[key] = boolVal === 'true' ? true : boolVal === 'false' ? false : null;
-                }
-            }
-        }
-        if (Object.keys(result).length > 0) {
-            return result;
-        }
-    }
-    catch {
-        // Regex extraction failed
-    }
-    return null;
-}
-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.');
-    }
-}

package/dist/bin/providers/openaiResponsesProvider.js

@@ -1,249 +0,0 @@
-import OpenAI from 'openai';
-export class OpenAIResponsesProvider {
-    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;
-        this.reasoningEffort = options.reasoningEffort;
-        this.textVerbosity = options.textVerbosity;
-    }
-    async generate(messages, tools) {
-        const request = {
-            model: this.model,
-            input: mapMessages(messages),
-            tools: tools.length ? tools.map(mapTool) : undefined,
-            stream: false,
-        };
-        if (this.reasoningEffort) {
-            request.reasoning = { effort: this.reasoningEffort };
-        }
-        if (this.textVerbosity) {
-            request.text = { verbosity: this.textVerbosity };
-        }
-        const response = await this.client.responses.create(request);
-        assertHasOutput(response);
-        const toolCalls = response.output.filter(isFunctionCall).map(mapToolCall);
-        const usage = mapUsage(response.usage);
-        if (toolCalls.length > 0) {
-            return {
-                type: 'tool_calls',
-                toolCalls,
-                content: extractTextContent(response),
-                usage,
-            };
-        }
-        return {
-            type: 'message',
-            content: extractTextContent(response),
-            usage,
-        };
-    }
-    async *generateStream(messages, tools) {
-        const request = {
-            model: this.model,
-            input: mapMessages(messages),
-            tools: tools.length ? tools.map(mapTool) : undefined,
-            stream: true,
-        };
-        if (this.reasoningEffort) {
-            request.reasoning = { effort: this.reasoningEffort };
-        }
-        if (this.textVerbosity) {
-            request.text = { verbosity: this.textVerbosity };
-        }
-        const stream = await this.client.responses.create(request);
-        // Track tool calls being built
-        const pendingToolCalls = new Map();
-        for await (const event of stream) {
-            switch (event.type) {
-                case 'response.output_text.delta':
-                    if (event.delta) {
-                        yield { type: 'content', content: event.delta };
-                    }
-                    break;
-                case 'response.function_call_arguments.delta':
-                    if (event.call_id) {
-                        const existing = pendingToolCalls.get(event.call_id);
-                        if (existing) {
-                            existing.arguments += event.delta ?? '';
-                        }
-                        else {
-                            pendingToolCalls.set(event.call_id, {
-                                name: event.name ?? '',
-                                arguments: event.delta ?? '',
-                            });
-                        }
-                    }
-                    break;
-                case 'response.function_call_arguments.done':
-                    if (event.call_id) {
-                        const pending = pendingToolCalls.get(event.call_id);
-                        if (pending) {
-                            let parsed = {};
-                            try {
-                                parsed = JSON.parse(pending.arguments || '{}');
-                            }
-                            catch {
-                                parsed = {};
-                            }
-                            yield {
-                                type: 'tool_call',
-                                toolCall: {
-                                    id: event.call_id,
-                                    name: event.name ?? pending.name,
-                                    arguments: parsed,
-                                },
-                            };
-                            pendingToolCalls.delete(event.call_id);
-                        }
-                    }
-                    break;
-                case 'response.done':
-                    if (event.response?.usage) {
-                        const usage = mapUsage(event.response.usage);
-                        if (usage) {
-                            yield { type: 'usage', usage };
-                        }
-                    }
-                    yield { type: 'done' };
-                    break;
-            }
-        }
-    }
-}
-function mapMessages(messages) {
-    const input = [];
-    for (const message of messages) {
-        switch (message.role) {
-            case 'system':
-            case 'user':
-            case 'assistant': {
-                input.push({
-                    role: message.role,
-                    content: message.content,
-                    type: 'message',
-                });
-                if (message.role === 'assistant') {
-                    for (const call of message.toolCalls ?? []) {
-                        input.push({
-                            type: 'function_call',
-                            call_id: call.id,
-                            name: call.name,
-                            arguments: JSON.stringify(call.arguments ?? {}),
-                        });
-                    }
-                }
-                break;
-            }
-            case 'tool': {
-                input.push({
-                    type: 'function_call_output',
-                    call_id: message.toolCallId,
-                    output: message.content,
-                });
-                break;
-            }
-            default:
-                break;
-        }
-    }
-    return input;
-}
-function mapTool(definition) {
-    return {
-        type: 'function',
-        name: definition.name,
-        description: definition.description,
-        parameters: (definition.parameters ?? {
-            type: 'object',
-            properties: {},
-        }),
-        strict: false,
-    };
-}
-function extractTextContent(response) {
-    const primary = collectOutputText(response.output);
-    if (primary) {
-        return primary;
-    }
-    const aggregated = typeof response.output_text === 'string' ? response.output_text.trim() : '';
-    if (aggregated) {
-        return aggregated;
-    }
-    const refusal = collectRefusalText(response.output);
-    if (refusal) {
-        return refusal;
-    }
-    return '';
-}
-function collectOutputText(output) {
-    const chunks = [];
-    for (const item of output) {
-        if (!isOutputMessage(item)) {
-            continue;
-        }
-        for (const block of item.content) {
-            if (block.type === 'output_text') {
-                chunks.push(block.text);
-            }
-        }
-    }
-    return chunks.join('\n').trim();
-}
-function collectRefusalText(output) {
-    for (const item of output) {
-        if (!isOutputMessage(item)) {
-            continue;
-        }
-        for (const block of item.content) {
-            if (isRefusal(block) && block.refusal?.trim()) {
-                return block.refusal.trim();
-            }
-        }
-    }
-    return '';
-}
-function mapToolCall(call) {
-    let parsed = {};
-    try {
-        parsed = JSON.parse(call.arguments ?? '{}');
-    }
-    catch {
-        parsed = {};
-    }
-    return {
-        id: call.call_id ?? call.id ?? '',
-        name: call.name,
-        arguments: parsed,
-    };
-}
-function mapUsage(usage) {
-    if (!usage) {
-        return undefined;
-    }
-    return {
-        inputTokens: usage.input_tokens,
-        outputTokens: usage.output_tokens,
-        totalTokens: usage.total_tokens,
-    };
-}
-function isFunctionCall(item) {
-    return item.type === 'function_call';
-}
-function isOutputMessage(item) {
-    return item.type === 'message';
-}
-function isRefusal(block) {
-    return block.type === 'refusal';
-}
-function assertHasOutput(response) {
-    if (!('output' in response)) {
-        throw new Error('Streaming responses are not supported in this runtime.');
-    }
-}

package/dist/bin/providers/providerFactory.js

@@ -1,24 +0,0 @@
-const registry = new Map();
-export function registerProvider(id, factory, options = {}) {
-    if (!id?.trim()) {
-        throw new Error('Provider id cannot be blank.');
-    }
-    if (registry.has(id) && !options.override) {
-        throw new Error(`Provider "${id}" is already registered.`);
-    }
-    registry.set(id, factory);
-}
-export function createProvider(config) {
-    const factory = registry.get(config.provider);
-    if (!factory) {
-        const known = Array.from(registry.keys()).sort().join(', ');
-        throw new Error(`Provider "${config.provider}" is not registered. Registered providers: ${known || 'none'}.`);
-    }
-    return factory(config);
-}
-export function listRegisteredProviders() {
-    return Array.from(registry.keys());
-}
-export function hasProvider(id) {
-    return registry.has(id);
-}