praisonai 1.3.6 → 1.5.0

package/dist/ai/multimodal.js

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * Multimodal - AI SDK Wrapper
+ *
+ * Provides utilities for multimodal inputs (images, files, PDFs).
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTextPart = createTextPart;
+exports.createImagePart = createImagePart;
+exports.createFilePart = createFilePart;
+exports.createPdfPart = createPdfPart;
+exports.toMessageContent = toMessageContent;
+exports.createMultimodalMessage = createMultimodalMessage;
+exports.base64ToUint8Array = base64ToUint8Array;
+exports.uint8ArrayToBase64 = uint8ArrayToBase64;
+exports.isUrl = isUrl;
+exports.isDataUrl = isDataUrl;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Create a text part.
+ */
+function createTextPart(text) {
+    return { type: 'text', text };
+}
+/**
+ * Create an image part from various sources.
+ *
+ * @example From URL
+ * ```typescript
+ * const imagePart = createImagePart('https://example.com/image.png');
+ * ```
+ *
+ * @example From base64
+ * ```typescript
+ * const imagePart = createImagePart('data:image/png;base64,...');
+ * ```
+ *
+ * @example From file path
+ * ```typescript
+ * const imagePart = await createImagePart('./image.png');
+ * ```
+ */
+function createImagePart(source, mimeType) {
+    // If it's a file path, read it
+    if (typeof source === 'string' && !source.startsWith('http') && !source.startsWith('data:')) {
+        if (fs.existsSync(source)) {
+            const buffer = fs.readFileSync(source);
+            const detectedMime = mimeType || detectImageMimeType(source);
+            return {
+                type: 'image',
+                image: buffer,
+                mimeType: detectedMime,
+            };
+        }
+    }
+    return {
+        type: 'image',
+        image: source,
+        mimeType,
+    };
+}
+/**
+ * Create a file part from various sources.
+ *
+ * @example
+ * ```typescript
+ * const filePart = createFilePart('./document.txt', 'text/plain');
+ * ```
+ */
+function createFilePart(source, mimeType, name) {
+    // If it's a file path, read it
+    if (typeof source === 'string' && !source.startsWith('http') && !source.startsWith('data:')) {
+        if (fs.existsSync(source)) {
+            const buffer = fs.readFileSync(source);
+            return {
+                type: 'file',
+                data: buffer,
+                mimeType,
+                name: name || path.basename(source),
+            };
+        }
+    }
+    return {
+        type: 'file',
+        data: source,
+        mimeType,
+        name,
+    };
+}
+/**
+ * Create a PDF part from various sources.
+ *
+ * @example
+ * ```typescript
+ * const pdfPart = createPdfPart('./document.pdf');
+ * ```
+ *
+ * @example With page range
+ * ```typescript
+ * const pdfPart = createPdfPart('./document.pdf', { pages: { start: 1, end: 5 } });
+ * ```
+ */
+function createPdfPart(source, options) {
+    // If it's a file path, read it
+    if (typeof source === 'string' && !source.startsWith('http') && !source.startsWith('data:')) {
+        if (fs.existsSync(source)) {
+            const buffer = fs.readFileSync(source);
+            return {
+                type: 'pdf',
+                data: buffer,
+                pages: options?.pages,
+                textOnly: options?.textOnly,
+            };
+        }
+    }
+    return {
+        type: 'pdf',
+        data: source,
+        pages: options?.pages,
+        textOnly: options?.textOnly,
+    };
+}
+/**
+ * Convert input parts to AI SDK message content format.
+ */
+function toMessageContent(parts) {
+    return parts.map(part => {
+        switch (part.type) {
+            case 'text':
+                return { type: 'text', text: part.text };
+            case 'image':
+                return {
+                    type: 'image',
+                    image: part.image,
+                    mimeType: part.mimeType,
+                };
+            case 'file':
+                return {
+                    type: 'file',
+                    data: part.data,
+                    mimeType: part.mimeType,
+                };
+            case 'pdf':
+                // PDFs are treated as files with application/pdf mime type
+                return {
+                    type: 'file',
+                    data: part.data,
+                    mimeType: 'application/pdf',
+                };
+            default:
+                return part;
+        }
+    });
+}
+/**
+ * Create a multimodal message with text and images.
+ *
+ * @example
+ * ```typescript
+ * const message = createMultimodalMessage(
+ *   'What is in this image?',
+ *   ['https://example.com/image.png']
+ * );
+ * ```
+ */
+function createMultimodalMessage(text, images, role = 'user') {
+    const content = [];
+    // Add images first
+    for (const image of images) {
+        content.push(createImagePart(image));
+    }
+    // Add text
+    content.push(createTextPart(text));
+    return {
+        role,
+        content: toMessageContent(content),
+    };
+}
+/**
+ * Detect image MIME type from file extension.
+ */
+function detectImageMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml',
+        '.bmp': 'image/bmp',
+        '.ico': 'image/x-icon',
+    };
+    return mimeTypes[ext] || 'image/png';
+}
+/**
+ * Convert a base64 string to Uint8Array.
+ */
+function base64ToUint8Array(base64) {
+    // Handle data URLs
+    const base64Data = base64.includes(',') ? base64.split(',')[1] : base64;
+    const binaryString = atob(base64Data);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * Convert Uint8Array to base64 string.
+ */
+function uint8ArrayToBase64(bytes) {
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+/**
+ * Check if a string is a valid URL.
+ */
+function isUrl(str) {
+    try {
+        new URL(str);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a string is a data URL.
+ */
+function isDataUrl(str) {
+    return str.startsWith('data:');
+}

package/dist/ai/nextjs.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Next.js Integration - AI SDK Wrapper
+ *
+ * Provides route handlers and React hooks for Next.js applications.
+ */
+export interface RouteHandlerConfig {
+    /** Agent or handler function */
+    handler: (input: any) => Promise<any>;
+    /** Enable streaming (default: true) */
+    streaming?: boolean;
+    /** Maximum duration in seconds */
+    maxDuration?: number;
+    /** CORS configuration */
+    cors?: boolean | {
+        origin?: string | string[];
+        methods?: string[];
+    };
+}
+/**
+ * Create a Next.js App Router route handler.
+ *
+ * @example app/api/chat/route.ts
+ * ```typescript
+ * import { createRouteHandler } from 'praisonai/ai';
+ * import { streamText } from 'praisonai/ai';
+ *
+ * export const POST = createRouteHandler({
+ *   handler: async (input) => {
+ *     return await streamText({
+ *       model: 'gpt-4o',
+ *       messages: input.messages
+ *     });
+ *   }
+ * });
+ * ```
+ *
+ * @example With Agent
+ * ```typescript
+ * import { createRouteHandler } from 'praisonai/ai';
+ * import { Agent } from 'praisonai';
+ *
+ * const agent = new Agent({ instructions: 'You are helpful' });
+ *
+ * export const POST = createRouteHandler({
+ *   handler: async (input) => {
+ *     return await agent.chat(input.message);
+ *   }
+ * });
+ * ```
+ */
+export declare function createRouteHandler(config: RouteHandlerConfig): (request: Request) => Promise<Response>;
+/**
+ * Create a Next.js Pages Router API handler.
+ *
+ * @example pages/api/chat.ts
+ * ```typescript
+ * import { createPagesHandler } from 'praisonai/ai';
+ * import { streamText } from 'praisonai/ai';
+ *
+ * export default createPagesHandler({
+ *   handler: async (input) => {
+ *     return await streamText({
+ *       model: 'gpt-4o',
+ *       messages: input.messages
+ *     });
+ *   }
+ * });
+ * ```
+ */
+export declare function createPagesHandler(config: RouteHandlerConfig): (req: any, res: any) => Promise<void>;
+/**
+ * Configuration for useChat hook wrapper.
+ */
+export interface UseChatConfig {
+    /** API endpoint */
+    api?: string;
+    /** Initial messages */
+    initialMessages?: Array<{
+        role: string;
+        content: string;
+    }>;
+    /** On error callback */
+    onError?: (error: Error) => void;
+    /** On finish callback */
+    onFinish?: (message: any) => void;
+    /** Custom headers */
+    headers?: Record<string, string>;
+    /** Custom body */
+    body?: Record<string, any>;
+}
+/**
+ * Note: For React hooks (useChat, useCompletion, useObject),
+ * use the AI SDK React package directly:
+ *
+ * ```typescript
+ * import { useChat } from 'ai/react';
+ *
+ * function ChatComponent() {
+ *   const { messages, input, handleInputChange, handleSubmit } = useChat({
+ *     api: '/api/chat'
+ *   });
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit}>
+ *       {messages.map(m => <div key={m.id}>{m.content}</div>)}
+ *       <input value={input} onChange={handleInputChange} />
+ *     </form>
+ *   );
+ * }
+ * ```
+ *
+ * The praisonai package focuses on server-side functionality.
+ * For client-side React hooks, install and use 'ai/react' directly.
+ */
+/**
+ * Export runtime configuration for Next.js edge runtime.
+ */
+export declare const runtime = "edge";
+/**
+ * Export max duration configuration.
+ */
+export declare const maxDuration = 30;

package/dist/ai/nextjs.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * Next.js Integration - AI SDK Wrapper
+ *
+ * Provides route handlers and React hooks for Next.js applications.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxDuration = exports.runtime = void 0;
+exports.createRouteHandler = createRouteHandler;
+exports.createPagesHandler = createPagesHandler;
+/**
+ * Create a Next.js App Router route handler.
+ *
+ * @example app/api/chat/route.ts
+ * ```typescript
+ * import { createRouteHandler } from 'praisonai/ai';
+ * import { streamText } from 'praisonai/ai';
+ *
+ * export const POST = createRouteHandler({
+ *   handler: async (input) => {
+ *     return await streamText({
+ *       model: 'gpt-4o',
+ *       messages: input.messages
+ *     });
+ *   }
+ * });
+ * ```
+ *
+ * @example With Agent
+ * ```typescript
+ * import { createRouteHandler } from 'praisonai/ai';
+ * import { Agent } from 'praisonai';
+ *
+ * const agent = new Agent({ instructions: 'You are helpful' });
+ *
+ * export const POST = createRouteHandler({
+ *   handler: async (input) => {
+ *     return await agent.chat(input.message);
+ *   }
+ * });
+ * ```
+ */
+function createRouteHandler(config) {
+    return async (request) => {
+        try {
+            // Parse request body
+            const body = await request.json();
+            // Execute handler
+            const result = await config.handler(body);
+            // Handle streaming response
+            if (config.streaming !== false && result.textStream) {
+                const stream = new ReadableStream({
+                    async start(controller) {
+                        const encoder = new TextEncoder();
+                        try {
+                            for await (const chunk of result.textStream) {
+                                const data = JSON.stringify({ text: chunk });
+                                controller.enqueue(encoder.encode(`data: ${data}\n\n`));
+                            }
+                            controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+                        }
+                        catch (error) {
+                            controller.error(error);
+                        }
+                        finally {
+                            controller.close();
+                        }
+                    },
+                });
+                return new Response(stream, {
+                    headers: {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        'Connection': 'keep-alive',
+                        ...getCorsHeaders(config.cors),
+                    },
+                });
+            }
+            // Handle toDataStreamResponse if available (AI SDK)
+            if (result.toDataStreamResponse) {
+                return result.toDataStreamResponse();
+            }
+            // Handle regular response
+            const responseData = typeof result === 'string'
+                ? { text: result }
+                : result.text
+                    ? { text: result.text, usage: result.usage }
+                    : result;
+            return new Response(JSON.stringify(responseData), {
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...getCorsHeaders(config.cors),
+                },
+            });
+        }
+        catch (error) {
+            console.error('Route handler error:', error);
+            return new Response(JSON.stringify({ error: error.message || 'Internal server error' }), {
+                status: 500,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...getCorsHeaders(config.cors),
+                },
+            });
+        }
+    };
+}
+/**
+ * Create a Next.js Pages Router API handler.
+ *
+ * @example pages/api/chat.ts
+ * ```typescript
+ * import { createPagesHandler } from 'praisonai/ai';
+ * import { streamText } from 'praisonai/ai';
+ *
+ * export default createPagesHandler({
+ *   handler: async (input) => {
+ *     return await streamText({
+ *       model: 'gpt-4o',
+ *       messages: input.messages
+ *     });
+ *   }
+ * });
+ * ```
+ */
+function createPagesHandler(config) {
+    return async (req, res) => {
+        try {
+            // Set CORS headers
+            if (config.cors) {
+                const headers = getCorsHeaders(config.cors);
+                for (const [key, value] of Object.entries(headers)) {
+                    res.setHeader(key, value);
+                }
+            }
+            // Handle preflight
+            if (req.method === 'OPTIONS') {
+                res.status(204).end();
+                return;
+            }
+            // Execute handler
+            const result = await config.handler(req.body);
+            // Handle streaming response
+            if (config.streaming !== false && result.textStream) {
+                res.setHeader('Content-Type', 'text/event-stream');
+                res.setHeader('Cache-Control', 'no-cache');
+                res.setHeader('Connection', 'keep-alive');
+                for await (const chunk of result.textStream) {
+                    res.write(`data: ${JSON.stringify({ text: chunk })}\n\n`);
+                }
+                res.write('data: [DONE]\n\n');
+                res.end();
+                return;
+            }
+            // Handle regular response
+            const responseData = typeof result === 'string'
+                ? { text: result }
+                : result.text
+                    ? { text: result.text, usage: result.usage }
+                    : result;
+            res.status(200).json(responseData);
+        }
+        catch (error) {
+            console.error('Pages handler error:', error);
+            res.status(500).json({ error: error.message || 'Internal server error' });
+        }
+    };
+}
+/**
+ * Get CORS headers based on configuration.
+ */
+function getCorsHeaders(cors) {
+    if (!cors)
+        return {};
+    const config = typeof cors === 'boolean'
+        ? { origin: '*', methods: ['GET', 'POST', 'OPTIONS'] }
+        : cors;
+    const origin = Array.isArray(config.origin)
+        ? config.origin.join(', ')
+        : (config.origin || '*');
+    return {
+        'Access-Control-Allow-Origin': origin,
+        'Access-Control-Allow-Methods': (config.methods || ['GET', 'POST', 'OPTIONS']).join(', '),
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    };
+}
+/**
+ * Note: For React hooks (useChat, useCompletion, useObject),
+ * use the AI SDK React package directly:
+ *
+ * ```typescript
+ * import { useChat } from 'ai/react';
+ *
+ * function ChatComponent() {
+ *   const { messages, input, handleInputChange, handleSubmit } = useChat({
+ *     api: '/api/chat'
+ *   });
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit}>
+ *       {messages.map(m => <div key={m.id}>{m.content}</div>)}
+ *       <input value={input} onChange={handleInputChange} />
+ *     </form>
+ *   );
+ * }
+ * ```
+ *
+ * The praisonai package focuses on server-side functionality.
+ * For client-side React hooks, install and use 'ai/react' directly.
+ */
+/**
+ * Export runtime configuration for Next.js edge runtime.
+ */
+exports.runtime = 'edge';
+/**
+ * Export max duration configuration.
+ */
+exports.maxDuration = 30;