osborn 0.1.6 → 0.5.3

package/dist/smithery-proxy.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Smithery MCP Proxy — Bridges Smithery cloud MCP servers to Claude Agent SDK.
+ *
+ * The Claude Agent SDK's `type: 'http'` transport has a known bug (#18296, #7290)
+ * where it forces OAuth discovery on all HTTP MCP servers, ignoring configured
+ * auth headers. This proxy bypasses that by:
+ *
+ * 1. Using @smithery/api/mcp createConnection() to get a working transport
+ * 2. Connecting an MCP Client to the remote server via that transport
+ * 3. Listing available tools from the remote server
+ * 4. Creating a local McpServer with proxied tool handlers
+ * 5. Returning it as { type: 'sdk', name, instance } for the Claude Agent SDK
+ *
+ * This means the Claude SDK talks to our local McpServer (in-process, no HTTP),
+ * and our McpServer forwards tool calls to Smithery via the working transport.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SmitheryAuthorizationError } from '@smithery/api/mcp';
+export interface SmitheryProxyConfig {
+    /** Display name for the MCP server (e.g., 'youtube') */
+    name: string;
+    /** Smithery Connect namespace (e.g., 'deer-y2fs') */
+    namespace: string;
+    /** Smithery Connect connection ID (e.g., 'youtube-mcp-sfiorini-TRmB') */
+    connectionId: string;
+    /** Upstream MCP server URL (e.g., 'https://youtube-mcp--sfiorini.run.tools') */
+    mcpUrl?: string;
+}
+/**
+ * Parse a Smithery Connect URL into namespace and connectionId.
+ * URL format: https://api.smithery.ai/connect/{namespace}/{connectionId}/mcp
+ */
+export declare function parseSmitheryUrl(url: string): {
+    namespace: string;
+    connectionId: string;
+} | null;
+/**
+ * Create a proxy MCP server for a Smithery-hosted server.
+ *
+ * Returns a config object compatible with Claude Agent SDK's McpSdkServerConfigWithInstance.
+ * The proxy connects to Smithery via createConnection(), discovers tools, and registers
+ * them on a local McpServer that forwards calls to the remote server.
+ */
+export declare function createSmitheryProxy(config: SmitheryProxyConfig): Promise<{
+    type: 'sdk';
+    name: string;
+    instance: McpServer;
+}>;
+/**
+ * Destroy an active proxy connection and clean up resources.
+ */
+export declare function destroySmitheryProxy(name: string): Promise<void>;
+/**
+ * Check if a URL is a Smithery Connect URL.
+ */
+export declare function isSmitheryUrl(url: string): boolean;
+export { SmitheryAuthorizationError };

package/dist/smithery-proxy.js

