overai 1.4.0

package/dist/llm/openai.js

@@ -0,0 +1,302 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIService = void 0;
+const openai_1 = __importDefault(require("openai"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const logger_1 = require("../utils/logger");
+// Load environment variables once at the application level
+dotenv_1.default.config();
+if (!process.env.OPENAI_API_KEY) {
+    throw new Error('OPENAI_API_KEY not found in environment variables');
+}
+// Convert our ChatMessage to OpenAI's ChatCompletionMessageParam
+function convertToOpenAIMessage(message) {
+    // Basic conversion for common message types
+    if (message.role === 'system' || message.role === 'user' || message.role === 'assistant') {
+        return {
+            role: message.role,
+            content: message.content || '',
+            ...(message.tool_calls ? { tool_calls: message.tool_calls } : {})
+        };
+    }
+    // Handle tool messages
+    if (message.role === 'tool') {
+        return {
+            role: 'tool',
+            content: message.content || '',
+            tool_call_id: message.tool_call_id || ''
+        };
+    }
+    // Default fallback
+    return {
+        role: 'user',
+        content: message.content || ''
+    };
+}
+// Convert custom tool format to OpenAI's ChatCompletionTool format
+function convertToOpenAITool(tool) {
+    // If it's already in the correct format, return it
+    if (tool.type === 'function' && typeof tool.type === 'string') {
+        // Ensure the function name is valid
+        if (!tool.function?.name || tool.function.name.trim() === '') {
+            tool.function.name = `function_${Math.random().toString(36).substring(2, 9)}`;
+        }
+        return tool;
+    }
+    // Generate a valid function name if none is provided
+    const functionName = tool.function?.name && tool.function.name.trim() !== ''
+        ? tool.function.name
+        : `function_${Math.random().toString(36).substring(2, 9)}`;
+    // Otherwise, try to convert it
+    return {
+        type: 'function',
+        function: {
+            name: functionName,
+            description: tool.function?.description || `Function ${functionName}`,
+            parameters: tool.function?.parameters || {}
+        }
+    };
+}
+// Singleton instance for OpenAI client
+let openAIInstance = null;
+// Get cached OpenAI client instance
+async function getOpenAIClient() {
+    if (!openAIInstance) {
+        openAIInstance = new openai_1.default({
+            apiKey: process.env.OPENAI_API_KEY
+        });
+        await logger_1.Logger.debug('OpenAI client initialized');
+    }
+    return openAIInstance;
+}
+class OpenAIService {
+    constructor(model = 'gpt-5-nano') {
+        this.client = null;
+        this.model = model;
+        logger_1.Logger.debug(`OpenAIService initialized with model: ${model}`);
+    }
+    // Lazy initialization of client
+    async getClient() {
+        if (!this.client) {
+            this.client = await getOpenAIClient();
+        }
+        return this.client;
+    }
+    async generateText(prompt, systemPrompt = '', temperature = 0.7, tools, tool_choice) {
+        await logger_1.Logger.startSpinner('Generating text with OpenAI...');
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({ role: 'system', content: systemPrompt });
+        }
+        messages.push({ role: 'user', content: prompt });
+        try {
+            // Convert messages to OpenAI format
+            const openAIMessages = messages.map(convertToOpenAIMessage);
+            // Convert tools to OpenAI format if provided
+            const openAITools = tools ? tools.map(convertToOpenAITool) : undefined;
+            const completion = await this.getClient().then(client => client.chat.completions.create({
+                model: this.model,
+                temperature,
+                messages: openAIMessages,
+                tools: openAITools,
+                tool_choice
+            }));
+            const message = completion.choices[0]?.message;
+            if (!message) {
+                throw new Error('No response from OpenAI');
+            }
+            // Check for tool calls
+            if (message.tool_calls && message.tool_calls.length > 0) {
+                await logger_1.Logger.debug('Tool calls detected in generateText', { tool_calls: message.tool_calls });
+                // For backward compatibility, we return a message about tool calls
+                return 'The model wants to use tools. Please use generateChat or chatCompletion instead.';
+            }
+            const response = message.content;
+            if (!response) {
+                throw new Error('No content in response from OpenAI');
+            }
+            await logger_1.Logger.stopSpinner(true);
+            await logger_1.Logger.section('Generated Response', response);
+            return response;
+        }
+        catch (error) {
+            await logger_1.Logger.stopSpinner(false);
+            await logger_1.Logger.error('Error generating text', error);
+            throw error;
+        }
+    }
+    async generateChat(messages, temperature = 0.7, tools, tool_choice) {
+        await logger_1.Logger.startSpinner('Generating chat response...');
+        try {
+            // Convert messages to OpenAI format
+            const openAIMessages = messages.map(convertToOpenAIMessage);
+            // Convert tools to OpenAI format if provided
+            const openAITools = tools ? tools.map(convertToOpenAITool) : undefined;
+            const completion = await this.getClient().then(client => client.chat.completions.create({
+                model: this.model,
+                temperature,
+                messages: openAIMessages,
+                tools: openAITools,
+                tool_choice
+            }));
+            const response = completion.choices[0]?.message;
+            if (!response) {
+                throw new Error('No response from OpenAI');
+            }
+            await logger_1.Logger.stopSpinner(true);
+            const result = {
+                content: response.content || '',
+                role: response.role
+            };
+            // Add tool calls if they exist
+            if (response.tool_calls && response.tool_calls.length > 0) {
+                result.tool_calls = response.tool_calls;
+                await logger_1.Logger.debug('Tool calls detected', { tool_calls: result.tool_calls });
+            }
+            await logger_1.Logger.section('Chat Response', result.content);
+            return result;
+        }
+        catch (error) {
+            await logger_1.Logger.stopSpinner(false);
+            await logger_1.Logger.error('Error generating chat response', error);
+            throw error;
+        }
+    }
+    async streamText(prompt, systemPrompt = '', temperature = 0.7, onToken, tools, tool_choice, onToolCall) {
+        await logger_1.Logger.debug('Starting text stream...', {
+            model: this.model,
+            temperature
+        });
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({ role: 'system', content: systemPrompt });
+        }
+        messages.push({ role: 'user', content: prompt });
+        try {
+            // Convert messages to OpenAI format
+            const openAIMessages = messages.map(convertToOpenAIMessage);
+            // Convert tools to OpenAI format if provided
+            const openAITools = tools ? tools.map(convertToOpenAITool) : undefined;
+            const stream = await this.getClient().then(client => client.chat.completions.create({
+                model: this.model,
+                temperature,
+                messages: openAIMessages,
+                stream: true,
+                tools: openAITools,
+                tool_choice
+            }));
+            let fullResponse = '';
+            const toolCalls = {};
+            for await (const chunk of stream) {
+                const delta = chunk.choices[0]?.delta;
+                // Handle content tokens
+                if (delta?.content) {
+                    const token = delta.content;
+                    fullResponse += token;
+                    onToken(token);
+                }
+                // Handle tool calls
+                if (delta?.tool_calls && delta.tool_calls.length > 0) {
+                    for (const toolCall of delta.tool_calls) {
+                        const { index } = toolCall;
+                        if (!toolCalls[index]) {
+                            toolCalls[index] = {
+                                id: toolCall.id,
+                                type: toolCall.type,
+                                function: {
+                                    name: toolCall.function?.name || '',
+                                    arguments: ''
+                                }
+                            };
+                        }
+                        // Accumulate function arguments
+                        if (toolCall.function?.arguments) {
+                            toolCalls[index].function.arguments += toolCall.function.arguments;
+                        }
+                        // Call the onToolCall callback if provided
+                        if (onToolCall) {
+                            onToolCall(toolCalls[index]);
+                        }
+                    }
+                }
+            }
+            await logger_1.Logger.debug('Stream completed successfully');
+        }
+        catch (error) {
+            await logger_1.Logger.error('Error in text stream', error);
+            throw error;
+        }
+    }
+    async streamChat(messages, temperature = 0.7, onToken) {
+        await logger_1.Logger.debug('Starting chat stream with messages...', {
+            model: this.model,
+            messageCount: messages.length
+        });
+        try {
+            const openAIMessages = messages.map(convertToOpenAIMessage);
+            const stream = await this.getClient().then(client => client.chat.completions.create({
+                model: this.model,
+                temperature,
+                messages: openAIMessages,
+                stream: true
+            }));
+            let fullResponse = '';
+            for await (const chunk of stream) {
+                const delta = chunk.choices[0]?.delta;
+                if (delta?.content) {
+                    const token = delta.content;
+                    fullResponse += token;
+                    onToken(token);
+                }
+            }
+            await logger_1.Logger.debug('Chat stream completed');
+            return fullResponse;
+        }
+        catch (error) {
+            await logger_1.Logger.error('Error in chat stream', error);
+            throw error;
+        }
+    }
+    async chatCompletion(messages, temperature = 0.7, tools, tool_choice) {
+        await logger_1.Logger.startSpinner('Chat completion with OpenAI...');
+        try {
+            // Convert messages to OpenAI format
+            const openAIMessages = messages.map(convertToOpenAIMessage);
+            // Convert tools to OpenAI format if provided
+            const openAITools = tools ? tools.map(convertToOpenAITool) : undefined;
+            const completion = await this.getClient().then(client => client.chat.completions.create({
+                model: this.model,
+                temperature,
+                messages: openAIMessages,
+                tools: openAITools,
+                tool_choice
+            }));
+            // Safely access the message
+            if (!completion.choices || completion.choices.length === 0 || !completion.choices[0].message) {
+                throw new Error('No response from OpenAI');
+            }
+            const message = completion.choices[0].message;
+            const response = {
+                content: message.content || '',
+                role: message.role
+            };
+            // Add tool calls if they exist
+            if (message.tool_calls && message.tool_calls.length > 0) {
+                response.tool_calls = message.tool_calls;
+                await logger_1.Logger.debug('Tool calls detected', { tool_calls: response.tool_calls });
+            }
+            await logger_1.Logger.stopSpinner(true);
+            await logger_1.Logger.section('Chat Completion Response', response.content);
+            return response;
+        }
+        catch (error) {
+            await logger_1.Logger.stopSpinner(false);
+            await logger_1.Logger.error('Error in chat completion', error);
+            throw error;
+        }
+    }
+}
+exports.OpenAIService = OpenAIService;

