erosolar-cli 1.5.2 → 1.5.4

package/dist/bin/providers/openaiChatCompletionsProvider.js

@@ -0,0 +1,208 @@
+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

@@ -0,0 +1,249 @@
+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

@@ -0,0 +1,24 @@
+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);
+}