praisonai 1.0.18 → 1.1.0

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

@@ -0,0 +1,43 @@
+/**
+ * LLM Providers - Factory and exports for multi-provider support
+ */
+export * from './types';
+export * from './base';
+export { OpenAIProvider } from './openai';
+export { AnthropicProvider } from './anthropic';
+export { GoogleProvider } from './google';
+import type { LLMProvider, ProviderConfig } from './types';
+/**
+ * Parse model string into provider and model ID
+ * Supports formats:
+ * - "provider/model" (e.g., "openai/gpt-4o")
+ * - "model" (defaults to OpenAI, e.g., "gpt-4o-mini")
+ */
+export declare function parseModelString(model: string): {
+    providerId: string;
+    modelId: string;
+};
+/**
+ * Create a provider instance from a model string
+ *
+ * @example
+ * ```typescript
+ * const provider = createProvider('openai/gpt-4o');
+ * const provider = createProvider('anthropic/claude-3-5-sonnet-latest');
+ * const provider = createProvider('google/gemini-2.0-flash');
+ * const provider = createProvider('gpt-4o-mini'); // Defaults to OpenAI
+ * ```
+ */
+export declare function createProvider(model: string, config?: ProviderConfig): LLMProvider;
+/**
+ * Get the default provider (OpenAI with gpt-4o-mini)
+ */
+export declare function getDefaultProvider(config?: ProviderConfig): LLMProvider;
+/**
+ * Check if a provider is available (has required API key)
+ */
+export declare function isProviderAvailable(providerId: string): boolean;
+/**
+ * Get list of available providers
+ */
+export declare function getAvailableProviders(): string[];

package/dist/llm/providers/index.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * LLM Providers - Factory and exports for multi-provider support
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleProvider = exports.AnthropicProvider = exports.OpenAIProvider = void 0;
+exports.parseModelString = parseModelString;
+exports.createProvider = createProvider;
+exports.getDefaultProvider = getDefaultProvider;
+exports.isProviderAvailable = isProviderAvailable;
+exports.getAvailableProviders = getAvailableProviders;
+__exportStar(require("./types"), exports);
+__exportStar(require("./base"), exports);
+var openai_1 = require("./openai");
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return openai_1.OpenAIProvider; } });
+var anthropic_1 = require("./anthropic");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return anthropic_1.AnthropicProvider; } });
+var google_1 = require("./google");
+Object.defineProperty(exports, "GoogleProvider", { enumerable: true, get: function () { return google_1.GoogleProvider; } });
+const openai_2 = require("./openai");
+const anthropic_2 = require("./anthropic");
+const google_2 = require("./google");
+/**
+ * Provider registry for dynamic provider loading
+ */
+const PROVIDER_MAP = {
+    openai: openai_2.OpenAIProvider,
+    anthropic: anthropic_2.AnthropicProvider,
+    google: google_2.GoogleProvider,
+    gemini: google_2.GoogleProvider, // Alias
+};
+/**
+ * Parse model string into provider and model ID
+ * Supports formats:
+ * - "provider/model" (e.g., "openai/gpt-4o")
+ * - "model" (defaults to OpenAI, e.g., "gpt-4o-mini")
+ */
+function parseModelString(model) {
+    if (model.includes('/')) {
+        const [providerId, ...rest] = model.split('/');
+        return { providerId: providerId.toLowerCase(), modelId: rest.join('/') };
+    }
+    // Default to OpenAI for common model prefixes
+    if (model.startsWith('gpt-') || model.startsWith('o1') || model.startsWith('o3')) {
+        return { providerId: 'openai', modelId: model };
+    }
+    if (model.startsWith('claude-')) {
+        return { providerId: 'anthropic', modelId: model };
+    }
+    if (model.startsWith('gemini-')) {
+        return { providerId: 'google', modelId: model };
+    }
+    // Default to OpenAI
+    return { providerId: 'openai', modelId: model };
+}
+/**
+ * Create a provider instance from a model string
+ *
+ * @example
+ * ```typescript
+ * const provider = createProvider('openai/gpt-4o');
+ * const provider = createProvider('anthropic/claude-3-5-sonnet-latest');
+ * const provider = createProvider('google/gemini-2.0-flash');
+ * const provider = createProvider('gpt-4o-mini'); // Defaults to OpenAI
+ * ```
+ */
+function createProvider(model, config) {
+    const { providerId, modelId } = parseModelString(model);
+    const ProviderClass = PROVIDER_MAP[providerId];
+    if (!ProviderClass) {
+        throw new Error(`Unknown provider: ${providerId}. Available providers: ${Object.keys(PROVIDER_MAP).join(', ')}`);
+    }
+    return new ProviderClass(modelId, config);
+}
+/**
+ * Get the default provider (OpenAI with gpt-4o-mini)
+ */
+function getDefaultProvider(config) {
+    return createProvider('openai/gpt-4o-mini', config);
+}
+/**
+ * Check if a provider is available (has required API key)
+ */
+function isProviderAvailable(providerId) {
+    switch (providerId.toLowerCase()) {
+        case 'openai':
+            return !!process.env.OPENAI_API_KEY;
+        case 'anthropic':
+            return !!process.env.ANTHROPIC_API_KEY;
+        case 'google':
+        case 'gemini':
+            return !!process.env.GOOGLE_API_KEY;
+        default:
+            return false;
+    }
+}
+/**
+ * Get list of available providers
+ */
+function getAvailableProviders() {
+    return Object.keys(PROVIDER_MAP).filter(isProviderAvailable);
+}

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