@@ -0,0 +1,195 @@
+/**
+ * Smithery MCP Proxy — Bridges Smithery cloud MCP servers to Claude Agent SDK.
+ *
+ * The Claude Agent SDK's `type: 'http'` transport has a known bug (#18296, #7290)
+ * where it forces OAuth discovery on all HTTP MCP servers, ignoring configured
+ * auth headers. This proxy bypasses that by:
+ *
+ * 1. Using @smithery/api/mcp createConnection() to get a working transport
+ * 2. Connecting an MCP Client to the remote server via that transport
+ * 3. Listing available tools from the remote server
+ * 4. Creating a local McpServer with proxied tool handlers
+ * 5. Returning it as { type: 'sdk', name, instance } for the Claude Agent SDK
+ *
+ * This means the Claude SDK talks to our local McpServer (in-process, no HTTP),
+ * and our McpServer forwards tool calls to Smithery via the working transport.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { createConnection, SmitheryAuthorizationError } from '@smithery/api/mcp';
+import { z } from 'zod';
+// Track active proxy connections for cleanup
+const activeProxies = new Map();
+/**
+ * Parse a Smithery Connect URL into namespace and connectionId.
+ * URL format: https://api.smithery.ai/connect/{namespace}/{connectionId}/mcp
+ */
+export function parseSmitheryUrl(url) {
+    const match = url.match(/api\.smithery\.ai\/connect\/([^/]+)\/([^/]+)\/mcp/);
+    if (!match)
+        return null;
+    return { namespace: match[1], connectionId: match[2] };
+}
+/**
+ * Convert a JSON Schema property definition to a Zod type.
+ * Used to register proxy tools with proper parameter schemas so Claude
+ * knows what arguments each tool accepts.
+ */
+function jsonSchemaPropertyToZod(prop, required) {
+    if (!prop)
+        return required ? z.any() : z.any().optional();
+    let zodType;
+    switch (prop.type) {
+        case 'string':
+            zodType = prop.enum ? z.enum(prop.enum) : z.string();
+            break;
+        case 'number':
+        case 'integer':
+            zodType = z.number();
+            break;
+        case 'boolean':
+            zodType = z.boolean();
+            break;
+        case 'array':
+            zodType = z.array(z.any());
+            break;
+        case 'object':
+            zodType = z.record(z.string(), z.any());
+            break;
+        default:
+            zodType = z.any();
+    }
+    if (prop.description) {
+        zodType = zodType.describe(prop.description);
+    }
+    if (!required) {
+        zodType = zodType.optional();
+    }
+    return zodType;
+}
+/**
+ * Convert a JSON Schema object to a Zod raw shape for McpServer.tool() registration.
+ */
+function jsonSchemaToZodShape(inputSchema) {
+    const shape = {};
+    if (!inputSchema?.properties)
+        return shape;
+    const requiredFields = inputSchema.required || [];
+    for (const [propName, propDef] of Object.entries(inputSchema.properties)) {
+        const isRequired = requiredFields.includes(propName);
+        shape[propName] = jsonSchemaPropertyToZod(propDef, isRequired);
+    }
+    return shape;
+}
+/**
+ * Create a proxy MCP server for a Smithery-hosted server.
+ *
+ * Returns a config object compatible with Claude Agent SDK's McpSdkServerConfigWithInstance.
+ * The proxy connects to Smithery via createConnection(), discovers tools, and registers
+ * them on a local McpServer that forwards calls to the remote server.
+ */
+export async function createSmitheryProxy(config) {
+    const { name, namespace, connectionId, mcpUrl } = config;
+    console.log(`🔌 Smithery proxy: connecting to ${name} (${namespace}/${connectionId})...`);
+    // Clean up any existing proxy for this name
+    await destroySmitheryProxy(name);
+    // 1. Get authenticated transport from Smithery SDK
+    const connection = await createConnection({
+        namespace,
+        connectionId,
+        mcpUrl,
+    });
+    console.log(`🔌 Smithery proxy: transport ready for ${name} (url: ${connection.url})`);
+    // 2. Connect MCP Client to the remote server
+    const remoteClient = new Client({ name: `${name}-proxy-client`, version: '1.0.0' }, { capabilities: {} });
+    await remoteClient.connect(connection.transport);
+    console.log(`🔌 Smithery proxy: client connected to ${name}`);
+    // 3. List tools from remote server
+    const toolsList = await remoteClient.listTools();
+    console.log(`🔌 Smithery proxy: ${name} has ${toolsList.tools.length} tools: ${toolsList.tools.map(t => t.name).join(', ')}`);
+    // 4. Create local McpServer and register proxied tools
+    const proxyServer = new McpServer({ name: `${name}-proxy`, version: '1.0.0' }, { capabilities: { tools: {} } });
+    for (const remoteTool of toolsList.tools) {
+        const zodShape = jsonSchemaToZodShape(remoteTool.inputSchema);
+        const hasParams = Object.keys(zodShape).length > 0;
+        if (hasParams) {
+            proxyServer.tool(remoteTool.name, remoteTool.description || '', zodShape, async (args) => {
+                console.log(`🔌 Smithery proxy [${name}]: calling ${remoteTool.name}`);
+                const result = await remoteClient.callTool({
+                    name: remoteTool.name,
+                    arguments: args,
+                });
+                return result;
+            });
+        }
+        else {
+            proxyServer.tool(remoteTool.name, remoteTool.description || '', async () => {
+                console.log(`🔌 Smithery proxy [${name}]: calling ${remoteTool.name}`);
+                const result = await remoteClient.callTool({
+                    name: remoteTool.name,
+                    arguments: {},
+                });
+                return result;
+            });
+        }
+    }
+    // Patch McpServer and its internal Server to allow reconnection across SDK query() calls.
+    // The Claude SDK connects to the McpServer on each query() but never disconnects,
+    // so the second query throws "Already connected to a transport". This patch
+    // auto-closes the previous transport before accepting a new one.
+    // We patch at both levels because McpServer.connect may throw before reaching Server.connect.
+    const proxyServerAny = proxyServer;
+    if (proxyServerAny.connect) {
+        const originalMcpConnect = proxyServerAny.connect.bind(proxyServerAny);
+        proxyServerAny.connect = async function (transport) {
+            if (this._transport) {
+                try {
+                    await this._transport.close();
+                }
+                catch { }
+                this._transport = undefined;
+            }
+            const inner = this._server;
+            if (inner?._transport) {
+                try {
+                    await inner._transport.close();
+                }
+                catch { }
+                inner._transport = undefined;
+            }
+            return originalMcpConnect(transport);
+        };
+    }
+    // Track for cleanup
+    activeProxies.set(name, { client: remoteClient, server: proxyServer });
+    console.log(`✅ Smithery proxy: ${name} ready with ${toolsList.tools.length} tools`);
+    return {
+        type: 'sdk',
+        name,
+        instance: proxyServer,
+    };
+}
+/**
+ * Destroy an active proxy connection and clean up resources.
+ */
+export async function destroySmitheryProxy(name) {
+    const proxy = activeProxies.get(name);
+    if (proxy) {
+        try {
+            await proxy.client.close();
+            await proxy.server.close();
+        }
+        catch (e) {
+            // Ignore cleanup errors
+        }
+        activeProxies.delete(name);
+        console.log(`🔌 Smithery proxy: ${name} destroyed`);
+    }
+}
+/**
+ * Check if a URL is a Smithery Connect URL.
+ */
+export function isSmitheryUrl(url) {
+    return url.includes('api.smithery.ai/connect/');
+}
+export { SmitheryAuthorizationError };

