overai 1.4.0

package/dist/ai/speech.js

@@ -0,0 +1,296 @@
+"use strict";
+/**
+ * Speech & Transcription - AI SDK v6 Compatible
+ *
+ * Provides speech generation and transcription utilities.
+ */
+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.TRANSCRIPTION_MODELS = exports.SPEECH_MODELS = void 0;
+exports.generateSpeech = generateSpeech;
+exports.transcribe = transcribe;
+// ============================================================================
+// Speech Generation
+// ============================================================================
+/**
+ * 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);
+ * ```
+ */
+async function generateSpeech(options) {
+    const [provider, model] = parseModel(options.model);
+    switch (provider) {
+        case 'openai':
+            return generateSpeechOpenAI(model, options);
+        case 'elevenlabs':
+            return generateSpeechElevenLabs(model, options);
+        default:
+            // Try AI SDK
+            return generateSpeechAISDK(options);
+    }
+}
+async function generateSpeechOpenAI(model, options) {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+        throw new Error('OPENAI_API_KEY environment variable is required for OpenAI speech generation');
+    }
+    const response = await fetch('https://api.openai.com/v1/audio/speech', {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            model: model || 'tts-1',
+            input: options.text,
+            voice: options.voice || 'alloy',
+            speed: options.speed,
+            response_format: options.format || 'mp3',
+        }),
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`OpenAI speech generation failed: ${response.status} - ${error}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return {
+        audio: new Uint8Array(arrayBuffer),
+        format: options.format || 'mp3',
+    };
+}
+async function generateSpeechElevenLabs(model, options) {
+    const apiKey = process.env.ELEVENLABS_API_KEY;
+    if (!apiKey) {
+        throw new Error('ELEVENLABS_API_KEY environment variable is required for ElevenLabs speech generation');
+    }
+    const voiceId = options.voice || '21m00Tcm4TlvDq8ikWAM'; // Default: Rachel
+    const response = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`, {
+        method: 'POST',
+        headers: {
+            'xi-api-key': apiKey,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            text: options.text,
+            model_id: model || 'eleven_multilingual_v2',
+            voice_settings: {
+                stability: 0.5,
+                similarity_boost: 0.75,
+            },
+        }),
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`ElevenLabs speech generation failed: ${response.status} - ${error}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return {
+        audio: new Uint8Array(arrayBuffer),
+        format: 'mp3',
+    };
+}
+async function generateSpeechAISDK(options) {
+    try {
+        const ai = await Promise.resolve().then(() => __importStar(require('ai')));
+        if ('generateSpeech' in ai) {
+            const result = await ai.generateSpeech(options);
+            return {
+                audio: result.audio,
+                format: options.format || 'mp3',
+                durationSeconds: result.durationSeconds,
+                providerMetadata: result.providerMetadata,
+            };
+        }
+    }
+    catch {
+        // AI SDK not available or doesn't support speech
+    }
+    throw new Error(`Speech generation not supported for model: ${options.model}`);
+}
+// ============================================================================
+// Transcription
+// ============================================================================
+/**
+ * Transcribe audio to text.
+ *
+ * @example
+ * ```typescript
+ * const result = await transcribe({
+ *   model: 'openai/whisper-1',
+ *   audio: await fs.readFile('audio.mp3')
+ * });
+ *
+ * console.log(result.text);
+ * ```
+ */
+async function transcribe(options) {
+    const [provider, model] = parseModel(options.model);
+    switch (provider) {
+        case 'openai':
+            return transcribeOpenAI(model, options);
+        default:
+            // Try AI SDK
+            return transcribeAISDK(options);
+    }
+}
+async function transcribeOpenAI(model, options) {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+        throw new Error('OPENAI_API_KEY environment variable is required for OpenAI transcription');
+    }
+    // Convert audio to appropriate format
+    let audioData;
+    if (typeof options.audio === 'string') {
+        if (options.audio.startsWith('http')) {
+            const response = await fetch(options.audio);
+            audioData = new Uint8Array(await response.arrayBuffer());
+        }
+        else {
+            // Assume base64
+            audioData = Uint8Array.from(atob(options.audio), c => c.charCodeAt(0));
+        }
+    }
+    else if (options.audio instanceof ArrayBuffer) {
+        audioData = new Uint8Array(options.audio);
+    }
+    else {
+        audioData = options.audio;
+    }
+    const formData = new FormData();
+    formData.append('file', new Blob([audioData.buffer]), 'audio.mp3');
+    formData.append('model', model || 'whisper-1');
+    if (options.language)
+        formData.append('language', options.language);
+    if (options.prompt)
+        formData.append('prompt', options.prompt);
+    if (options.temperature)
+        formData.append('temperature', String(options.temperature));
+    formData.append('response_format', options.format === 'verbose_json' ? 'verbose_json' : 'json');
+    const response = await fetch('https://api.openai.com/v1/audio/transcriptions', {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+        },
+        body: formData,
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`OpenAI transcription failed: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    if (options.format === 'verbose_json') {
+        return {
+            text: data.text,
+            language: data.language,
+            durationSeconds: data.duration,
+            segments: data.segments?.map((s, i) => ({
+                id: i,
+                start: s.start,
+                end: s.end,
+                text: s.text,
+            })),
+        };
+    }
+    return {
+        text: data.text,
+    };
+}
+async function transcribeAISDK(options) {
+    try {
+        const ai = await Promise.resolve().then(() => __importStar(require('ai')));
+        if ('transcribe' in ai) {
+            const result = await ai.transcribe(options);
+            return {
+                text: result.text,
+                language: result.language,
+                durationSeconds: result.durationSeconds,
+                segments: result.segments,
+                providerMetadata: result.providerMetadata,
+            };
+        }
+    }
+    catch {
+        // AI SDK not available or doesn't support transcription
+    }
+    throw new Error(`Transcription not supported for model: ${options.model}`);
+}
+// ============================================================================
+// Utilities
+// ============================================================================
+function parseModel(model) {
+    if (model.includes('/')) {
+        const [provider, ...rest] = model.split('/');
+        return [provider.toLowerCase(), rest.join('/')];
+    }
+    // Infer provider from model name
+    if (model.startsWith('tts-') || model.startsWith('whisper')) {
+        return ['openai', model];
+    }
+    if (model.startsWith('eleven_')) {
+        return ['elevenlabs', model];
+    }
+    return ['openai', model];
+}
+/**
+ * Available speech models.
+ */
+exports.SPEECH_MODELS = {
+    openai: {
+        'tts-1': { description: 'Standard TTS model', voices: ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'] },
+        'tts-1-hd': { description: 'High-definition TTS model', voices: ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'] },
+    },
+    elevenlabs: {
+        'eleven_multilingual_v2': { description: 'Multilingual model', voices: [] },
+        'eleven_turbo_v2': { description: 'Fast model', voices: [] },
+    },
+};
+/**
+ * Available transcription models.
+ */
+exports.TRANSCRIPTION_MODELS = {
+    openai: {
+        'whisper-1': { description: 'Whisper large-v2 model', languages: 'auto-detect' },
+    },
+};

package/dist/ai/telemetry.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Telemetry - AI SDK v6 Compatible Telemetry
+ *
+ * Provides telemetry settings compatible with AI SDK v6's experimental_telemetry.
+ * Optionally bridges to OpenTelemetry for production observability.
+ */
+/**
+ * Telemetry settings compatible with AI SDK v6.
+ */
+export interface TelemetrySettings {
+    /** Enable telemetry (default: false) */
+    isEnabled?: boolean;
+    /** Record input data (default: true when enabled) */
+    recordInputs?: boolean;
+    /** Record output data (default: true when enabled) */
+    recordOutputs?: boolean;
+    /** Function identifier for grouping telemetry */
+    functionId?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** Custom tracer (OpenTelemetry compatible) */
+    tracer?: Tracer;
+}
+/**
+ * OpenTelemetry-compatible tracer interface.
+ */
+export interface Tracer {
+    startSpan(name: string, options?: SpanOptions): Span;
+    startActiveSpan<T>(name: string, fn: (span: Span) => T): T;
+    startActiveSpan<T>(name: string, options: SpanOptions, fn: (span: Span) => T): T;
+}
+/**
+ * OpenTelemetry-compatible span interface.
+ */
+export interface Span {
+    setAttribute(key: string, value: string | number | boolean): this;
+    setAttributes(attributes: Record<string, string | number | boolean>): this;
+    addEvent(name: string, attributes?: Record<string, unknown>): this;
+    setStatus(status: SpanStatus): this;
+    end(): void;
+    recordException(exception: Error): void;
+    isRecording(): boolean;
+}
+export interface SpanOptions {
+    attributes?: Record<string, string | number | boolean>;
+    kind?: SpanKind;
+}
+export type SpanKind = 'internal' | 'server' | 'client' | 'producer' | 'consumer';
+export interface SpanStatus {
+    code: 'ok' | 'error' | 'unset';
+    message?: string;
+}
+/**
+ * Configure global telemetry settings.
+ *
+ * @example
+ * ```typescript
+ * configureTelemetry({
+ *   isEnabled: true,
+ *   functionId: 'my-app',
+ *   metadata: { version: '1.0.0' }
+ * });
+ * ```
+ */
+export declare function configureTelemetry(settings: TelemetrySettings): void;
+/**
+ * Get current telemetry settings.
+ */
+export declare function getTelemetrySettings(): TelemetrySettings;
+/**
+ * Enable telemetry globally.
+ */
+export declare function enableTelemetry(options?: Omit<TelemetrySettings, 'isEnabled'>): void;
+/**
+ * Disable telemetry globally.
+ */
+export declare function disableTelemetry(): void;
+/**
+ * Check if telemetry is enabled.
+ */
+export declare function isTelemetryEnabled(): boolean;
+/**
+ * Initialize OpenTelemetry integration.
+ *
+ * @example
+ * ```typescript
+ * import { trace } from '@opentelemetry/api';
+ *
+ * initOpenTelemetry({
+ *   tracer: trace.getTracer('praisonai'),
+ *   serviceName: 'my-ai-app'
+ * });
+ * ```
+ */
+export declare function initOpenTelemetry(options?: {
+    tracer?: Tracer;
+    serviceName?: string;
+    endpoint?: string;
+}): Promise<void>;
+/**
+ * Get the OpenTelemetry tracer.
+ */
+export declare function getTracer(): Tracer | null;
+/**
+ * Create a span for an AI operation.
+ *
+ * @example
+ * ```typescript
+ * const span = createAISpan('generateText', {
+ *   model: 'gpt-4o',
+ *   provider: 'openai'
+ * });
+ *
+ * try {
+ *   const result = await generateText({ ... });
+ *   span.setAttribute('tokens', result.usage.totalTokens);
+ *   span.setStatus({ code: 'ok' });
+ * } catch (error) {
+ *   span.recordException(error);
+ *   span.setStatus({ code: 'error', message: error.message });
+ * } finally {
+ *   span.end();
+ * }
+ * ```
+ */
+export declare function createAISpan(name: string, attributes?: Record<string, string | number | boolean>): Span;
+/**
+ * Execute a function within a span.
+ */
+export declare function withSpan<T>(name: string, attributes: Record<string, string | number | boolean>, fn: (span: Span) => Promise<T>): Promise<T>;
+/**
+ * Create middleware that adds telemetry to AI SDK calls.
+ */
+export declare function createTelemetryMiddleware(settings?: TelemetrySettings): any;
+export interface TelemetryEvent {
+    name: string;
+    timestamp: number;
+    attributes: Record<string, unknown>;
+    spanId?: string;
+    traceId?: string;
+}
+/**
+ * Record a telemetry event.
+ */
+export declare function recordEvent(name: string, attributes?: Record<string, unknown>): void;
+/**
+ * Get recorded events.
+ */
+export declare function getEvents(): TelemetryEvent[];
+/**
+ * Clear recorded events.
+ */
+export declare function clearEvents(): void;
+/**
+ * Create telemetry settings for AI SDK calls.
+ */
+export declare function createTelemetrySettings(options?: {
+    functionId?: string;
+    metadata?: Record<string, unknown>;
+    recordInputs?: boolean;
+    recordOutputs?: boolean;
+}): TelemetrySettings | undefined;