pi-harness-runtime 1.1.337 → 1.1.339

package/packages/voice-api/dist/provider.js

@@ -0,0 +1,154 @@
+/**
+ * Whisper Provider - Abstract interface for speech-to-text
+ */
+/**
+ * Create OpenAI Whisper provider
+ */
+export function createOpenAIProvider(apiKey) {
+    return new OpenAIProvider(apiKey);
+}
+/**
+ * Create Replicate Whisper provider
+ */
+export function createReplicateProvider(apiToken) {
+    return new ReplicateProvider(apiToken);
+}
+/**
+ * OpenAI Whisper Provider
+ */
+class OpenAIProvider {
+    name = 'openai';
+    apiKey;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    isConfigured() {
+        return Boolean(this.apiKey);
+    }
+    async transcribe(options) {
+        const startTime = Date.now();
+        try {
+            // Dynamic import to avoid hard dependency
+            const OpenAI = (await import('openai')).default;
+            const openai = new OpenAI({ apiKey: this.apiKey });
+            let audioData;
+            if (options.audioBuffer) {
+                audioData = Buffer.from(options.audioBuffer);
+            }
+            else if (options.audioUrl) {
+                // Fetch audio from URL
+                const response = await fetch(options.audioUrl);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch audio: ${response.status}`);
+                }
+                const arrayBuffer = await response.arrayBuffer();
+                audioData = Buffer.from(arrayBuffer);
+            }
+            else {
+                throw new Error('No audio data provided');
+            }
+            const result = await openai.audio.transcriptions.create({
+                file: audioData,
+                model: options.model || 'whisper-1',
+                language: options.language,
+                response_format: 'verbose_json',
+            });
+            return {
+                text: result.text,
+                language: result.language || options.language,
+                duration: result.duration,
+                timestamp: new Date().toISOString(),
+                provider: 'openai',
+            };
+        }
+        catch (error) {
+            return {
+                text: '',
+                timestamp: new Date().toISOString(),
+                provider: 'openai',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}
+/**
+ * Replicate Whisper Provider
+ */
+class ReplicateProvider {
+    name = 'replicate';
+    apiToken;
+    constructor(apiToken) {
+        this.apiToken = apiToken;
+    }
+    isConfigured() {
+        return Boolean(this.apiToken);
+    }
+    async transcribe(options) {
+        const startTime = Date.now();
+        try {
+            // Get audio data
+            let audioData;
+            if (options.audioBuffer) {
+                audioData = options.audioBuffer;
+            }
+            else if (options.audioUrl) {
+                const response = await fetch(options.audioUrl);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch audio: ${response.status}`);
+                }
+                const arrayBuffer = await response.arrayBuffer();
+                audioData = new Uint8Array(arrayBuffer);
+            }
+            else {
+                throw new Error('No audio data provided');
+            }
+            // Convert to base64 for Replicate
+            const base64 = btoa(String.fromCharCode(...audioData));
+            const dataUrl = `data:audio/wav;base64,${base64}`;
+            // Call Replicate API
+            const response = await fetch('https://api.replicate.com/v1/predictions', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Token ${this.apiToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    version: 'e39e7d2f3c2b7a7d8c9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b',
+                    input: {
+                        audio: dataUrl,
+                        model: options.model || 'large-v3',
+                    },
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Replicate API error: ${response.status}`);
+            }
+            const prediction = await response.json();
+            // Poll for completion
+            let result = prediction;
+            while (result.status !== 'succeeded' && result.status !== 'failed') {
+                await new Promise(r => setTimeout(r, 1000));
+                const pollResponse = await fetch(`https://api.replicate.com/v1/predictions/${result.id}`, {
+                    headers: { 'Authorization': `Token ${this.apiToken}` },
+                });
+                result = await pollResponse.json();
+            }
+            if (result.status === 'failed') {
+                throw new Error(result.error || 'Transcription failed');
+            }
+            return {
+                text: result.output,
+                timestamp: new Date().toISOString(),
+                provider: 'replicate',
+            };
+        }
+        catch (error) {
+            return {
+                text: '',
+                timestamp: new Date().toISOString(),
+                provider: 'replicate',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}

package/packages/voice-api/dist/telegram.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Telegram Voice Handler
+ *
+ * Handles voice messages from Telegram bots.
+ */
+import type { TranscriptionResult } from './types.js';
+import { VoiceTranscriber } from './transcriber.js';
+/**
+ * Telegram voice message from bot update
+ */
+export interface TelegramVoiceUpdate {
+    update_id: number;
+    message?: {
+        message_id: number;
+        voice?: {
+            file_id: string;
+            duration: number;
+            mime_type: string;
+            file_size?: number;
+        };
+        chat: {
+            id: number;
+            type: string;
+        };
+    };
+}
+/**
+ * Telegram Voice Handler options
+ */
+export interface TelegramVoiceHandlerOptions {
+    /** Telegram bot token */
+    botToken: string;
+    /** Voice transcriber instance */
+    transcriber: VoiceTranscriber;
+    /** Base URL for Telegram API */
+    apiBase?: string;
+    /** Callback when voice is transcribed */
+    onTranscribed?: (chatId: string, text: string, result: TranscriptionResult) => Promise<void>;
+    /** Callback on error */
+    onError?: (chatId: string, error: Error) => void;
+}
+/**
+ * Telegram Voice Handler
+ *
+ * Processes voice messages from Telegram and transcribes them.
+ */
+export declare class TelegramVoiceHandler {
+    private botToken;
+    private transcriber;
+    private apiBase;
+    private onTranscribed?;
+    private onError?;
+    constructor(options: TelegramVoiceHandlerOptions);
+    /**
+     * Handle incoming update from Telegram webhook
+     */
+    handleUpdate(update: TelegramVoiceUpdate): Promise<{
+        success: boolean;
+        text?: string;
+        error?: string;
+    }>;
+    /**
+     * Get file path from Telegram
+     */
+    private getFilePath;
+    /**
+     * Send text response to chat
+     */
+    sendMessage(chatId: string, text: string): Promise<boolean>;
+    /**
+     * Create webhook handler middleware
+     */
+    createWebhookHandler(): (request: Request) => Promise<Response>;
+}

package/packages/voice-api/dist/telegram.js

@@ -0,0 +1,119 @@
+/**
+ * Telegram Voice Handler
+ *
+ * Handles voice messages from Telegram bots.
+ */
+/**
+ * Telegram Voice Handler
+ *
+ * Processes voice messages from Telegram and transcribes them.
+ */
+export class TelegramVoiceHandler {
+    botToken;
+    transcriber;
+    apiBase;
+    onTranscribed;
+    onError;
+    constructor(options) {
+        this.botToken = options.botToken;
+        this.transcriber = options.transcriber;
+        this.apiBase = options.apiBase || 'https://api.telegram.org';
+        this.onTranscribed = options.onTranscribed;
+        this.onError = options.onError;
+    }
+    /**
+     * Handle incoming update from Telegram webhook
+     */
+    async handleUpdate(update) {
+        const message = update.message;
+        const voice = message?.voice;
+        if (!message || !voice) {
+            return { success: false, error: 'No voice message in update' };
+        }
+        const chatId = String(message.chat.id);
+        try {
+            // Get file path from Telegram
+            const filePath = await this.getFilePath(voice.file_id);
+            if (!filePath) {
+                return { success: false, error: 'Failed to get file path' };
+            }
+            // Construct download URL
+            const fileUrl = `${this.apiBase}/file/bot${this.botToken}/${filePath}`;
+            // Transcribe
+            const result = await this.transcriber.transcribe({ audioUrl: fileUrl });
+            if (result.error) {
+                this.onError?.(chatId, new Error(result.error));
+                return { success: false, error: result.error };
+            }
+            // Notify callback
+            await this.onTranscribed?.(chatId, result.text, result);
+            return { success: true, text: result.text };
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.onError?.(chatId, err);
+            return { success: false, error: err.message };
+        }
+    }
+    /**
+     * Get file path from Telegram
+     */
+    async getFilePath(fileId) {
+        try {
+            const response = await fetch(`${this.apiBase}/bot${this.botToken}/getFile?file_id=${fileId}`);
+            if (!response.ok) {
+                return null;
+            }
+            const data = await response.json();
+            return data.result?.file_path || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Send text response to chat
+     */
+    async sendMessage(chatId, text) {
+        try {
+            const response = await fetch(`${this.apiBase}/bot${this.botToken}/sendMessage`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    chat_id: chatId,
+                    text,
+                    parse_mode: 'Markdown',
+                }),
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Create webhook handler middleware
+     */
+    createWebhookHandler() {
+        return async (request) => {
+            try {
+                const update = await request.json();
+                const result = await this.handleUpdate(update);
+                if (result.success && result.text) {
+                    // Optionally echo back the transcription
+                    // await this.sendMessage(String(update.message?.chat.id), `🎤: ${result.text}`);
+                }
+                return new Response(JSON.stringify({ ok: true }), {
+                    status: 200,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            catch (error) {
+                return new Response(JSON.stringify({ ok: false, error: String(error) }), {
+                    status: 500,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+        };
+    }
+}

package/packages/voice-api/dist/transcriber.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Voice Transcriber - Main interface for speech-to-text
+ */
+import type { TranscriptionResult, TranscribeOptions, VoiceApiConfig } from './types.js';
+import { WhisperProvider } from './provider.js';
+/**
+ * Voice Transcriber
+ *
+ * Main interface for transcribing voice messages to text.
+ * Supports multiple providers (OpenAI, Replicate).
+ */
+export declare class VoiceTranscriber {
+    private providers;
+    private defaultProvider;
+    constructor(config?: VoiceApiConfig);
+    /**
+     * Check if transcriber is configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Get configured providers
+     */
+    getProviders(): string[];
+    /**
+     * Get default provider
+     */
+    getDefaultProvider(): string | null;
+    /**
+     * Transcribe audio to text
+     */
+    transcribe(options: TranscribeOptions): Promise<TranscriptionResult>;
+    /**
+     * Add a provider
+     */
+    addProvider(name: string, provider: WhisperProvider): void;
+    /**
+     * Remove a provider
+     */
+    removeProvider(name: string): boolean;
+    /**
+     * Set default provider
+     */
+    setDefaultProvider(name: string): boolean;
+}
+/**
+ * Create a VoiceTranscriber from environment variables
+ */
+export declare function createFromEnv(): VoiceTranscriber;

package/packages/voice-api/dist/transcriber.js

@@ -0,0 +1,118 @@
+/**
+ * Voice Transcriber - Main interface for speech-to-text
+ */
+import { createOpenAIProvider, createReplicateProvider } from './provider.js';
+/**
+ * Voice Transcriber
+ *
+ * Main interface for transcribing voice messages to text.
+ * Supports multiple providers (OpenAI, Replicate).
+ */
+export class VoiceTranscriber {
+    providers = new Map();
+    defaultProvider = '';
+    constructor(config = {}) {
+        // Initialize OpenAI provider
+        if (config.openaiApiKey) {
+            const provider = createOpenAIProvider(config.openaiApiKey);
+            this.providers.set('openai', provider);
+            this.defaultProvider = 'openai';
+        }
+        // Initialize Replicate provider
+        if (config.replicateApiToken) {
+            const provider = createReplicateProvider(config.replicateApiToken);
+            this.providers.set('replicate', provider);
+            if (!this.defaultProvider) {
+                this.defaultProvider = 'replicate';
+            }
+        }
+        // Set default provider from config
+        if (config.provider && this.providers.has(config.provider)) {
+            this.defaultProvider = config.provider;
+        }
+    }
+    /**
+     * Check if transcriber is configured
+     */
+    isConfigured() {
+        return this.providers.size > 0;
+    }
+    /**
+     * Get configured providers
+     */
+    getProviders() {
+        return Array.from(this.providers.keys());
+    }
+    /**
+     * Get default provider
+     */
+    getDefaultProvider() {
+        return this.defaultProvider || null;
+    }
+    /**
+     * Transcribe audio to text
+     */
+    async transcribe(options) {
+        const providerName = options.provider || this.defaultProvider;
+        if (!providerName) {
+            return {
+                text: '',
+                timestamp: new Date().toISOString(),
+                provider: 'openai',
+                error: 'No provider configured',
+            };
+        }
+        const provider = this.providers.get(providerName);
+        if (!provider) {
+            return {
+                text: '',
+                timestamp: new Date().toISOString(),
+                provider: providerName,
+                error: `Provider ${providerName} not configured`,
+            };
+        }
+        return provider.transcribe(options);
+    }
+    /**
+     * Add a provider
+     */
+    addProvider(name, provider) {
+        this.providers.set(name, provider);
+        if (!this.defaultProvider) {
+            this.defaultProvider = name;
+        }
+    }
+    /**
+     * Remove a provider
+     */
+    removeProvider(name) {
+        const deleted = this.providers.delete(name);
+        if (this.defaultProvider === name) {
+            this.defaultProvider = this.providers.keys().next().value || '';
+        }
+        return deleted;
+    }
+    /**
+     * Set default provider
+     */
+    setDefaultProvider(name) {
+        if (this.providers.has(name)) {
+            this.defaultProvider = name;
+            return true;
+        }
+        return false;
+    }
+}
+/**
+ * Create a VoiceTranscriber from environment variables
+ */
+export function createFromEnv() {
+    // SAFETY: globalThis.process is always available in Node.js
+    const env = globalThis.process;
+    const envVars = env?.env ?? {};
+    return new VoiceTranscriber({
+        openaiApiKey: envVars.OPENAI_API_KEY,
+        replicateApiToken: envVars.REPLICATE_API_TOKEN,
+        provider: envVars.VOICE_PROVIDER || 'openai',
+    });
+}

package/packages/voice-api/dist/types.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Voice API Types
+ */
+/**
+ * Transcription result from Whisper
+ */
+export interface TranscriptionResult {
+    /** The transcribed text */
+    text: string;
+    /** Language detected (ISO 639-1) */
+    language?: string;
+    /** Duration in seconds */
+    duration?: number;
+    /** Confidence score (0-1) */
+    confidence?: number;
+    /** Timestamp of transcription */
+    timestamp: string;
+    /** Provider used (openai/replicate) */
+    provider: 'openai' | 'replicate';
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Voice message from messaging platforms
+ */
+export interface VoiceMessage {
+    /** Unique message ID */
+    id: string;
+    /** Platform source (telegram/line) */
+    platform: 'telegram' | 'line';
+    /** Chat/user ID */
+    chatId: string;
+    /** Audio file URL or path */
+    audioUrl: string;
+    /** Duration in seconds */
+    duration?: number;
+    /** MIME type */
+    mimeType: string;
+    /** File size in bytes */
+    fileSize?: number;
+    /** Raw platform-specific data */
+    raw?: unknown;
+}
+/**
+ * Voice API configuration
+ */
+export interface VoiceApiConfig {
+    /** OpenAI API key (for Whisper) */
+    openaiApiKey?: string;
+    /** Replicate API token (alternative) */
+    replicateApiToken?: string;
+    /** Default provider */
+    provider?: 'openai' | 'replicate';
+    /** Model to use */
+    model?: string;
+    /** Language hint (ISO 639-1) */
+    language?: string;
+    /** Temperature for generation */
+    temperature?: number;
+}
+/**
+ * Transcribe options
+ */
+export interface TranscribeOptions {
+    /** Audio URL or file path (required if no audioBuffer) */
+    audioUrl?: string;
+    /** Audio as Buffer (Uint8Array for cross-platform) */
+    audioBuffer?: Uint8Array;
+    /** Language hint */
+    language?: string;
+    /** Model override */
+    model?: string;
+    /** Provider override */
+    provider?: 'openai' | 'replicate';
+}

package/packages/voice-api/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Voice API Types
+ */
+export {};

package/packages/voice-api/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@pi-harness/voice-api",
+  "version": "1.1.339",
+  "type": "module",
+  "description": "Voice-to-text API using Whisper for Telegram and LINE integration",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "openai": "^4.77.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.2"
+  }
+}

package/packages/voice-api/src/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Voice API - Speech-to-Text using Whisper
+ * 
+ * Supports:
+ * - OpenAI Whisper API (primary)
+ * - Replicate Whisper (alternative)
+ * 
+ * Used by Telegram and LINE voice message handlers.
+ */
+
+export { WhisperProvider } from './provider.js';
+export { VoiceTranscriber } from './transcriber.js';
+export { TelegramVoiceHandler } from './telegram.js';
+export { LineVoiceHandler } from './line.js';
+export type { TranscriptionResult, VoiceMessage } from './types.js';