@olane/o-intelligence 0.7.12-alpha.9 → 0.7.12

package/dist/src/perplexity-intelligence.tool.js

@@ -1,12 +1,13 @@
 import { oAddress } from '@olane/o-core';
 import { LLM_PARAMS } from './methods/llm.methods.js';
 import { oLaneTool } from '@olane/o-lane';
+import { StreamUtils } from '@olane/o-node';
 export class PerplexityIntelligenceTool extends oLaneTool {
     constructor(config) {
         super({
             ...config,
             address: new oAddress('o://perplexity'),
-            description: 'Perplexity sonar model is useful for searching the web or providing information about a wide range of topics',
+            description: 'Perplexity intelligence tool is useful for searching the web or providing information about any unknown entity or topic',
             methods: LLM_PARAMS,
             dependencies: [],
         });
@@ -17,8 +18,13 @@ export class PerplexityIntelligenceTool extends oLaneTool {
      * Chat completion with Perplexity
      */
     async _tool_completion(request) {
+        const params = request.params;
+        const { _isStreaming = false } = params;
+        if (_isStreaming) {
+            this.logger.debug('Streaming completion...');
+            return StreamUtils.processGenerator(request, this._streamCompletion(request), request.stream);
+        }
         try {
-            const params = request.params;
             const { model = this.defaultModel, messages, max_tokens, temperature, top_p, top_k, presence_penalty, frequency_penalty, apiKey = this.defaultApiKey, search_domain, return_citations, return_images, return_related_questions, } = params;
             if (!messages || !Array.isArray(messages)) {
                 return {
@@ -89,12 +95,151 @@ export class PerplexityIntelligenceTool extends oLaneTool {
             };
         }
     }
+    /**
+     * Stream chat completion with Perplexity
+     */
+    async *_streamCompletion(request) {
+        try {
+            const params = request.params;
+            const { model = this.defaultModel, messages, max_tokens, temperature, top_p, top_k, presence_penalty, frequency_penalty, apiKey = this.defaultApiKey, search_domain, return_citations, return_images, return_related_questions, } = params;
+            if (!messages || !Array.isArray(messages)) {
+                yield {
+                    success: false,
+                    error: '"messages" array is required',
+                };
+                return;
+            }
+            if (!apiKey) {
+                yield {
+                    success: false,
+                    error: 'Perplexity API key is required',
+                };
+                return;
+            }
+            const chatRequest = {
+                model: model,
+                messages: messages,
+                stream: true,
+            };
+            // Add optional parameters if provided
+            if (max_tokens !== undefined)
+                chatRequest.max_tokens = max_tokens;
+            if (temperature !== undefined)
+                chatRequest.temperature = temperature;
+            if (top_p !== undefined)
+                chatRequest.top_p = top_p;
+            if (top_k !== undefined)
+                chatRequest.top_k = top_k;
+            if (presence_penalty !== undefined)
+                chatRequest.presence_penalty = presence_penalty;
+            if (frequency_penalty !== undefined)
+                chatRequest.frequency_penalty = frequency_penalty;
+            if (search_domain !== undefined)
+                chatRequest.search_domain = search_domain;
+            if (return_citations !== undefined)
+                chatRequest.return_citations = return_citations;
+            if (return_images !== undefined)
+                chatRequest.return_images = return_images;
+            if (return_related_questions !== undefined)
+                chatRequest.return_related_questions = return_related_questions;
+            const response = await fetch(`https://api.perplexity.ai/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(chatRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                yield {
+                    success: false,
+                    error: `Perplexity API error: ${response.status} - ${errorText}`,
+                };
+                return;
+            }
+            if (!response.body) {
+                yield { success: false, error: 'Response body is null' };
+                return;
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            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) {
+                    const trimmedLine = line.trim();
+                    if (!trimmedLine || !trimmedLine.startsWith('data: '))
+                        continue;
+                    const data = trimmedLine.slice(6);
+                    if (data === '[DONE]')
+                        break;
+                    try {
+                        const parsed = JSON.parse(data);
+                        const choice = parsed.choices?.[0];
+                        if (choice?.delta?.content) {
+                            yield {
+                                delta: choice.delta.content,
+                                model: parsed.model || model,
+                            };
+                        }
+                        if (choice?.finish_reason) {
+                            yield {
+                                finish_reason: choice.finish_reason,
+                            };
+                        }
+                        if (parsed.usage) {
+                            yield {
+                                usage: parsed.usage,
+                            };
+                        }
+                        // Handle Perplexity-specific fields
+                        if (parsed.citations) {
+                            yield {
+                                citations: parsed.citations,
+                            };
+                        }
+                        if (parsed.images) {
+                            yield {
+                                images: parsed.images,
+                            };
+                        }
+                        if (parsed.related_questions) {
+                            yield {
+                                related_questions: parsed.related_questions,
+                            };
+                        }
+                    }
+                    catch (parseError) {
+                        // Skip invalid JSON
+                        continue;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            yield {
+                success: false,
+                error: `Failed to stream chat: ${error.message}`,
+            };
+        }
+    }
     /**
      * Generate text with Perplexity (alias for completion)
      */
     async _tool_generate(request) {
+        const params = request.params;
+        const { _isStreaming = false } = params;
+        if (_isStreaming) {
+            this.logger.debug('Streaming generate...');
+            return StreamUtils.processGenerator(request, this._streamGenerate(request), request.stream);
+        }
         try {
-            const params = request.params;
             const { model = this.defaultModel, prompt, system, max_tokens, temperature, top_p, top_k, presence_penalty, frequency_penalty, search_domain, return_citations, return_images, return_related_questions, apiKey = this.defaultApiKey, } = params;
             if (!prompt) {
                 return {
@@ -171,6 +316,146 @@ export class PerplexityIntelligenceTool extends oLaneTool {
             };
         }
     }
+    /**
+     * Stream text generation with Perplexity
+     */
+    async *_streamGenerate(request) {
+        try {
+            const params = request.params;
+            const { model = this.defaultModel, prompt, system, max_tokens, temperature, top_p, top_k, presence_penalty, frequency_penalty, search_domain, return_citations, return_images, return_related_questions, apiKey = this.defaultApiKey, } = params;
+            if (!prompt) {
+                yield {
+                    success: false,
+                    error: 'Prompt is required',
+                };
+                return;
+            }
+            if (!apiKey) {
+                yield {
+                    success: false,
+                    error: 'Perplexity API key is required',
+                };
+                return;
+            }
+            // Convert prompt to messages format
+            const messages = [];
+            if (system) {
+                messages.push({ role: 'system', content: system });
+            }
+            messages.push({ role: 'user', content: prompt });
+            const chatRequest = {
+                model: model,
+                messages,
+                stream: true,
+            };
+            // Add optional parameters if provided
+            if (max_tokens !== undefined)
+                chatRequest.max_tokens = max_tokens;
+            if (temperature !== undefined)
+                chatRequest.temperature = temperature;
+            if (top_p !== undefined)
+                chatRequest.top_p = top_p;
+            if (top_k !== undefined)
+                chatRequest.top_k = top_k;
+            if (presence_penalty !== undefined)
+                chatRequest.presence_penalty = presence_penalty;
+            if (frequency_penalty !== undefined)
+                chatRequest.frequency_penalty = frequency_penalty;
+            if (search_domain !== undefined)
+                chatRequest.search_domain = search_domain;
+            if (return_citations !== undefined)
+                chatRequest.return_citations = return_citations;
+            if (return_images !== undefined)
+                chatRequest.return_images = return_images;
+            if (return_related_questions !== undefined)
+                chatRequest.return_related_questions = return_related_questions;
+            const response = await fetch(`https://api.perplexity.ai/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(chatRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                yield {
+                    success: false,
+                    error: `Perplexity API error: ${response.status} - ${errorText}`,
+                };
+                return;
+            }
+            if (!response.body) {
+                yield { success: false, error: 'Response body is null' };
+                return;
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            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) {
+                    const trimmedLine = line.trim();
+                    if (!trimmedLine || !trimmedLine.startsWith('data: '))
+                        continue;
+                    const data = trimmedLine.slice(6);
+                    if (data === '[DONE]')
+                        break;
+                    try {
+                        const parsed = JSON.parse(data);
+                        const choice = parsed.choices?.[0];
+                        if (choice?.delta?.content) {
+                            yield {
+                                delta: choice.delta.content,
+                                model: parsed.model || model,
+                            };
+                        }
+                        if (choice?.finish_reason) {
+                            yield {
+                                finish_reason: choice.finish_reason,
+                            };
+                        }
+                        if (parsed.usage) {
+                            yield {
+                                usage: parsed.usage,
+                            };
+                        }
+                        // Handle Perplexity-specific fields
+                        if (parsed.citations) {
+                            yield {
+                                citations: parsed.citations,
+                            };
+                        }
+                        if (parsed.images) {
+                            yield {
+                                images: parsed.images,
+                            };
+                        }
+                        if (parsed.related_questions) {
+                            yield {
+                                related_questions: parsed.related_questions,
+                            };
+                        }
+                    }
+                    catch (parseError) {
+                        // Skip invalid JSON
+                        continue;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            yield {
+                success: false,
+                error: `Failed to stream generate: ${error.message}`,
+            };
+        }
+    }
     /**
      * List available models
      */

package/dist/src/types/streaming.types.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Streaming-related type definitions for o-intelligence package
+ */
+/**
+ * Represents a single chunk of streaming data
+ */
+export interface StreamChunk {
+    /**
+     * The text content of this chunk (token/text fragment)
+     */
+    text: string;
+    /**
+     * Whether this is a delta (incremental) chunk
+     */
+    delta?: boolean;
+    /**
+     * Current position in the stream (optional)
+     */
+    position?: number;
+    /**
+     * Whether this is the final chunk
+     */
+    isComplete?: boolean;
+    /**
+     * Model information
+     */
+    model?: string;
+    /**
+     * Additional metadata from the provider
+     */
+    metadata?: {
+        /**
+         * Finish reason (if available)
+         */
+        finish_reason?: string;
+        /**
+         * Token usage information (usually in final chunk)
+         */
+        usage?: {
+            prompt_tokens?: number;
+            completion_tokens?: number;
+            total_tokens?: number;
+        };
+        /**
+         * Provider-specific data
+         */
+        [key: string]: any;
+    };
+}
+/**
+ * Configuration options for streaming
+ */
+export interface StreamingOptions {
+    /**
+     * Whether to enable streaming
+     */
+    enabled?: boolean;
+    /**
+     * Buffer size for streaming chunks (in bytes)
+     */
+    bufferSize?: number;
+    /**
+     * Timeout for reading from stream (in milliseconds)
+     */
+    readTimeoutMs?: number;
+    /**
+     * Whether to include metadata in each chunk
+     */
+    includeMetadata?: boolean;
+    /**
+     * Callback for handling errors during streaming
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Callback for when streaming starts
+     */
+    onStart?: () => void;
+    /**
+     * Callback for when streaming completes
+     */
+    onComplete?: (totalChunks: number) => void;
+}
+/**
+ * Streaming request parameters (extends standard completion params)
+ */
+export interface StreamingRequestParams {
+    /**
+     * The model to use
+     */
+    model?: string;
+    /**
+     * Messages for chat completion
+     */
+    messages?: Array<{
+        role: string;
+        content: string;
+    }>;
+    /**
+     * System message
+     */
+    system?: string;
+    /**
+     * Maximum tokens to generate
+     */
+    max_tokens?: number;
+    /**
+     * Temperature (0-1 or 0-2 depending on provider)
+     */
+    temperature?: number;
+    /**
+     * Top-p sampling
+     */
+    top_p?: number;
+    /**
+     * API key for the provider
+     */
+    apiKey?: string;
+    /**
+     * Whether to stream the response
+     */
+    stream?: boolean;
+    /**
+     * Streaming-specific options
+     */
+    streamingOptions?: StreamingOptions;
+    /**
+     * Additional provider-specific parameters
+     */
+    [key: string]: any;
+}
+/**
+ * Accumulator for building complete response from chunks
+ */
+export interface StreamAccumulator {
+    /**
+     * Full text accumulated so far
+     */
+    fullText: string;
+    /**
+     * Number of chunks received
+     */
+    chunkCount: number;
+    /**
+     * Timestamp when streaming started
+     */
+    startTime: number;
+    /**
+     * Whether streaming is complete
+     */
+    isComplete: boolean;
+    /**
+     * Final metadata (if available)
+     */
+    metadata?: StreamChunk['metadata'];
+}
+/**
+ * Result from a completed stream
+ */
+export interface StreamResult {
+    /**
+     * Complete generated text
+     */
+    text: string;
+    /**
+     * Model used
+     */
+    model?: string;
+    /**
+     * Total chunks received
+     */
+    totalChunks: number;
+    /**
+     * Time taken (in milliseconds)
+     */
+    duration: number;
+    /**
+     * Usage information
+     */
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    /**
+     * Finish reason
+     */
+    finish_reason?: string;
+    /**
+     * Whether the stream completed successfully
+     */
+    success: boolean;
+    /**
+     * Error message if stream failed
+     */
+    error?: string;
+}
+//# sourceMappingURL=streaming.types.d.ts.map

package/dist/src/types/streaming.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.types.d.ts","sourceRoot":"","sources":["../../../src/types/streaming.types.ts"],"names":[],"mappings":"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"}

package/dist/src/types/streaming.types.js

@@ -0,0 +1,4 @@
+/**
+ * Streaming-related type definitions for o-intelligence package
+ */
+export {};

package/dist/src/utils/sse-parser.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Server-Sent Events (SSE) Parser Utility
+ *
+ * Parses streaming responses from various LLM providers that use SSE format.
+ * Most providers (Anthropic, OpenAI, Perplexity, Grok) follow a similar pattern:
+ * - Lines starting with "data: " contain JSON payloads
+ * - "data: [DONE]" signals stream completion
+ * - Empty lines separate events
+ */
+/// <reference types="node" />
+/**
+ * Represents a parsed SSE message
+ */
+export interface SSEMessage {
+    event?: string;
+    data?: string;
+    id?: string;
+    retry?: number;
+}
+/**
+ * Parse a buffer of SSE text into individual messages
+ *
+ * @param buffer - The text buffer containing SSE data
+ * @returns Array of parsed SSE messages
+ */
+export declare function parseSSE(buffer: string): SSEMessage[];
+/**
+ * Check if SSE data indicates stream completion
+ */
+export declare function isStreamDone(data: string): boolean;
+/**
+ * AsyncGenerator that yields parsed chunks from a ReadableStream
+ *
+ * @param stream - The response stream from fetch
+ * @yields Parsed JSON data from each SSE message
+ */
+export declare function streamSSEChunks(stream: ReadableStream<Uint8Array>): AsyncGenerator<any, void, unknown>;
+/**
+ * Extract text content from Anthropic streaming chunk
+ */
+export declare function extractAnthropicContent(chunk: any): string;
+/**
+ * Extract text content from OpenAI streaming chunk
+ */
+export declare function extractOpenAIContent(chunk: any): string;
+/**
+ * Extract text content from Ollama streaming chunk
+ */
+export declare function extractOllamaContent(chunk: any): string;
+/**
+ * Extract text content from Perplexity streaming chunk
+ */
+export declare function extractPerplexityContent(chunk: any): string;
+/**
+ * Extract text content from Grok streaming chunk
+ */
+export declare function extractGrokContent(chunk: any): string;
+/**
+ * Extract text content from Gemini streaming chunk
+ */
+export declare function extractGeminiContent(chunk: any): string;
+/**
+ * Generic content extractor that tries multiple patterns
+ */
+export declare function extractContent(chunk: any, provider?: string): string;
+//# sourceMappingURL=sse-parser.d.ts.map

package/dist/src/utils/sse-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-parser.d.ts","sourceRoot":"","sources":["../../../src/utils/sse-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;;AAEH;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAsBD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,EAAE,CAkDrD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;;GAKG;AACH,wBAAuB,eAAe,CACpC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GACjC,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC,CAoEpC;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,CAK1D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,CAKvD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,CAQvD;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,CAK3D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,CAKrD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,CAKvD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAiDpE"}