@@ -0,0 +1,18 @@
+/**
+ * OpenAI Provider - Implementation for OpenAI API
+ */
+import type { ChatCompletionMessageParam, ChatCompletionTool } from 'openai/resources/chat/completions';
+import { BaseProvider } from './base';
+import type { ProviderConfig, GenerateTextOptions, GenerateTextResult, StreamTextOptions, StreamChunk, GenerateObjectOptions, GenerateObjectResult, Message, ToolDefinition } from './types';
+export declare class OpenAIProvider extends BaseProvider {
+    readonly providerId = "openai";
+    private client;
+    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>>;
+    protected formatMessages(messages: Message[]): ChatCompletionMessageParam[];
+    protected formatTools(tools: ToolDefinition[]): ChatCompletionTool[];
+    private mapFinishReason;
+    private normalizeSchema;
+}

package/dist/llm/providers/openai.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * OpenAI Provider - Implementation for OpenAI API
+ */
+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"));
+const base_1 = require("./base");
+class OpenAIProvider extends base_1.BaseProvider {
+    constructor(modelId, config = {}) {
+        super(modelId, config);
+        this.providerId = 'openai';
+        this.client = new openai_1.default({
+            apiKey: config.apiKey || process.env.OPENAI_API_KEY,
+            baseURL: config.baseUrl,
+            timeout: config.timeout || 60000,
+            maxRetries: 0, // We handle retries ourselves
+        });
+    }
+    async generateText(options) {
+        return this.withRetry(async () => {
+            const response = await this.client.chat.completions.create({
+                model: this.modelId,
+                messages: this.formatMessages(options.messages),
+                temperature: options.temperature ?? 0.7,
+                max_tokens: options.maxTokens,
+                tools: options.tools ? this.formatTools(options.tools) : undefined,
+                tool_choice: options.toolChoice,
+                stop: options.stop,
+                top_p: options.topP,
+                frequency_penalty: options.frequencyPenalty,
+                presence_penalty: options.presencePenalty,
+            });
+            const choice = response.choices[0];
+            const message = choice.message;
+            return {
+                text: message.content || '',
+                toolCalls: message.tool_calls?.map(tc => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: {
+                        name: tc.function.name,
+                        arguments: tc.function.arguments,
+                    },
+                })),
+                usage: {
+                    promptTokens: response.usage?.prompt_tokens || 0,
+                    completionTokens: response.usage?.completion_tokens || 0,
+                    totalTokens: response.usage?.total_tokens || 0,
+                },
+                finishReason: this.mapFinishReason(choice.finish_reason),
+                raw: response,
+            };
+        });
+    }
+    async streamText(options) {
+        const self = this;
+        return {
+            async *[Symbol.asyncIterator]() {
+                const stream = await self.client.chat.completions.create({
+                    model: self.modelId,
+                    messages: self.formatMessages(options.messages),
+                    temperature: options.temperature ?? 0.7,
+                    max_tokens: options.maxTokens,
+                    tools: options.tools ? self.formatTools(options.tools) : undefined,
+                    tool_choice: options.toolChoice,
+                    stop: options.stop,
+                    stream: true,
+                });
+                let toolCalls = [];
+                for await (const chunk of stream) {
+                    const delta = chunk.choices[0]?.delta;
+                    if (delta?.content) {
+                        if (options.onToken) {
+                            options.onToken(delta.content);
+                        }
+                        yield { text: delta.content };
+                    }
+                    if (delta?.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            if (tc.index !== undefined) {
+                                if (!toolCalls[tc.index]) {
+                                    toolCalls[tc.index] = {
+                                        id: tc.id || '',
+                                        type: 'function',
+                                        function: { name: '', arguments: '' },
+                                    };
+                                }
+                                if (tc.id)
+                                    toolCalls[tc.index].id = tc.id;
+                                if (tc.function?.name)
+                                    toolCalls[tc.index].function.name = tc.function.name;
+                                if (tc.function?.arguments)
+                                    toolCalls[tc.index].function.arguments += tc.function.arguments;
+                            }
+                        }
+                    }
+                    if (chunk.choices[0]?.finish_reason) {
+                        yield {
+                            finishReason: chunk.choices[0].finish_reason,
+                            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                            usage: chunk.usage ? {
+                                promptTokens: chunk.usage.prompt_tokens,
+                                completionTokens: chunk.usage.completion_tokens,
+                                totalTokens: chunk.usage.total_tokens,
+                            } : undefined,
+                        };
+                    }
+                }
+            },
+        };
+    }
+    async generateObject(options) {
+        return this.withRetry(async () => {
+            const response = await this.client.chat.completions.create({
+                model: this.modelId,
+                messages: this.formatMessages(options.messages),
+                temperature: options.temperature ?? 0.7,
+                max_tokens: options.maxTokens,
+                response_format: {
+                    type: 'json_schema',
+                    json_schema: {
+                        name: 'response',
+                        schema: this.normalizeSchema(options.schema),
+                        strict: true,
+                    },
+                },
+            });
+            const choice = response.choices[0];
+            const content = choice.message.content || '{}';
+            let parsed;
+            try {
+                parsed = JSON.parse(content);
+            }
+            catch (e) {
+                throw new Error(`Failed to parse JSON response: ${content}`);
+            }
+            return {
+                object: parsed,
+                usage: {
+                    promptTokens: response.usage?.prompt_tokens || 0,
+                    completionTokens: response.usage?.completion_tokens || 0,
+                    totalTokens: response.usage?.total_tokens || 0,
+                },
+                raw: response,
+            };
+        });
+    }
+    formatMessages(messages) {
+        return messages.map(msg => {
+            if (msg.role === 'tool') {
+                return {
+                    role: 'tool',
+                    content: msg.content || '',
+                    tool_call_id: msg.tool_call_id || '',
+                };
+            }
+            if (msg.role === 'assistant' && msg.tool_calls) {
+                return {
+                    role: 'assistant',
+                    content: msg.content,
+                    tool_calls: msg.tool_calls,
+                };
+            }
+            return {
+                role: msg.role,
+                content: msg.content || '',
+            };
+        });
+    }
+    formatTools(tools) {
+        return tools.map(tool => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description || `Function ${tool.name}`,
+                parameters: tool.parameters || { type: 'object', properties: {} },
+            },
+        }));
+    }
+    mapFinishReason(reason) {
+        switch (reason) {
+            case 'stop': return 'stop';
+            case 'length': return 'length';
+            case 'tool_calls': return 'tool_calls';
+            case 'content_filter': return 'content_filter';
+            default: return 'stop';
+        }
+    }
+    normalizeSchema(schema) {
+        // If it's a Zod schema, convert to JSON schema
+        if (schema && typeof schema.parse === 'function' && typeof schema._def === 'object') {
+            // This is a Zod schema - we need zod-to-json-schema
+            // For now, throw an error suggesting to use JSON schema directly
+            throw new Error('Zod schemas require zod-to-json-schema. Please use JSON schema directly or install zod-to-json-schema.');
+        }
+        return schema;
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;

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

@@ -0,0 +1,94 @@
+/**
+ * LLM Provider Types - Core type definitions for the provider abstraction layer
+ */
+export interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | null;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[];
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ToolDefinition {
+    name: string;
+    description?: string;
+    parameters?: Record<string, any>;
+}
+export interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+export interface GenerateTextOptions {
+    messages: Message[];
+    temperature?: number;
+    maxTokens?: number;
+    tools?: ToolDefinition[];
+    toolChoice?: 'auto' | 'none' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    stop?: string[];
+    topP?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+}
+export interface GenerateTextResult {
+    text: string;
+    toolCalls?: ToolCall[];
+    usage: TokenUsage;
+    finishReason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'error';
+    raw?: any;
+}
+export interface StreamTextOptions extends GenerateTextOptions {
+    onToken?: (token: string) => void;
+    onToolCall?: (toolCall: ToolCall) => void;
+}
+export interface StreamChunk {
+    text?: string;
+    toolCalls?: ToolCall[];
+    usage?: Partial<TokenUsage>;
+    finishReason?: string;
+}
+export interface GenerateObjectOptions<T = any> {
+    messages: Message[];
+    schema: Record<string, any> | any;
+    temperature?: number;
+    maxTokens?: number;
+    maxRetries?: number;
+}
+export interface GenerateObjectResult<T = any> {
+    object: T;
+    usage: TokenUsage;
+    raw?: any;
+}
+export interface ProviderConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    maxRetries?: number;
+    timeout?: number;
+    defaultModel?: string;
+}
+/**
+ * Base interface for all LLM providers
+ */
+export interface LLMProvider {
+    readonly providerId: string;
+    readonly modelId: string;
+    generateText(options: GenerateTextOptions): Promise<GenerateTextResult>;
+    streamText(options: StreamTextOptions): Promise<AsyncIterable<StreamChunk>>;
+    generateObject<T = any>(options: GenerateObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+}
+/**
+ * Provider factory function type
+ */
+export type ProviderFactory = (modelId: string, config?: ProviderConfig) => LLMProvider;

package/dist/llm/providers/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * LLM Provider Types - Core type definitions for the provider abstraction layer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/observability/index.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Observability - Tracing, logging, and metrics hooks
+ */
+export type SpanKind = 'llm' | 'tool' | 'agent' | 'workflow' | 'custom';
+export type SpanStatus = 'pending' | 'running' | 'completed' | 'failed';
+export interface SpanData {
+    id: string;
+    traceId: string;
+    parentId?: string;
+    name: string;
+    kind: SpanKind;
+    status: SpanStatus;
+    startTime: number;
+    endTime?: number;
+    attributes: Record<string, any>;
+    events: SpanEvent[];
+}
+export interface SpanEvent {
+    name: string;
+    timestamp: number;
+    attributes?: Record<string, any>;
+}
+export interface TraceData {
+    id: string;
+    name: string;
+    startTime: number;
+    endTime?: number;
+    status: SpanStatus;
+    spans: SpanData[];
+    metadata: Record<string, any>;
+}
+/**
+ * Observability Adapter Protocol
+ */
+export interface ObservabilityAdapter {
+    startTrace(name: string, metadata?: Record<string, any>): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, any>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, any>): void;
+    flush(): Promise<void>;
+}
+export interface TraceContext {
+    traceId: string;
+    startSpan(name: string, kind: SpanKind): SpanContext;
+    end(status?: SpanStatus): void;
+}
+export interface SpanContext {
+    spanId: string;
+    traceId: string;
+    addEvent(name: string, attributes?: Record<string, any>): void;
+    setAttributes(attributes: Record<string, any>): void;
+    end(status?: SpanStatus): void;
+}
+/**
+ * In-memory observability adapter for development
+ */
+export declare class MemoryObservabilityAdapter implements ObservabilityAdapter {
+    private traces;
+    private spans;
+    startTrace(name: string, metadata?: Record<string, any>): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, any>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, any>): void;
+    flush(): Promise<void>;
+    getTrace(traceId: string): TraceData | undefined;
+    getSpan(spanId: string): SpanData | undefined;
+    getAllTraces(): TraceData[];
+    clear(): void;
+    private generateId;
+}
+/**
+ * Console observability adapter for debugging
+ */
+export declare class ConsoleObservabilityAdapter implements ObservabilityAdapter {
+    private memory;
+    startTrace(name: string, metadata?: Record<string, any>): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, any>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, any>): void;
+    flush(): Promise<void>;
+}
+export declare function setObservabilityAdapter(adapter: ObservabilityAdapter): void;
+export declare function getObservabilityAdapter(): ObservabilityAdapter;