osborn 0.1.6 → 0.5.3

package/dist/claude-llm.js

@@ -0,0 +1,623 @@
+/**
+ * Claude LLM Wrapper for LiveKit Agents
+ *
+ * Wraps the Claude Agent SDK (@anthropic-ai/claude-agent-sdk) to work
+ * with LiveKit's AgentSession as an LLM provider.
+ *
+ * Flow: User speaks → STT → ClaudeLLM (Agent SDK) → TTS → User hears
+ */
+import { llm, shortuuid, DEFAULT_API_CONNECT_OPTIONS } from '@livekit/agents';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { EventEmitter } from 'events';
+import { saveSessionMetadata } from './config.js';
+import { getResearchSystemPrompt } from './prompts.js';
+/**
+ * Strip markdown formatting for TTS (text-to-speech)
+ * Removes **bold**, ##headers, ```code```, etc. so TTS doesn't read them literally
+ */
+function stripMarkdownForTTS(text) {
+    return text
+        // Remove code blocks (``` ... ```)
+        .replace(/```[\s\S]*?```/g, ' [code block] ')
+        // Remove inline code (` ... `)
+        .replace(/`([^`]+)`/g, '$1')
+        // Remove bold (**text** or __text__)
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/__([^_]+)__/g, '$1')
+        // Remove italic (*text* or _text_) - be careful not to match bullet points
+        .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '$1')
+        .replace(/(?<!_)_([^_]+)_(?!_)/g, '$1')
+        // Remove headers (# ## ### etc)
+        .replace(/^#{1,6}\s+/gm, '')
+        // Remove bullet points but keep content
+        .replace(/^[\s]*[-*+]\s+/gm, '')
+        // Remove numbered lists but keep content
+        .replace(/^[\s]*\d+\.\s+/gm, '')
+        // Remove horizontal rules
+        .replace(/^[-*_]{3,}$/gm, '')
+        // Remove links [text](url) -> text
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        // Remove images ![alt](url)
+        .replace(/!\[([^\]]*)\]\([^)]+\)/g, '$1')
+        // Remove blockquotes
+        .replace(/^>\s+/gm, '')
+        // Clean up multiple spaces/newlines
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/  +/g, ' ')
+        .trim();
+}
+/**
+ * Summarize text for TTS - create short spoken summaries
+ * Full output goes to frontend, this condensed version is spoken
+ */
+function summarizeForTTS(text, maxLength = 500) {
+    // First strip markdown
+    let summary = stripMarkdownForTTS(text);
+    // Remove file paths (keep just filename)
+    summary = summary.replace(/\/[\w\-\.\/]+\/([\w\-\.]+)/g, '$1');
+    // Remove code block placeholders if too many
+    const codeBlockCount = (summary.match(/\[code block\]/g) || []).length;
+    if (codeBlockCount > 1) {
+        summary = summary.replace(/\[code block\]/g, '').replace(/\s+/g, ' ');
+        summary = summary.trim() + ` I've included ${codeBlockCount} code examples.`;
+    }
+    // If still too long, take first sentence(s) up to maxLength
+    if (summary.length > maxLength) {
+        // Try to break at sentence boundaries
+        const sentences = summary.match(/[^.!?]+[.!?]+/g) || [summary];
+        let result = '';
+        for (const sentence of sentences) {
+            if ((result + sentence).length <= maxLength) {
+                result += sentence;
+            }
+            else {
+                break;
+            }
+        }
+        // If no complete sentence fits, truncate with ellipsis
+        if (!result) {
+            result = summary.substring(0, maxLength - 3) + '...';
+        }
+        summary = result.trim();
+    }
+    return summary || 'Done.';
+}
+// Research mode tools — full research capabilities
+const RESEARCH_TOOLS = [
+    'Read', 'Write', 'Edit', 'Glob', 'Grep',
+    'Bash', 'WebSearch', 'WebFetch',
+    'LSP', 'Task', 'TodoWrite',
+];
+/**
+ * Claude LLM - Wraps Claude Agent SDK for LiveKit
+ * Research mode: reads anything, writes only to session workspace
+ */
+export class ClaudeLLM extends llm.LLM {
+    #opts;
+    #sessionId = null;
+    #eventEmitter;
+    #resumeSessionId = null;
+    #continueSession = false;
+    #mcpServers = {};
+    // File checkpointing - stores checkpoint UUIDs for rewinding file changes
+    #checkpoints = [];
+    #latestCheckpoint = null;
+    // Pending permission request (for voice approval flow)
+    #pendingPermission = null;
+    constructor(opts = {}) {
+        super();
+        // Session resume/continue options
+        this.#resumeSessionId = opts.resumeSessionId || null;
+        this.#continueSession = opts.continueSession || false;
+        // MCP servers
+        this.#mcpServers = opts.mcpServers || {};
+        this.#opts = {
+            workingDirectory: opts.workingDirectory || process.cwd(),
+            permissionMode: opts.permissionMode || 'default',
+            allowedTools: opts.allowedTools || RESEARCH_TOOLS,
+            resumeSessionId: this.#resumeSessionId || undefined,
+            continueSession: this.#continueSession,
+            mcpServers: this.#mcpServers,
+        };
+        this.#eventEmitter = opts.eventEmitter || new EventEmitter();
+        console.log('🟠 ClaudeLLM initialized (Research Mode)');
+        console.log(`   📁 Working dir: ${this.#opts.workingDirectory}`);
+        console.log(`   🔧 Allowed tools: ${this.#opts.allowedTools?.join(', ')}`);
+        const mcpCount = Object.keys(this.#mcpServers).length;
+        if (mcpCount > 0) {
+            console.log(`   🔌 MCP servers: ${Object.keys(this.#mcpServers).join(', ')}`);
+        }
+        if (this.#resumeSessionId) {
+            console.log(`   🔄 Resuming session: ${this.#resumeSessionId}`);
+        }
+        else if (this.#continueSession) {
+            console.log(`   🔄 Continuing most recent session`);
+        }
+    }
+    /**
+     * Respond to a pending permission request
+     * Call this after receiving 'permission_request' event
+     */
+    respondToPermission(allow, message) {
+        if (this.#pendingPermission) {
+            const input = this.#pendingPermission.input;
+            if (allow) {
+                this.#pendingPermission.resolve({
+                    behavior: 'allow',
+                    updatedInput: input, // Pass through original input
+                });
+            }
+            else {
+                this.#pendingPermission.resolve({
+                    behavior: 'deny',
+                    message: message || 'User denied permission',
+                });
+            }
+            this.#pendingPermission = null;
+        }
+    }
+    /**
+     * Check if there's a pending permission request
+     */
+    hasPendingPermission() {
+        return this.#pendingPermission !== null;
+    }
+    /**
+     * Get pending permission details
+     */
+    getPendingPermission() {
+        if (this.#pendingPermission) {
+            return { toolName: this.#pendingPermission.toolName, input: this.#pendingPermission.input };
+        }
+        return null;
+    }
+    // ============================================================
+    // MCP SERVER MANAGEMENT - Runtime enable/disable MCP servers
+    // ============================================================
+    /**
+     * Get all currently enabled MCP servers
+     */
+    getMcpServers() {
+        return { ...this.#mcpServers };
+    }
+    /**
+     * Get list of enabled MCP server keys
+     */
+    getEnabledMcpServerKeys() {
+        return Object.keys(this.#mcpServers);
+    }
+    /**
+     * Replace all MCP servers at once
+     */
+    setMcpServers(servers) {
+        this.#mcpServers = { ...servers };
+        this.#opts.mcpServers = this.#mcpServers;
+        console.log(`🔌 MCP servers updated: ${Object.keys(servers).join(', ') || 'none'}`);
+        this.#eventEmitter.emit('mcp_servers_changed', {
+            enabledKeys: Object.keys(this.#mcpServers),
+        });
+    }
+    /**
+     * Enable a single MCP server
+     */
+    enableMcpServer(key, config) {
+        this.#mcpServers[key] = config;
+        this.#opts.mcpServers = this.#mcpServers;
+        console.log(`🔌 MCP server enabled: ${key}`);
+        this.#eventEmitter.emit('mcp_servers_changed', {
+            enabledKeys: Object.keys(this.#mcpServers),
+        });
+    }
+    /**
+     * Disable a single MCP server
+     */
+    disableMcpServer(key) {
+        delete this.#mcpServers[key];
+        this.#opts.mcpServers = this.#mcpServers;
+        console.log(`🔌 MCP server disabled: ${key}`);
+        this.#eventEmitter.emit('mcp_servers_changed', {
+            enabledKeys: Object.keys(this.#mcpServers),
+        });
+    }
+    label() {
+        return 'claude.agent-sdk';
+    }
+    get model() {
+        return this.#opts.model || 'claude-sonnet-4-6';
+    }
+    get sessionId() {
+        return this.#sessionId;
+    }
+    /**
+     * Set session ID to resume a specific conversation
+     * Call this before sending the first message to resume from a previous session
+     */
+    setResumeSessionId(sessionId) {
+        this.#resumeSessionId = sessionId;
+        // CRITICAL: Sync to opts so ClaudeLLMStream.run() picks up the resume ID
+        this.#opts.resumeSessionId = sessionId || undefined;
+        if (sessionId) {
+            console.log(`🔄 Will resume session: ${sessionId}`);
+        }
+    }
+    /**
+     * Reset state for mid-conversation session switch
+     * Clears pending permissions and resets conversation tracking
+     */
+    resetForSessionSwitch() {
+        // Clear any pending permission request from previous session
+        if (this.#pendingPermission) {
+            // Deny the pending permission to clean up
+            this.#pendingPermission.resolve({
+                behavior: 'deny',
+                message: 'Session switched - permission request cancelled',
+            });
+            this.#pendingPermission = null;
+        }
+        // Clear session resume state so new resume can take effect
+        this.#resumeSessionId = null;
+        this.#continueSession = false;
+        this.#opts.resumeSessionId = undefined;
+        this.#opts.continueSession = false;
+        this.#sessionId = null;
+        // Clear checkpoints from previous session
+        this.#checkpoints = [];
+        this.#latestCheckpoint = null;
+        // Emit event for listeners
+        this.#eventEmitter.emit('session_reset');
+        console.log('🔄 LLM state reset for session switch');
+    }
+    /**
+     * Enable "continue" mode - resumes most recent session
+     */
+    setContinueSession(enabled) {
+        this.#continueSession = enabled;
+        this.#opts.continueSession = enabled;
+        if (enabled) {
+            console.log(`🔄 Will continue most recent session`);
+        }
+    }
+    /**
+     * Check if this instance is configured to resume a session
+     */
+    get isResumingSession() {
+        return !!(this.#resumeSessionId || this.#continueSession);
+    }
+    get events() {
+        return this.#eventEmitter;
+    }
+    // ============================================================
+    // FILE CHECKPOINTING - Track and rewind file changes
+    // ============================================================
+    /**
+     * Capture a checkpoint UUID for potential file rewind
+     * Called internally when receiving user message UUIDs from the SDK
+     */
+    captureCheckpoint(checkpointId) {
+        this.#checkpoints.push(checkpointId);
+        this.#latestCheckpoint = checkpointId;
+        console.log(`📍 Checkpoint captured: ${checkpointId.substring(0, 8)}...`);
+        this.#eventEmitter.emit('checkpoint_captured', { checkpointId });
+    }
+    /**
+     * Get the most recent checkpoint UUID
+     * Use this to rewind all file changes back to the beginning
+     */
+    getLatestCheckpoint() {
+        return this.#latestCheckpoint;
+    }
+    /**
+     * Get the first checkpoint UUID (initial state)
+     * Rewinding to this restores all files to their original state
+     */
+    getFirstCheckpoint() {
+        return this.#checkpoints.length > 0 ? this.#checkpoints[0] : null;
+    }
+    /**
+     * Get all captured checkpoint UUIDs
+     * Ordered from oldest to newest
+     */
+    getCheckpoints() {
+        return [...this.#checkpoints];
+    }
+    /**
+     * Clear all captured checkpoints
+     * Call this when starting a new session
+     */
+    clearCheckpoints() {
+        this.#checkpoints = [];
+        this.#latestCheckpoint = null;
+        console.log('🧹 Checkpoints cleared');
+    }
+    /**
+     * Check if checkpoints are available
+     */
+    hasCheckpoints() {
+        return this.#checkpoints.length > 0;
+    }
+    chat({ chatCtx, toolCtx, connOptions = DEFAULT_API_CONNECT_OPTIONS, }) {
+        return new ClaudeLLMStream(this, {
+            chatCtx,
+            toolCtx,
+            connOptions,
+            opts: this.#opts,
+            sessionId: this.#sessionId,
+            onSessionId: (id) => {
+                const isFirst = !this.#sessionId;
+                this.#sessionId = id;
+                if (isFirst) {
+                    this.#eventEmitter.emit('session_id', { sessionId: id });
+                }
+            },
+            eventEmitter: this.#eventEmitter,
+            // Pass checkpoint capture handler
+            onCheckpoint: (checkpointId) => {
+                this.captureCheckpoint(checkpointId);
+            },
+            // Pass permission handler for canUseTool callback
+            onPermissionRequest: (toolName, input) => {
+                return new Promise((resolve) => {
+                    this.#pendingPermission = { toolName, input, resolve };
+                    console.log(`⚠️ Permission request: ${toolName}`);
+                    this.#eventEmitter.emit('permission_request', { toolName, input });
+                });
+            },
+        });
+    }
+}
+/**
+ * Claude LLM Stream - Runs Claude Agent SDK query() and streams results
+ */
+class ClaudeLLMStream extends llm.LLMStream {
+    #opts;
+    #sessionId;
+    #onSessionId;
+    #eventEmitter;
+    #onPermissionRequest;
+    #onCheckpoint;
+    constructor(llmInstance, { chatCtx, toolCtx, connOptions, opts, sessionId, onSessionId, eventEmitter, onCheckpoint, onPermissionRequest, }) {
+        super(llmInstance, { chatCtx, toolCtx, connOptions });
+        this.#opts = opts;
+        this.#sessionId = sessionId;
+        this.#onSessionId = onSessionId;
+        this.#eventEmitter = eventEmitter;
+        this.#onCheckpoint = onCheckpoint;
+        this.#onPermissionRequest = onPermissionRequest;
+    }
+    async run() {
+        const requestId = `claude_${shortuuid()}`;
+        try {
+            // Extract user's message from chat context
+            // ChatContext has .items which are ChatItem[] (ChatMessage | FunctionCall | FunctionCallOutput)
+            const items = this.chatCtx.items;
+            // Find the last user message
+            let userText = '';
+            for (let i = items.length - 1; i >= 0; i--) {
+                const item = items[i];
+                if (item.type === 'message' && item.role === 'user') {
+                    // Content is ChatContent[] = (ImageContent | AudioContent | string)[]
+                    if (Array.isArray(item.content)) {
+                        userText = item.content
+                            .filter((c) => typeof c === 'string')
+                            .join('\n');
+                    }
+                    break;
+                }
+            }
+            if (!userText.trim()) {
+                this.queue.put({
+                    id: requestId,
+                    delta: { role: 'assistant', content: "I didn't catch that. Could you repeat?" },
+                });
+                return;
+            }
+            console.log(`🎤 User: "${userText.substring(0, 100)}${userText.length > 100 ? '...' : ''}"`);
+            // Build Claude Agent SDK options
+            const resumeSessionId = this.#opts.resumeSessionId;
+            const continueSession = this.#opts.continueSession;
+            // Session workspace path for system prompt — only available after SDK assigns a real session ID
+            const sessionId = this.#sessionId || this.#opts.resumeSessionId || null;
+            const workspacePath = sessionId
+                ? (this.#opts.workingDirectory
+                    ? `${this.#opts.workingDirectory}/.osborn/sessions/${sessionId}/`
+                    : `.osborn/sessions/${sessionId}/`)
+                : null;
+            // Build allowedTools with MCP wildcard patterns
+            const mcpKeys = Object.keys(this.#opts.mcpServers || {});
+            const mcpPatterns = mcpKeys.map(key => `mcp__${key}__*`);
+            const allowedTools = [
+                ...(this.#opts.allowedTools || []),
+                ...mcpPatterns,
+            ];
+            const sdkOptions = {
+                cwd: this.#opts.workingDirectory,
+                permissionMode: this.#opts.permissionMode,
+                allowedTools,
+                model: this.#opts.model || 'claude-sonnet-4-6',
+                enableFileCheckpointing: true,
+                extraArgs: { 'replay-user-messages': null },
+                ...(resumeSessionId && { resume: resumeSessionId }),
+                ...(continueSession && !resumeSessionId && { continue: true }),
+                ...(this.#sessionId && !resumeSessionId && !continueSession && { resume: this.#sessionId }),
+                ...(mcpKeys.length > 0 && {
+                    mcpServers: this.#opts.mcpServers,
+                }),
+                ...(mcpKeys.length > 0 && (() => {
+                    for (const [key, cfg] of Object.entries(this.#opts.mcpServers || {})) {
+                        const cfgType = cfg.type || 'stdio';
+                        console.log(`🔌 SDK query MCP: ${key} [type=${cfgType}]`);
+                    }
+                    return {};
+                })()),
+                // Research mode system prompt — always injected
+                systemPrompt: getResearchSystemPrompt(workspacePath),
+                canUseTool: async (toolName, input, _options) => {
+                    // Auto-approve writes to session workspace (but block spec.md and library/ — fast brain manages those)
+                    if (toolName === 'Write' || toolName === 'Edit') {
+                        const filePath = String(input?.file_path || '');
+                        if (filePath.includes('.osborn/sessions/') || filePath.includes('.osborn/research/')) {
+                            // Block writes to spec.md and library/ — the fast brain manages these
+                            const fileName = filePath.split('/').pop() || '';
+                            if (fileName === 'spec.md' || filePath.includes('/library/')) {
+                                console.log(`🚫 Blocked research agent write to managed file: ${filePath} (fast brain handles spec.md and library/)`);
+                                return { behavior: 'deny', message: 'spec.md and library/ are managed by the fast brain sub-agent. Do NOT write to them. Return your findings in your response text — the fast brain will organize them into spec.md and library/ automatically.' };
+                            }
+                            console.log(`✅ Auto-approved ${toolName} to workspace: ${filePath}`);
+                            return { behavior: 'allow', updatedInput: input };
+                        }
+                    }
+                    // Auto-approve AskUserQuestion — research agent should freely ask clarifying questions
+                    if (toolName === 'AskUserQuestion') {
+                        console.log(`✅ Auto-approved ${toolName}`);
+                        return { behavior: 'allow', updatedInput: input };
+                    }
+                    // Auto-deny tools the research agent should never use
+                    if (toolName === 'EnterPlanMode' || toolName === 'ExitPlanMode') {
+                        console.log(`🚫 Auto-denied ${toolName} (not used in research mode)`);
+                        return { behavior: 'deny', message: 'Research mode does not use plan mode. Just proceed with the research directly.' };
+                    }
+                    console.log(`⚠️ Permission needed: ${toolName}`);
+                    return this.#onPermissionRequest(toolName, input);
+                },
+                hooks: {
+                    PreToolUse: [{
+                            matcher: '.*',
+                            hooks: [async (input) => {
+                                    const toolName = input?.tool_name || 'unknown';
+                                    const toolInput = input?.tool_input || {};
+                                    // Safety: block Write/Edit outside session workspace
+                                    if (toolName === 'Write' || toolName === 'Edit') {
+                                        const filePath = String(toolInput.file_path || '');
+                                        if (filePath && !filePath.includes('.osborn/sessions/') && !filePath.includes('.osborn/research/')) {
+                                            console.log(`🚫 Research mode: blocked write to ${filePath}`);
+                                            this.#eventEmitter.emit('tool_blocked', { name: toolName, reason: 'Research mode: writes restricted to session workspace' });
+                                            return { decision: 'block', reason: 'Research mode: write to .osborn/sessions/ only.' };
+                                        }
+                                    }
+                                    console.log(`🔧 Claude: ${toolName}`);
+                                    this.#eventEmitter.emit('tool_use', { name: toolName, input: toolInput });
+                                    return {};
+                                }]
+                        }],
+                    PostToolUse: [{
+                            matcher: '.*',
+                            hooks: [async (input) => {
+                                    const toolName = input?.tool_name || 'unknown';
+                                    const toolInput = input?.tool_input || {};
+                                    const toolResponse = input?.tool_response; // Capture actual tool output for fast brain processing
+                                    console.log(`✅ Done: ${toolName}`);
+                                    this.#eventEmitter.emit('tool_result', { name: toolName, input: toolInput, response: toolResponse });
+                                    return {};
+                                }]
+                        }]
+                }
+            };
+            // Run Claude Agent SDK query() and stream results
+            let hasOutput = false;
+            let fullResponse = ''; // Collect full response for frontend
+            for await (const message of query({ prompt: userText, options: sdkOptions })) {
+                // Capture session ID for context continuity
+                if (message.type === 'system' && message.subtype === 'init') {
+                    // Log MCP server connection status
+                    const mcpServers = message.mcp_servers;
+                    if (mcpServers && Array.isArray(mcpServers)) {
+                        for (const s of mcpServers) {
+                            const status = s.status === 'connected' ? '✅' : '❌';
+                            console.log(`${status} MCP server ${s.name}: ${s.status}`);
+                            if (s.status !== 'connected') {
+                                console.log(`   🔍 MCP error:`, JSON.stringify(s));
+                            }
+                        }
+                    }
+                    const newSessionId = message.session_id;
+                    if (newSessionId) {
+                        this.#onSessionId(newSessionId);
+                        const isNewSession = !this.#sessionId;
+                        if (isNewSession) {
+                            console.log(`📋 New session: ${newSessionId}`);
+                        }
+                        this.#sessionId = newSessionId;
+                        // Save session metadata for new sessions
+                        if (isNewSession && this.#opts.workingDirectory) {
+                            saveSessionMetadata(this.#opts.workingDirectory, {
+                                sessionId: newSessionId,
+                                lastUpdated: new Date().toISOString(),
+                                projectPath: this.#opts.workingDirectory,
+                            });
+                        }
+                        // Verify session resume succeeded (if we requested a specific session)
+                        const requestedResumeId = this.#opts.resumeSessionId;
+                        if (requestedResumeId && newSessionId !== requestedResumeId) {
+                            console.error(`❌ Session resume FAILED: Expected ${requestedResumeId.substring(0, 8)}..., got ${newSessionId.substring(0, 8)}...`);
+                            this.#eventEmitter.emit('session_resume_failed', {
+                                requestedSessionId: requestedResumeId,
+                                actualSessionId: newSessionId,
+                            });
+                        }
+                        else if (requestedResumeId && newSessionId === requestedResumeId) {
+                            console.log(`✅ Session resumed successfully: ${newSessionId.substring(0, 8)}...`);
+                        }
+                    }
+                }
+                // Capture checkpoint UUIDs from user messages (for file rewind capability)
+                // Per SDK docs: user messages include a UUID that can be used as a restore point
+                if (message.type === 'user' && message.uuid) {
+                    const checkpointId = message.uuid;
+                    this.#onCheckpoint(checkpointId);
+                }
+                // Stream text chunks
+                if (message.type === 'assistant' && message.message?.content) {
+                    for (const block of message.message.content) {
+                        if (block.type === 'text' && block.text) {
+                            hasOutput = true;
+                            const rawText = block.text;
+                            // Emit RAW text to frontend (for chat bubbles with full formatting)
+                            this.#eventEmitter.emit('assistant_text', { text: rawText });
+                            // Collect for final TTS summary
+                            fullResponse += rawText + ' ';
+                        }
+                    }
+                }
+                // Final result
+                if (message.type === 'result' && message.result) {
+                    const rawResult = message.result;
+                    // Emit RAW result to frontend
+                    this.#eventEmitter.emit('assistant_result', { text: rawResult });
+                    if (!hasOutput) {
+                        fullResponse = rawResult;
+                        hasOutput = true;
+                    }
+                }
+            }
+            // Send SUMMARIZED output to TTS (spoken)
+            if (hasOutput && fullResponse.trim()) {
+                const ttsText = summarizeForTTS(fullResponse.trim());
+                console.log(`🔊 TTS (summarized ${fullResponse.length} → ${ttsText.length} chars): "${ttsText.substring(0, 80)}..."`);
+                this.queue.put({
+                    id: requestId,
+                    delta: { role: 'assistant', content: ttsText },
+                });
+            }
+            else {
+                this.queue.put({
+                    id: requestId,
+                    delta: { role: 'assistant', content: 'Done.' },
+                });
+            }
+            console.log('✅ Claude response complete');
+        }
+        catch (error) {
+            console.error('❌ Claude Agent SDK error:', error);
+            this.queue.put({
+                id: requestId,
+                delta: { role: 'assistant', content: 'Sorry, I encountered an error.' },
+            });
+        }
+    }
+}
+/**
+ * Create a ClaudeLLM instance
+ */
+export function createClaudeLLM(opts) {
+    return new ClaudeLLM(opts);
+}

package/dist/codex-llm.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Codex LLM Wrapper for LiveKit Agents
+ *
+ * Wraps the Codex Agent SDK (@openai/codex-sdk) to work
+ * with LiveKit's AgentSession as an LLM provider.
+ *
+ * Flow: User speaks → STT → CodexLLM (Agent SDK) → TTS → User hears
+ */
+import { llm, type APIConnectOptions } from '@livekit/agents';
+import { Codex } from '@openai/codex-sdk';
+import { EventEmitter } from 'events';
+export interface CodexLLMOptions {
+    workingDirectory?: string;
+    skipGitRepoCheck?: boolean;
+    /** Event emitter for tool_use, progress updates */
+    eventEmitter?: EventEmitter;
+}
+/**
+ * Codex LLM - Wraps Codex Agent SDK for LiveKit
+ */
+export declare class CodexLLM extends llm.LLM {
+    #private;
+    constructor(opts?: CodexLLMOptions);
+    label(): string;
+    get model(): string;
+    get events(): EventEmitter;
+    get thread(): ReturnType<Codex['startThread']> | null;
+    chat({ chatCtx, toolCtx, connOptions, }: {
+        chatCtx: llm.ChatContext;
+        toolCtx?: llm.ToolContext;
+        connOptions?: APIConnectOptions;
+        parallelToolCalls?: boolean;
+        toolChoice?: llm.ToolChoice;
+        extraKwargs?: Record<string, unknown>;
+    }): llm.LLMStream;
+}
+/**
+ * Create a CodexLLM instance
+ */
+export declare function createCodexLLM(opts?: CodexLLMOptions): CodexLLM;