package/dist/status-manager.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Status Manager - Handles background task status and conversational updates
+ *
+ * This module enables a Siri-like experience where:
+ * 1. Background research/tasks run independently
+ * 2. Status updates can be polled via a tool
+ * 3. The voice LLM can naturally ask about progress
+ * 4. Results are delivered conversationally
+ */
+export interface TaskStatus {
+    id: string;
+    type: 'research' | 'execute' | 'search';
+    query: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    result?: string;
+    startedAt: number;
+    completedAt?: number;
+    progress?: number;
+    progressUpdates: string[];
+    lastUpdate?: string;
+}
+export interface StatusUpdate {
+    hasUpdates: boolean;
+    completedTasks: TaskStatus[];
+    runningTasks: TaskStatus[];
+    pendingTasks: TaskStatus[];
+    summary: string;
+}
+export declare class StatusManager {
+    private tasks;
+    private lastCheckTime;
+    private conversationContext;
+    /**
+     * Start tracking a new task (generates new ID)
+     */
+    startTask(type: TaskStatus['type'], query: string): string;
+    /**
+     * Register a task with a specific ID (used when brain already created the task)
+     */
+    registerTask(id: string, type: TaskStatus['type'], query: string): string;
+    /**
+     * Mark a task as running
+     */
+    markRunning(id: string, progress?: number): void;
+    /**
+     * Add a progress update to a running task (for interim voice updates)
+     */
+    addProgressUpdate(id: string, update: string): void;
+    /**
+     * Get the latest unspoken progress update for any running task
+     * Returns null if no new updates available
+     */
+    getLatestProgressUpdate(): {
+        taskId: string;
+        update: string;
+    } | null;
+    /**
+     * Check if there are new progress updates available
+     */
+    hasProgressUpdates(): boolean;
+    /**
+     * Complete a task with result
+     */
+    completeTask(id: string, result: string, success?: boolean): void;
+    /**
+     * Add context from conversation
+     */
+    addContext(context: string): void;
+    /**
+     * Get status update - called by the check_status tool
+     */
+    getStatusUpdate(): StatusUpdate;
+    /**
+     * Check if there are completed tasks to report
+     */
+    hasCompletedTasks(): boolean;
+    /**
+     * Get a brief status for voice announcement
+     */
+    getBriefStatus(): string;
+    /**
+     * Clear completed tasks after they've been reported
+     */
+    clearReportedTasks(): void;
+    /**
+     * Get context summary for the brain
+     */
+    getContextSummary(): string;
+}
+export declare const statusManager: StatusManager;

package/dist/status-manager.js