package/dist/llm/providers/ai-sdk/adapter.d.ts

@@ -0,0 +1,121 @@
+/**
+ * AI SDK Adapter
+ *
+ * Converts between praisonai-ts message/tool formats and AI SDK formats.
+ * Handles prompt construction, tool definitions, and result parsing.
+ */
+import type { Message, ToolDefinition, ToolCall, GenerateTextResult } from '../types';
+import type { AISDKToolCall, AISDKToolResult, FinishReason, PraisonStreamChunk } from './types';
+/**
+ * AI SDK prompt message types (simplified for compatibility)
+ */
+export interface AISDKSystemMessage {
+    role: 'system';
+    content: string;
+}
+export interface AISDKUserMessage {
+    role: 'user';
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}
+export interface AISDKAssistantMessage {
+    role: 'assistant';
+    content: Array<{
+        type: 'text';
+        text: string;
+    } | {
+        type: 'tool-call';
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+    }>;
+}
+export interface AISDKToolMessage {
+    role: 'tool';
+    content: Array<{
+        type: 'tool-result';
+        toolCallId: string;
+        toolName: string;
+        result: unknown;
+    }>;
+}
+export type AISDKMessage = AISDKSystemMessage | AISDKUserMessage | AISDKAssistantMessage | AISDKToolMessage;
+/**
+ * Convert praisonai-ts messages to AI SDK prompt format
+ */
+export declare function toAISDKPrompt(messages: Message[]): AISDKMessage[];
+/**
+ * Convert praisonai-ts tool definitions to AI SDK format
+ * AI SDK expects tools created with the tool() helper from @ai-sdk/provider-utils
+ */
+export declare function toAISDKTools(tools: ToolDefinition[]): Promise<Record<string, any>>;
+/**
+ * Convert AI SDK tool call to praisonai-ts format
+ */
+export declare function fromAISDKToolCall(toolCall: AISDKToolCall): ToolCall;
+/**
+ * Convert praisonai-ts tool result to AI SDK format
+ */
+export declare function toAISDKToolResult(toolCallId: string, toolName: string, result: unknown): AISDKToolResult;
+/**
+ * Extract text content from AI SDK response content
+ */
+export declare function extractTextFromContent(content: unknown[]): string;
+/**
+ * Extract tool calls from AI SDK response content
+ */
+export declare function extractToolCallsFromContent(content: unknown[]): ToolCall[];
+/**
+ * Convert AI SDK generate result to praisonai-ts format
+ */
+export declare function fromAISDKResult(result: {
+    text?: string;
+    content?: unknown[];
+    toolCalls?: AISDKToolCall[];
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+    finishReason?: string;
+}): GenerateTextResult;
+/**
+ * Map AI SDK finish reason to internal format
+ */
+export declare function mapFinishReason(reason?: string): FinishReason;
+/**
+ * Map AI SDK finish reason to praisonai-ts provider format
+ * Uses underscore format for tool_calls as expected by GenerateTextResult
+ */
+export declare function mapFinishReasonToProvider(reason?: string): 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'error';
+/**
+ * Convert AI SDK stream chunk to praisonai-ts format
+ */
+export declare function fromAISDKStreamChunk(chunk: {
+    type: string;
+    textDelta?: string;
+    toolCallId?: string;
+    toolName?: string;
+    argsTextDelta?: string;
+    args?: unknown;
+    finishReason?: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+}): PraisonStreamChunk | null;
+/**
+ * Map praisonai-ts tool choice to AI SDK format
+ */
+export declare function toAISDKToolChoice(toolChoice?: 'auto' | 'none' | 'required' | {
+    type: 'tool';
+    toolName: string;
+}): 'auto' | 'none' | 'required' | {
+    type: 'tool';
+    toolName: string;
+} | undefined;
+/**
+ * Create a simple prompt from a string
+ */
+export declare function createSimplePrompt(prompt: string, systemPrompt?: string): AISDKMessage[];