praisonai 1.0.18 → 1.1.0

package/dist/llm/providers/anthropic.js

@@ -0,0 +1,291 @@
+"use strict";
+/**
+ * Anthropic Provider - Implementation for Anthropic Claude API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+const base_1 = require("./base");
+class AnthropicProvider extends base_1.BaseProvider {
+    constructor(modelId, config = {}) {
+        super(modelId, config);
+        this.providerId = 'anthropic';
+        this.apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY || '';
+        this.baseUrl = config.baseUrl || 'https://api.anthropic.com';
+        if (!this.apiKey) {
+            throw new Error('ANTHROPIC_API_KEY is required');
+        }
+    }
+    async generateText(options) {
+        return this.withRetry(async () => {
+            const { systemPrompt, messages } = this.extractSystemPrompt(options.messages);
+            const response = await fetch(`${this.baseUrl}/v1/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.apiKey,
+                    'anthropic-version': '2023-06-01',
+                },
+                body: JSON.stringify({
+                    model: this.modelId,
+                    max_tokens: options.maxTokens || 4096,
+                    system: systemPrompt,
+                    messages: this.formatMessages(messages),
+                    temperature: options.temperature ?? 0.7,
+                    tools: options.tools ? this.formatTools(options.tools) : undefined,
+                    stop_sequences: options.stop,
+                    top_p: options.topP,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw Object.assign(new Error(error.error?.message || `Anthropic API error: ${response.status}`), {
+                    status: response.status,
+                });
+            }
+            const data = await response.json();
+            let text = '';
+            const toolCalls = [];
+            for (const block of data.content || []) {
+                if (block.type === 'text') {
+                    text += block.text;
+                }
+                else if (block.type === 'tool_use') {
+                    toolCalls.push({
+                        id: block.id,
+                        type: 'function',
+                        function: {
+                            name: block.name,
+                            arguments: JSON.stringify(block.input),
+                        },
+                    });
+                }
+            }
+            return {
+                text,
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                usage: {
+                    promptTokens: data.usage?.input_tokens || 0,
+                    completionTokens: data.usage?.output_tokens || 0,
+                    totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0),
+                },
+                finishReason: this.mapStopReason(data.stop_reason),
+                raw: data,
+            };
+        });
+    }
+    async streamText(options) {
+        const self = this;
+        const { systemPrompt, messages } = this.extractSystemPrompt(options.messages);
+        return {
+            async *[Symbol.asyncIterator]() {
+                const response = await fetch(`${self.baseUrl}/v1/messages`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-api-key': self.apiKey,
+                        'anthropic-version': '2023-06-01',
+                    },
+                    body: JSON.stringify({
+                        model: self.modelId,
+                        max_tokens: options.maxTokens || 4096,
+                        system: systemPrompt,
+                        messages: self.formatMessages(messages),
+                        temperature: options.temperature ?? 0.7,
+                        tools: options.tools ? self.formatTools(options.tools) : undefined,
+                        stream: true,
+                    }),
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({}));
+                    throw new Error(error.error?.message || `Anthropic API error: ${response.status}`);
+                }
+                const reader = response.body?.getReader();
+                if (!reader)
+                    throw new Error('No response body');
+                const decoder = new TextDecoder();
+                let buffer = '';
+                const toolCalls = [];
+                let currentToolCall = null;
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (!line.startsWith('data: '))
+                            continue;
+                        const data = line.slice(6);
+                        if (data === '[DONE]')
+                            continue;
+                        try {
+                            const event = JSON.parse(data);
+                            if (event.type === 'content_block_delta') {
+                                if (event.delta?.type === 'text_delta') {
+                                    const text = event.delta.text;
+                                    if (options.onToken)
+                                        options.onToken(text);
+                                    yield { text };
+                                }
+                                else if (event.delta?.type === 'input_json_delta') {
+                                    if (currentToolCall) {
+                                        currentToolCall.function.arguments += event.delta.partial_json;
+                                    }
+                                }
+                            }
+                            else if (event.type === 'content_block_start') {
+                                if (event.content_block?.type === 'tool_use') {
+                                    currentToolCall = {
+                                        id: event.content_block.id,
+                                        type: 'function',
+                                        function: {
+                                            name: event.content_block.name,
+                                            arguments: '',
+                                        },
+                                    };
+                                }
+                            }
+                            else if (event.type === 'content_block_stop') {
+                                if (currentToolCall) {
+                                    toolCalls.push(currentToolCall);
+                                    currentToolCall = null;
+                                }
+                            }
+                            else if (event.type === 'message_delta') {
+                                yield {
+                                    finishReason: self.mapStopReason(event.delta?.stop_reason),
+                                    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                                    usage: event.usage ? {
+                                        promptTokens: 0,
+                                        completionTokens: event.usage.output_tokens,
+                                        totalTokens: event.usage.output_tokens,
+                                    } : undefined,
+                                };
+                            }
+                        }
+                        catch (e) {
+                            // Skip malformed JSON
+                        }
+                    }
+                }
+            },
+        };
+    }
+    async generateObject(options) {
+        const { systemPrompt, messages } = this.extractSystemPrompt(options.messages);
+        // Add JSON instruction to system prompt
+        const jsonSystemPrompt = `${systemPrompt}\n\nYou must respond with valid JSON matching this schema:\n${JSON.stringify(options.schema, null, 2)}`;
+        return this.withRetry(async () => {
+            const response = await fetch(`${this.baseUrl}/v1/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.apiKey,
+                    'anthropic-version': '2023-06-01',
+                },
+                body: JSON.stringify({
+                    model: this.modelId,
+                    max_tokens: options.maxTokens || 4096,
+                    system: jsonSystemPrompt,
+                    messages: this.formatMessages(messages),
+                    temperature: options.temperature ?? 0.7,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || `Anthropic API error: ${response.status}`);
+            }
+            const data = await response.json();
+            let text = '';
+            for (const block of data.content || []) {
+                if (block.type === 'text') {
+                    text += block.text;
+                }
+            }
+            // Extract JSON from response
+            const jsonMatch = text.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                throw new Error(`No JSON found in response: ${text}`);
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(jsonMatch[0]);
+            }
+            catch (e) {
+                throw new Error(`Failed to parse JSON: ${jsonMatch[0]}`);
+            }
+            return {
+                object: parsed,
+                usage: {
+                    promptTokens: data.usage?.input_tokens || 0,
+                    completionTokens: data.usage?.output_tokens || 0,
+                    totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0),
+                },
+                raw: data,
+            };
+        });
+    }
+    extractSystemPrompt(messages) {
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const otherMessages = messages.filter(m => m.role !== 'system');
+        const systemPrompt = systemMessages.map(m => m.content).join('\n');
+        return { systemPrompt, messages: otherMessages };
+    }
+    formatMessages(messages) {
+        const result = [];
+        for (const msg of messages) {
+            if (msg.role === 'system')
+                continue; // Handled separately
+            if (msg.role === 'tool') {
+                // Tool results need to be part of user message in Anthropic
+                result.push({
+                    role: 'user',
+                    content: [{
+                            type: 'tool_result',
+                            tool_use_id: msg.tool_call_id || '',
+                            content: msg.content || '',
+                        }],
+                });
+            }
+            else if (msg.role === 'assistant' && msg.tool_calls) {
+                const content = [];
+                if (msg.content) {
+                    content.push({ type: 'text', text: msg.content });
+                }
+                for (const tc of msg.tool_calls) {
+                    content.push({
+                        type: 'tool_use',
+                        id: tc.id,
+                        name: tc.function.name,
+                        input: JSON.parse(tc.function.arguments),
+                    });
+                }
+                result.push({ role: 'assistant', content });
+            }
+            else {
+                result.push({
+                    role: msg.role,
+                    content: msg.content || '',
+                });
+            }
+        }
+        return result;
+    }
+    formatTools(tools) {
+        return tools.map(tool => ({
+            name: tool.name,
+            description: tool.description || `Function ${tool.name}`,
+            input_schema: tool.parameters || { type: 'object', properties: {} },
+        }));
+    }
+    mapStopReason(reason) {
+        switch (reason) {
+            case 'end_turn': return 'stop';
+            case 'max_tokens': return 'length';
+            case 'tool_use': return 'tool_calls';
+            default: return 'stop';
+        }
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;

package/dist/llm/providers/base.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Base Provider - Abstract base class for LLM providers
+ */
+import type { LLMProvider, ProviderConfig, GenerateTextOptions, GenerateTextResult, StreamTextOptions, StreamChunk, GenerateObjectOptions, GenerateObjectResult, Message, ToolDefinition } from './types';
+export declare abstract class BaseProvider implements LLMProvider {
+    abstract readonly providerId: string;
+    readonly modelId: string;
+    protected config: ProviderConfig;
+    constructor(modelId: string, config?: ProviderConfig);
+    abstract generateText(options: GenerateTextOptions): Promise<GenerateTextResult>;
+    abstract streamText(options: StreamTextOptions): Promise<AsyncIterable<StreamChunk>>;
+    abstract generateObject<T = any>(options: GenerateObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+    /**
+     * Convert tool definitions to provider-specific format
+     */
+    protected abstract formatTools(tools: ToolDefinition[]): any[];
+    /**
+     * Convert messages to provider-specific format
+     */
+    protected abstract formatMessages(messages: Message[]): any[];
+    /**
+     * Retry logic with exponential backoff
+     */
+    protected withRetry<T>(fn: () => Promise<T>, maxRetries?: number): Promise<T>;
+}

package/dist/llm/providers/base.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Base Provider - Abstract base class for LLM providers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProvider = void 0;
+class BaseProvider {
+    constructor(modelId, config = {}) {
+        this.modelId = modelId;
+        this.config = {
+            maxRetries: 3,
+            timeout: 60000,
+            ...config,
+        };
+    }
+    /**
+     * Retry logic with exponential backoff
+     */
+    async withRetry(fn, maxRetries = this.config.maxRetries || 3) {
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                // Check if error is retryable (rate limit, server error)
+                const isRetryable = error.status === 429 ||
+                    error.status >= 500 ||
+                    error.code === 'ECONNRESET' ||
+                    error.code === 'ETIMEDOUT';
+                if (!isRetryable || attempt === maxRetries) {
+                    throw error;
+                }
+                // Exponential backoff
+                const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+        throw lastError;
+    }
+}
+exports.BaseProvider = BaseProvider;

package/dist/llm/providers/google.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Google Provider - Implementation for Google Gemini API
+ */
+import { BaseProvider } from './base';
+import type { ProviderConfig, GenerateTextOptions, GenerateTextResult, StreamTextOptions, StreamChunk, GenerateObjectOptions, GenerateObjectResult, Message, ToolDefinition } from './types';
+interface GeminiContent {
+    role: 'user' | 'model';
+    parts: Array<{
+        text?: string;
+        functionCall?: any;
+        functionResponse?: any;
+    }>;
+}
+export declare class GoogleProvider extends BaseProvider {
+    readonly providerId = "google";
+    private apiKey;
+    private baseUrl;
+    constructor(modelId: string, config?: ProviderConfig);
+    generateText(options: GenerateTextOptions): Promise<GenerateTextResult>;
+    streamText(options: StreamTextOptions): Promise<AsyncIterable<StreamChunk>>;
+    generateObject<T = any>(options: GenerateObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+    private formatRequest;
+    protected formatMessages(messages: Message[]): GeminiContent[];
+    protected formatTools(tools: ToolDefinition[]): any[];
+    private mapFinishReason;
+}
+export {};

package/dist/llm/providers/google.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * Google Provider - Implementation for Google Gemini API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleProvider = void 0;
+const base_1 = require("./base");
+class GoogleProvider extends base_1.BaseProvider {
+    constructor(modelId, config = {}) {
+        super(modelId, config);
+        this.providerId = 'google';
+        this.apiKey = config.apiKey || process.env.GOOGLE_API_KEY || '';
+        this.baseUrl = config.baseUrl || 'https://generativelanguage.googleapis.com/v1beta';
+        if (!this.apiKey) {
+            throw new Error('GOOGLE_API_KEY is required');
+        }
+    }
+    async generateText(options) {
+        return this.withRetry(async () => {
+            const { systemInstruction, contents } = this.formatRequest(options.messages);
+            const response = await fetch(`${this.baseUrl}/models/${this.modelId}:generateContent?key=${this.apiKey}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
+                    contents,
+                    generationConfig: {
+                        temperature: options.temperature ?? 0.7,
+                        maxOutputTokens: options.maxTokens,
+                        topP: options.topP,
+                        stopSequences: options.stop,
+                    },
+                    tools: options.tools ? this.formatTools(options.tools) : undefined,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw Object.assign(new Error(error.error?.message || `Google API error: ${response.status}`), {
+                    status: response.status,
+                });
+            }
+            const data = await response.json();
+            const candidate = data.candidates?.[0];
+            let text = '';
+            const toolCalls = [];
+            for (const part of candidate?.content?.parts || []) {
+                if (part.text) {
+                    text += part.text;
+                }
+                else if (part.functionCall) {
+                    toolCalls.push({
+                        id: `call_${Math.random().toString(36).substr(2, 9)}`,
+                        type: 'function',
+                        function: {
+                            name: part.functionCall.name,
+                            arguments: JSON.stringify(part.functionCall.args || {}),
+                        },
+                    });
+                }
+            }
+            return {
+                text,
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                usage: {
+                    promptTokens: data.usageMetadata?.promptTokenCount || 0,
+                    completionTokens: data.usageMetadata?.candidatesTokenCount || 0,
+                    totalTokens: data.usageMetadata?.totalTokenCount || 0,
+                },
+                finishReason: this.mapFinishReason(candidate?.finishReason),
+                raw: data,
+            };
+        });
+    }
+    async streamText(options) {
+        const self = this;
+        const { systemInstruction, contents } = this.formatRequest(options.messages);
+        return {
+            async *[Symbol.asyncIterator]() {
+                const response = await fetch(`${self.baseUrl}/models/${self.modelId}:streamGenerateContent?key=${self.apiKey}&alt=sse`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
+                        contents,
+                        generationConfig: {
+                            temperature: options.temperature ?? 0.7,
+                            maxOutputTokens: options.maxTokens,
+                        },
+                        tools: options.tools ? self.formatTools(options.tools) : undefined,
+                    }),
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({}));
+                    throw new Error(error.error?.message || `Google API error: ${response.status}`);
+                }
+                const reader = response.body?.getReader();
+                if (!reader)
+                    throw new Error('No response body');
+                const decoder = new TextDecoder();
+                let buffer = '';
+                const toolCalls = [];
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (!line.startsWith('data: '))
+                            continue;
+                        const data = line.slice(6);
+                        if (data === '[DONE]')
+                            continue;
+                        try {
+                            const event = JSON.parse(data);
+                            const candidate = event.candidates?.[0];
+                            for (const part of candidate?.content?.parts || []) {
+                                if (part.text) {
+                                    if (options.onToken)
+                                        options.onToken(part.text);
+                                    yield { text: part.text };
+                                }
+                                else if (part.functionCall) {
+                                    toolCalls.push({
+                                        id: `call_${Math.random().toString(36).substr(2, 9)}`,
+                                        type: 'function',
+                                        function: {
+                                            name: part.functionCall.name,
+                                            arguments: JSON.stringify(part.functionCall.args || {}),
+                                        },
+                                    });
+                                }
+                            }
+                            if (candidate?.finishReason) {
+                                yield {
+                                    finishReason: self.mapFinishReason(candidate.finishReason),
+                                    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                                    usage: event.usageMetadata ? {
+                                        promptTokens: event.usageMetadata.promptTokenCount || 0,
+                                        completionTokens: event.usageMetadata.candidatesTokenCount || 0,
+                                        totalTokens: event.usageMetadata.totalTokenCount || 0,
+                                    } : undefined,
+                                };
+                            }
+                        }
+                        catch (e) {
+                            // Skip malformed JSON
+                        }
+                    }
+                }
+            },
+        };
+    }
+    async generateObject(options) {
+        const { systemInstruction, contents } = this.formatRequest(options.messages);
+        return this.withRetry(async () => {
+            const response = await fetch(`${this.baseUrl}/models/${this.modelId}:generateContent?key=${this.apiKey}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    systemInstruction: systemInstruction
+                        ? { parts: [{ text: `${systemInstruction}\n\nRespond with valid JSON matching this schema:\n${JSON.stringify(options.schema, null, 2)}` }] }
+                        : { parts: [{ text: `Respond with valid JSON matching this schema:\n${JSON.stringify(options.schema, null, 2)}` }] },
+                    contents,
+                    generationConfig: {
+                        temperature: options.temperature ?? 0.7,
+                        maxOutputTokens: options.maxTokens,
+                        responseMimeType: 'application/json',
+                    },
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || `Google API error: ${response.status}`);
+            }
+            const data = await response.json();
+            const candidate = data.candidates?.[0];
+            let text = '';
+            for (const part of candidate?.content?.parts || []) {
+                if (part.text)
+                    text += part.text;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch (e) {
+                // Try to extract JSON from text
+                const jsonMatch = text.match(/\{[\s\S]*\}/);
+                if (!jsonMatch)
+                    throw new Error(`No JSON found: ${text}`);
+                parsed = JSON.parse(jsonMatch[0]);
+            }
+            return {
+                object: parsed,
+                usage: {
+                    promptTokens: data.usageMetadata?.promptTokenCount || 0,
+                    completionTokens: data.usageMetadata?.candidatesTokenCount || 0,
+                    totalTokens: data.usageMetadata?.totalTokenCount || 0,
+                },
+                raw: data,
+            };
+        });
+    }
+    formatRequest(messages) {
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const otherMessages = messages.filter(m => m.role !== 'system');
+        const systemInstruction = systemMessages.length > 0
+            ? systemMessages.map(m => m.content).join('\n')
+            : null;
+        return {
+            systemInstruction,
+            contents: this.formatMessages(otherMessages),
+        };
+    }
+    formatMessages(messages) {
+        const result = [];
+        for (const msg of messages) {
+            if (msg.role === 'system')
+                continue;
+            const role = msg.role === 'assistant' ? 'model' : 'user';
+            if (msg.role === 'tool') {
+                result.push({
+                    role: 'user',
+                    parts: [{
+                            functionResponse: {
+                                name: msg.name || 'function',
+                                response: { result: msg.content },
+                            },
+                        }],
+                });
+            }
+            else if (msg.role === 'assistant' && msg.tool_calls) {
+                const parts = [];
+                if (msg.content)
+                    parts.push({ text: msg.content });
+                for (const tc of msg.tool_calls) {
+                    parts.push({
+                        functionCall: {
+                            name: tc.function.name,
+                            args: JSON.parse(tc.function.arguments),
+                        },
+                    });
+                }
+                result.push({ role: 'model', parts });
+            }
+            else {
+                result.push({
+                    role,
+                    parts: [{ text: msg.content || '' }],
+                });
+            }
+        }
+        return result;
+    }
+    formatTools(tools) {
+        return [{
+                functionDeclarations: tools.map(tool => ({
+                    name: tool.name,
+                    description: tool.description || `Function ${tool.name}`,
+                    parameters: tool.parameters || { type: 'object', properties: {} },
+                })),
+            }];
+    }
+    mapFinishReason(reason) {
+        switch (reason) {
+            case 'STOP': return 'stop';
+            case 'MAX_TOKENS': return 'length';
+            case 'SAFETY': return 'content_filter';
+            default: return 'stop';
+        }
+    }
+}
+exports.GoogleProvider = GoogleProvider;