@@ -0,0 +1,187 @@
+/**
+ * Status Manager - Handles background task status and conversational updates
+ *
+ * This module enables a Siri-like experience where:
+ * 1. Background research/tasks run independently
+ * 2. Status updates can be polled via a tool
+ * 3. The voice LLM can naturally ask about progress
+ * 4. Results are delivered conversationally
+ */
+export class StatusManager {
+    tasks = new Map();
+    lastCheckTime = Date.now();
+    conversationContext = [];
+    /**
+     * Start tracking a new task (generates new ID)
+     */
+    startTask(type, query) {
+        const id = `task-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`;
+        return this.registerTask(id, type, query);
+    }
+    /**
+     * Register a task with a specific ID (used when brain already created the task)
+     */
+    registerTask(id, type, query) {
+        // Skip if task already exists
+        if (this.tasks.has(id)) {
+            console.log(`📋 [Status] Task already registered: ${id}`);
+            return id;
+        }
+        this.tasks.set(id, {
+            id,
+            type,
+            query,
+            status: 'pending',
+            startedAt: Date.now(),
+            progressUpdates: [],
+        });
+        console.log(`📋 [Status] Task registered: ${id} - ${query.substring(0, 50)}...`);
+        return id;
+    }
+    /**
+     * Mark a task as running
+     */
+    markRunning(id, progress) {
+        const task = this.tasks.get(id);
+        if (task) {
+            task.status = 'running';
+            if (progress !== undefined)
+                task.progress = progress;
+        }
+    }
+    /**
+     * Add a progress update to a running task (for interim voice updates)
+     */
+    addProgressUpdate(id, update) {
+        const task = this.tasks.get(id);
+        if (task) {
+            task.progressUpdates.push(update);
+            task.lastUpdate = update;
+            console.log(`📊 [Status] Progress update for ${id.substring(0, 12)}: ${update.substring(0, 60)}...`);
+        }
+    }
+    /**
+     * Get the latest unspoken progress update for any running task
+     * Returns null if no new updates available
+     */
+    getLatestProgressUpdate() {
+        const runningTasks = Array.from(this.tasks.values()).filter(t => t.status === 'running');
+        for (const task of runningTasks) {
+            if (task.lastUpdate) {
+                const update = task.lastUpdate;
+                task.lastUpdate = undefined; // Mark as consumed
+                return { taskId: task.id, update };
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if there are new progress updates available
+     */
+    hasProgressUpdates() {
+        return Array.from(this.tasks.values()).some(t => t.status === 'running' && t.lastUpdate);
+    }
+    /**
+     * Complete a task with result
+     */
+    completeTask(id, result, success = true) {
+        const task = this.tasks.get(id);
+        if (task) {
+            task.status = success ? 'completed' : 'failed';
+            task.result = result;
+            task.completedAt = Date.now();
+            console.log(`✅ [Status] Task ${success ? 'completed' : 'failed'}: ${id}`);
+        }
+    }
+    /**
+     * Add context from conversation
+     */
+    addContext(context) {
+        this.conversationContext.push(context);
+        if (this.conversationContext.length > 10) {
+            this.conversationContext.shift();
+        }
+    }
+    /**
+     * Get status update - called by the check_status tool
+     */
+    getStatusUpdate() {
+        const now = Date.now();
+        const timeSinceLastCheck = now - this.lastCheckTime;
+        this.lastCheckTime = now;
+        const allTasks = Array.from(this.tasks.values());
+        const completedTasks = allTasks.filter(t => t.status === 'completed' && t.completedAt && t.completedAt > now - 60000 // Last minute
+        );
+        const runningTasks = allTasks.filter(t => t.status === 'running');
+        const pendingTasks = allTasks.filter(t => t.status === 'pending');
+        // Generate natural summary
+        let summary = '';
+        if (completedTasks.length > 0) {
+            const results = completedTasks.map(t => {
+                const shortResult = t.result?.substring(0, 200) || 'No result';
+                return `${t.query}: ${shortResult}`;
+            }).join('\n');
+            summary = `I found some results:\n${results}`;
+        }
+        else if (runningTasks.length > 0) {
+            const tasks = runningTasks.map(t => t.query).join(', ');
+            const elapsed = Math.round((now - runningTasks[0].startedAt) / 1000);
+            summary = `Still working on: ${tasks} (${elapsed}s elapsed)`;
+        }
+        else if (pendingTasks.length > 0) {
+            summary = `${pendingTasks.length} tasks queued, starting soon...`;
+        }
+        else {
+            summary = "No active tasks. What would you like me to work on?";
+        }
+        return {
+            hasUpdates: completedTasks.length > 0,
+            completedTasks,
+            runningTasks,
+            pendingTasks,
+            summary,
+        };
+    }
+    /**
+     * Check if there are completed tasks to report
+     */
+    hasCompletedTasks() {
+        return Array.from(this.tasks.values()).some(t => t.status === 'completed' &&
+            t.completedAt &&
+            t.completedAt > this.lastCheckTime);
+    }
+    /**
+     * Get a brief status for voice announcement
+     */
+    getBriefStatus() {
+        const running = Array.from(this.tasks.values()).filter(t => t.status === 'running');
+        const completed = Array.from(this.tasks.values()).filter(t => t.status === 'completed');
+        if (running.length > 0) {
+            return `Working on ${running.length} task${running.length > 1 ? 's' : ''}...`;
+        }
+        if (completed.length > 0) {
+            return `I have ${completed.length} result${completed.length > 1 ? 's' : ''} ready.`;
+        }
+        return "Ready for your next request.";
+    }
+    /**
+     * Clear completed tasks after they've been reported
+     */
+    clearReportedTasks() {
+        const now = Date.now();
+        for (const [id, task] of this.tasks.entries()) {
+            // Remove tasks that completed more than 2 minutes ago
+            if (task.status === 'completed' && task.completedAt && task.completedAt < now - 120000) {
+                this.tasks.delete(id);
+            }
+        }
+    }
+    /**
+     * Get context summary for the brain
+     */
+    getContextSummary() {
+        return this.conversationContext.slice(-5).join(' | ');
+    }
+}
+// Singleton instance
+export const statusManager = new StatusManager();

package/dist/voice-io.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Voice I/O Module
+ * Handles STT (Speech-to-Text), TTS (Text-to-Speech), and Realtime model creation
+ *
+ * Supports two modes:
+ * - Direct mode: STT (Deepgram) → Claude Agent SDK → TTS (Deepgram)
+ * - Realtime mode: OpenAI/Gemini native speech-to-speech models
+ */
+import * as deepgram from '@livekit/agents-plugin-deepgram';
+import * as google from '@livekit/agents-plugin-google';
+import * as openai from '@livekit/agents-plugin-openai';
+import * as silero from '@livekit/agents-plugin-silero';
+import type { RealtimeConfig } from './config.js';
+export interface STTConfig {
+    provider: 'deepgram' | 'groq-whisper' | 'openai-whisper';
+    model?: string;
+    language?: string;
+}
+export interface TTSConfig {
+    provider: 'gemini' | 'openai' | 'elevenlabs' | 'deepgram';
+    voice?: string;
+    model?: string;
+}
+export interface VoiceIOConfig {
+    stt: STTConfig;
+    tts: TTSConfig;
+}
+/**
+ * Create STT (Speech-to-Text) instance based on config
+ * Note: Gemini STT is not available in Node.js, using Deepgram as default
+ */
+export declare function createSTT(config: STTConfig): deepgram.STT | openai.STT;
+/**
+ * Create TTS (Text-to-Speech) instance based on config
+ * Using Gemini TTS as default (cheaper, good quality)
+ */
+export declare function createTTS(config: TTSConfig): any;
+/**
+ * Create VAD (Voice Activity Detection) for turn detection
+ *
+ * Tuned to prevent:
+ * - "Audio file is too short" errors from STT (OpenAI requires >= 0.1s)
+ * - Split sentences when user pauses briefly mid-speech
+ * - False triggers from ambient noise
+ */
+export declare function createVAD(): Promise<silero.VAD>;
+/**
+ * Default voice I/O configuration
+ * Uses Deepgram STT (fast, accurate) + Deepgram TTS (fast, good)
+ */
+export declare const DEFAULT_VOICE_IO_CONFIG: VoiceIOConfig;
+export interface RealtimeModelConfig {
+    provider: 'openai' | 'gemini';
+    openaiVoice?: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer';
+    openaiModel?: string;
+    geminiVoice?: 'Puck' | 'Charon' | 'Kore' | 'Fenrir' | 'Aoede';
+    geminiModel?: string;
+    instructions?: string;
+}
+/**
+ * Create Realtime Model for native speech-to-speech
+ * Supports OpenAI Realtime API and Gemini Live API
+ *
+ * Note: Instructions are passed to voice.Agent, not to the RealtimeModel
+ */
+export declare function createRealtimeModel(config: RealtimeModelConfig): google.beta.realtime.RealtimeModel | openai.realtime.RealtimeModel;
+/**
+ * Create realtime model from config
+ */
+export declare function createRealtimeModelFromConfig(realtimeConfig: RealtimeConfig, instructions?: string): google.beta.realtime.RealtimeModel | openai.realtime.RealtimeModel;