@wavequery/conductor/dist/cjs/llm/openai.js

Modular LLM orchestration framework

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.OpenAIProvider = void 0;
const openai_1 = __importDefault(require("openai"));
class OpenAIProvider {
    constructor(config) {
        this.client = new openai_1.default({
            apiKey: config.apiKey,
            organization: config.organizationId,
        });
        this.defaultModel = config.defaultModel;
    }
    async complete(prompt, options = {}) {
        try {
            const response = await this.client.chat.completions.create({
                model: options.model || this.defaultModel,
                messages: [{ role: "user", content: prompt }],
                temperature: options.temperature ?? 0.1,
                max_tokens: options.maxTokens,
                response_format: options.responseFormat
                    ? { type: options.responseFormat }
                    : undefined,
            });
            const completion = response.choices[0];
            return {
                content: completion.message.content || "",
                usage: {
                    promptTokens: response.usage?.prompt_tokens || 0,
                    completionTokens: response.usage?.completion_tokens || 0,
                    totalTokens: response.usage?.total_tokens || 0,
                },
                raw: response,
            };
        }
        catch (error) {
            throw new Error(`OpenAI completion error: ${error.message}`);
        }
    }
    async completeWithFunctions(prompt, functions, options = {}) {
        try {
            const response = await this.client.chat.completions.create({
                model: options.model || this.defaultModel,
                messages: [{ role: "user", content: prompt }],
                temperature: options.temperature ?? 0.1,
                max_tokens: options.maxTokens,
                tools: functions.map((fn) => ({
                    type: "function",
                    function: fn,
                })),
                tool_choice: "auto",
            });
            const completion = response.choices[0];
            const toolCall = completion.message.tool_calls?.[0];
            return {
                content: completion.message.content || "",
                usage: {
                    promptTokens: response.usage?.prompt_tokens || 0,
                    completionTokens: response.usage?.completion_tokens || 0,
                    totalTokens: response.usage?.total_tokens || 0,
                },
                functionCall: toolCall
                    ? {
                        name: toolCall.function.name,
                        arguments: JSON.parse(toolCall.function.arguments),
                    }
                    : undefined,
                raw: response,
            };
        }
        catch (error) {
            throw new Error(`OpenAI function completion error: ${error.message}`);
        }
    }
}
exports.OpenAIProvider = OpenAIProvider;
//# sourceMappingURL=openai.js.map