overai 1.4.0

package/dist/ai/server.js

@@ -0,0 +1,336 @@
+"use strict";
+/**
+ * Server Adapters - AI SDK Wrapper
+ *
+ * Provides server adapters for HTTP, Express, Hono, Fastify, and Nest.js.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpHandler = createHttpHandler;
+exports.createExpressHandler = createExpressHandler;
+exports.createHonoHandler = createHonoHandler;
+exports.createFastifyHandler = createFastifyHandler;
+exports.createNestHandler = createNestHandler;
+/**
+ * Create an HTTP server handler.
+ *
+ * @example
+ * ```typescript
+ * import { createServer } from 'http';
+ * import { createHttpHandler } from 'praisonai/ai';
+ *
+ * const handler = createHttpHandler({
+ *   handler: async (input) => {
+ *     return await generateText({ model: 'gpt-4o', prompt: input.prompt });
+ *   }
+ * });
+ *
+ * createServer(handler.handle).listen(3000);
+ * ```
+ */
+function createHttpHandler(config) {
+    return {
+        handle: async (req, res) => {
+            try {
+                // Set CORS headers
+                if (config.cors) {
+                    setCorsHeaders(res, config.cors);
+                }
+                // Handle preflight
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(204);
+                    res.end();
+                    return;
+                }
+                // Parse body
+                const body = config.bodyParser
+                    ? await config.bodyParser(req)
+                    : await parseJsonBody(req);
+                // Execute handler
+                const result = await config.handler(body);
+                // Format response
+                const response = config.responseFormatter
+                    ? config.responseFormatter(result)
+                    : result;
+                // Send response
+                if (config.streaming && result.textStream) {
+                    res.writeHead(200, {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        '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();
+                }
+                else {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(response));
+                }
+            }
+            catch (error) {
+                if (config.onError) {
+                    config.onError(error, req, res);
+                }
+                else {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: error.message }));
+                }
+            }
+        },
+    };
+}
+/**
+ * Create an Express handler.
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createExpressHandler } from 'praisonai/ai';
+ *
+ * const app = express();
+ * app.use(express.json());
+ *
+ * app.post('/api/chat', createExpressHandler({
+ *   handler: async (input) => {
+ *     return await streamText({ model: 'gpt-4o', messages: input.messages });
+ *   }
+ * }));
+ * ```
+ */
+function createExpressHandler(config) {
+    return async (req, res) => {
+        try {
+            // Set CORS headers
+            if (config.cors) {
+                setCorsHeaders(res, config.cors);
+            }
+            // Execute handler
+            const result = await config.handler(req.body);
+            // Format response
+            const response = config.responseFormatter
+                ? config.responseFormatter(result)
+                : result;
+            // Send response
+            if (config.streaming && 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();
+            }
+            else {
+                res.json(response);
+            }
+        }
+        catch (error) {
+            if (config.onError) {
+                config.onError(error, req, res);
+            }
+            else {
+                res.status(500).json({ error: error.message });
+            }
+        }
+    };
+}
+/**
+ * Create a Hono handler.
+ *
+ * @example
+ * ```typescript
+ * import { Hono } from 'hono';
+ * import { createHonoHandler } from 'praisonai/ai';
+ *
+ * const app = new Hono();
+ *
+ * app.post('/api/chat', createHonoHandler({
+ *   handler: async (input) => {
+ *     return await streamText({ model: 'gpt-4o', messages: input.messages });
+ *   }
+ * }));
+ * ```
+ */
+function createHonoHandler(config) {
+    return async (c) => {
+        try {
+            const body = await c.req.json();
+            const result = await config.handler(body);
+            const response = config.responseFormatter
+                ? config.responseFormatter(result)
+                : result;
+            if (config.streaming && result.textStream) {
+                const stream = new ReadableStream({
+                    async start(controller) {
+                        for await (const chunk of result.textStream) {
+                            controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify({ text: chunk })}\n\n`));
+                        }
+                        controller.enqueue(new TextEncoder().encode('data: [DONE]\n\n'));
+                        controller.close();
+                    },
+                });
+                return new Response(stream, {
+                    headers: {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        'Connection': 'keep-alive',
+                    },
+                });
+            }
+            return c.json(response);
+        }
+        catch (error) {
+            return c.json({ error: error.message }, 500);
+        }
+    };
+}
+/**
+ * Create a Fastify handler.
+ *
+ * @example
+ * ```typescript
+ * import Fastify from 'fastify';
+ * import { createFastifyHandler } from 'praisonai/ai';
+ *
+ * const fastify = Fastify();
+ *
+ * fastify.post('/api/chat', createFastifyHandler({
+ *   handler: async (input) => {
+ *     return await streamText({ model: 'gpt-4o', messages: input.messages });
+ *   }
+ * }));
+ * ```
+ */
+function createFastifyHandler(config) {
+    return async (request, reply) => {
+        try {
+            const result = await config.handler(request.body);
+            const response = config.responseFormatter
+                ? config.responseFormatter(result)
+                : result;
+            if (config.streaming && result.textStream) {
+                reply.raw.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                });
+                for await (const chunk of result.textStream) {
+                    reply.raw.write(`data: ${JSON.stringify({ text: chunk })}\n\n`);
+                }
+                reply.raw.write('data: [DONE]\n\n');
+                reply.raw.end();
+            }
+            else {
+                reply.send(response);
+            }
+        }
+        catch (error) {
+            if (config.onError) {
+                config.onError(error, request, reply);
+            }
+            else {
+                reply.status(500).send({ error: error.message });
+            }
+        }
+    };
+}
+/**
+ * Create a Nest.js controller method decorator config.
+ *
+ * @example
+ * ```typescript
+ * import { Controller, Post, Body, Res } from '@nestjs/common';
+ * import { createNestHandler } from 'praisonai/ai';
+ *
+ * @Controller('api')
+ * export class ChatController {
+ *   private handler = createNestHandler({
+ *     handler: async (input) => {
+ *       return await streamText({ model: 'gpt-4o', messages: input.messages });
+ *     }
+ *   });
+ *
+ *   @Post('chat')
+ *   async chat(@Body() body: any, @Res() res: any) {
+ *     return this.handler(body, res);
+ *   }
+ * }
+ * ```
+ */
+function createNestHandler(config) {
+    return async (body, res) => {
+        try {
+            const result = await config.handler(body);
+            const response = config.responseFormatter
+                ? config.responseFormatter(result)
+                : result;
+            if (config.streaming && 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();
+            }
+            else {
+                res.json(response);
+            }
+        }
+        catch (error) {
+            if (config.onError) {
+                config.onError(error, body, res);
+            }
+            else {
+                res.status(500).json({ error: error.message });
+            }
+        }
+    };
+}
+/**
+ * Parse JSON body from HTTP request.
+ */
+async function parseJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', chunk => body += chunk);
+        req.on('end', () => {
+            try {
+                resolve(body ? JSON.parse(body) : {});
+            }
+            catch (e) {
+                reject(new Error('Invalid JSON body'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+/**
+ * Set CORS headers on response.
+ */
+function setCorsHeaders(res, cors) {
+    const config = typeof cors === 'boolean'
+        ? { origin: '*', methods: ['GET', 'POST', 'OPTIONS'], headers: ['Content-Type'] }
+        : cors;
+    const origin = Array.isArray(config.origin) ? config.origin.join(', ') : (config.origin || '*');
+    if (res.setHeader) {
+        res.setHeader('Access-Control-Allow-Origin', origin);
+        res.setHeader('Access-Control-Allow-Methods', (config.methods || ['GET', 'POST', 'OPTIONS']).join(', '));
+        res.setHeader('Access-Control-Allow-Headers', (config.headers || ['Content-Type']).join(', '));
+        if (config.credentials) {
+            res.setHeader('Access-Control-Allow-Credentials', 'true');
+        }
+    }
+    else if (res.set) {
+        res.set('Access-Control-Allow-Origin', origin);
+        res.set('Access-Control-Allow-Methods', (config.methods || ['GET', 'POST', 'OPTIONS']).join(', '));
+        res.set('Access-Control-Allow-Headers', (config.headers || ['Content-Type']).join(', '));
+        if (config.credentials) {
+            res.set('Access-Control-Allow-Credentials', 'true');
+        }
+    }
+}

package/dist/ai/speech.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Speech & Transcription - AI SDK v6 Compatible
+ *
+ * Provides speech generation and transcription utilities.
+ */
+export interface GenerateSpeechOptions {
+    /** Model to use (e.g., 'openai/tts-1', 'elevenlabs/eleven_multilingual_v2') */
+    model: string;
+    /** Text to convert to speech */
+    text: string;
+    /** Voice to use */
+    voice?: string;
+    /** Speed multiplier (0.25 to 4.0) */
+    speed?: number;
+    /** Output format */
+    format?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
+    /** Additional provider options */
+    providerOptions?: Record<string, unknown>;
+}
+export interface GenerateSpeechResult {
+    /** Audio data as Uint8Array */
+    audio: Uint8Array;
+    /** Audio format */
+    format: string;
+    /** Duration in seconds (if available) */
+    durationSeconds?: number;
+    /** Provider metadata */
+    providerMetadata?: Record<string, unknown>;
+}
+export interface TranscribeOptions {
+    /** Model to use (e.g., 'openai/whisper-1') */
+    model: string;
+    /** Audio data - can be Uint8Array, ArrayBuffer, Buffer, base64 string, or URL */
+    audio: Uint8Array | ArrayBuffer | Buffer | string;
+    /** Language hint (ISO 639-1 code) */
+    language?: string;
+    /** Prompt to guide transcription */
+    prompt?: string;
+    /** Temperature for sampling */
+    temperature?: number;
+    /** Output format */
+    format?: 'json' | 'text' | 'srt' | 'verbose_json' | 'vtt';
+    /** Additional provider options */
+    providerOptions?: Record<string, unknown>;
+}
+export interface TranscribeResult {
+    /** Transcribed text */
+    text: string;
+    /** Detected language */
+    language?: string;
+    /** Duration in seconds */
+    durationSeconds?: number;
+    /** Segments with timestamps */
+    segments?: TranscriptionSegment[];
+    /** Provider metadata */
+    providerMetadata?: Record<string, unknown>;
+}
+export interface TranscriptionSegment {
+    /** Segment ID */
+    id: number;
+    /** Start time in seconds */
+    start: number;
+    /** End time in seconds */
+    end: number;
+    /** Segment text */
+    text: string;
+    /** Confidence score */
+    confidence?: number;
+}
+/**
+ * Generate speech from text.
+ *
+ * @example
+ * ```typescript
+ * const result = await generateSpeech({
+ *   model: 'openai/tts-1',
+ *   text: 'Hello, world!',
+ *   voice: 'alloy'
+ * });
+ *
+ * // Save to file
+ * await fs.writeFile('speech.mp3', result.audio);
+ * ```
+ */
+export declare function generateSpeech(options: GenerateSpeechOptions): Promise<GenerateSpeechResult>;
+/**
+ * Transcribe audio to text.
+ *
+ * @example
+ * ```typescript
+ * const result = await transcribe({
+ *   model: 'openai/whisper-1',
+ *   audio: await fs.readFile('audio.mp3')
+ * });
+ *
+ * console.log(result.text);
+ * ```
+ */
+export declare function transcribe(options: TranscribeOptions): Promise<TranscribeResult>;
+/**
+ * Available speech models.
+ */
+export declare const SPEECH_MODELS: {
+    openai: {
+        'tts-1': {
+            description: string;
+            voices: string[];
+        };
+        'tts-1-hd': {
+            description: string;
+            voices: string[];
+        };
+    };
+    elevenlabs: {
+        eleven_multilingual_v2: {
+            description: string;
+            voices: never[];
+        };
+        eleven_turbo_v2: {
+            description: string;
+            voices: never[];
+        };
+    };
+};
+/**
+ * Available transcription models.
+ */
+export declare const TRANSCRIPTION_MODELS: {
+    openai: {
+        'whisper-1': {
+            description: string;
+            languages: string;
+        };
+    };
+};