osborn 0.1.6 → 0.5.3

package/dist/codex-llm.js

@@ -0,0 +1,144 @@
+/**
+ * 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, shortuuid, DEFAULT_API_CONNECT_OPTIONS } from '@livekit/agents';
+import { Codex } from '@openai/codex-sdk';
+import { EventEmitter } from 'events';
+/**
+ * Codex LLM - Wraps Codex Agent SDK for LiveKit
+ */
+export class CodexLLM extends llm.LLM {
+    #opts;
+    #codex;
+    #thread = null;
+    #eventEmitter;
+    constructor(opts = {}) {
+        super();
+        this.#opts = {
+            workingDirectory: opts.workingDirectory || process.cwd(),
+            skipGitRepoCheck: opts.skipGitRepoCheck ?? true,
+        };
+        this.#codex = new Codex();
+        this.#eventEmitter = opts.eventEmitter || new EventEmitter();
+        console.log('🟣 CodexLLM initialized (Codex Agent SDK)');
+        console.log(`   📁 Working dir: ${this.#opts.workingDirectory}`);
+    }
+    label() {
+        return 'codex.agent-sdk';
+    }
+    get model() {
+        return 'codex';
+    }
+    get events() {
+        return this.#eventEmitter;
+    }
+    get thread() {
+        return this.#thread;
+    }
+    chat({ chatCtx, toolCtx, connOptions = DEFAULT_API_CONNECT_OPTIONS, }) {
+        return new CodexLLMStream(this, {
+            chatCtx,
+            toolCtx,
+            connOptions,
+            opts: this.#opts,
+            codex: this.#codex,
+            thread: this.#thread,
+            onThread: (t) => { this.#thread = t; },
+            eventEmitter: this.#eventEmitter,
+        });
+    }
+}
+/**
+ * Codex LLM Stream - Runs Codex Agent SDK and streams results
+ */
+class CodexLLMStream extends llm.LLMStream {
+    #opts;
+    #codex;
+    #thread;
+    #onThread;
+    #eventEmitter;
+    constructor(llmInstance, { chatCtx, toolCtx, connOptions, opts, codex, thread, onThread, eventEmitter, }) {
+        super(llmInstance, { chatCtx, toolCtx, connOptions });
+        this.#opts = opts;
+        this.#codex = codex;
+        this.#thread = thread;
+        this.#onThread = onThread;
+        this.#eventEmitter = eventEmitter;
+    }
+    async run() {
+        const requestId = `codex_${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 ? '...' : ''}"`);
+            // Create or reuse thread
+            if (!this.#thread) {
+                console.log('🆕 Starting new Codex thread');
+                this.#thread = this.#codex.startThread({
+                    workingDirectory: this.#opts.workingDirectory,
+                    skipGitRepoCheck: this.#opts.skipGitRepoCheck,
+                });
+                this.#onThread(this.#thread);
+            }
+            else {
+                console.log('🔄 Continuing Codex thread');
+            }
+            // Run Codex and get result
+            const turn = await this.#thread.run(userText);
+            // Emit tool usage events
+            if (turn.items && turn.items.length > 0) {
+                for (const item of turn.items) {
+                    console.log(`🔧 Codex: ${item.type || 'action'}`);
+                    this.#eventEmitter.emit('tool_use', item);
+                }
+            }
+            // Send response to TTS
+            const result = turn.finalResponse || 'Done.';
+            this.queue.put({
+                id: requestId,
+                delta: { role: 'assistant', content: result },
+            });
+            console.log('✅ Codex response complete');
+        }
+        catch (error) {
+            console.error('❌ Codex Agent SDK error:', error);
+            this.queue.put({
+                id: requestId,
+                delta: { role: 'assistant', content: 'Sorry, I encountered an error.' },
+            });
+        }
+    }
+}
+/**
+ * Create a CodexLLM instance
+ */
+export function createCodexLLM(opts) {
+    return new CodexLLM(opts);
+}

package/dist/config.d.ts

@@ -1,9 +1,55 @@
 import type { McpServerConfig } from './claude-handler.js';
+export type VoiceMode = 'direct' | 'realtime';
+export type EditMode = 'read-only' | 'edit';
+export type AgentMode = 'plan' | 'execute' | 'research';
+export type RealtimeProvider = 'openai' | 'gemini';
+export type STTProvider = 'deepgram' | 'groq-whisper' | 'openai-whisper';
+export type TTSProvider = 'gemini' | 'openai' | 'elevenlabs' | 'deepgram';
+export type BridgeLLMProvider = 'gemini-pro' | 'gpt-4o';
+export interface RealtimeConfig {
+    provider?: RealtimeProvider;
+    openaiVoice?: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer';
+    openaiModel?: string;
+    geminiVoice?: 'Aoede' | 'Charon' | 'Kore' | 'Fenrir' | 'Puck';
+    geminiModel?: string;
+}
+export interface DirectConfig {
+    stt?: {
+        provider?: STTProvider;
+        model?: string;
+        language?: string;
+    };
+    tts?: {
+        provider?: TTSProvider;
+        model?: string;
+        voice?: string;
+    };
+}
+export interface PipelinedConfig {
+    stt?: {
+        provider?: STTProvider;
+        model?: string;
+        language?: string;
+    };
+    llm?: {
+        provider?: BridgeLLMProvider;
+        model?: string;
+    };
+    tts?: {
+        provider?: TTSProvider;
+        model?: string;
+        voice?: string;
+    };
+}
 export interface OsbornConfig {
     workingDirectory?: string;
     mcpServers?: Record<string, McpServerConfigYaml>;
-    defaultProvider?: 'openai' | 'gemini';
+    defaultProvider?: 'gemini' | 'openai';
     defaultCodingAgent?: 'claude' | 'codex';
+    voiceMode?: VoiceMode;
+    realtime?: RealtimeConfig;
+    direct?: DirectConfig;
+    pipelined?: PipelinedConfig;
 }
 interface McpServerConfigYaml {
     enabled?: boolean;
@@ -13,6 +59,32 @@ interface McpServerConfigYaml {
     url?: string;
     transport?: 'stdio' | 'sse' | 'http';
 }
+export interface McpCatalogEntry {
+    name: string;
+    description: string;
+    serverKey: string;
+    category: 'code' | 'web' | 'data' | 'utility';
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    requiredEnvVars?: string[];
+    transport?: 'stdio' | 'http' | 'sse';
+    url?: string;
+    headers?: Record<string, string>;
+    requiredHeaders?: string[];
+}
+export declare const MCP_CATALOG: McpCatalogEntry[];
+export interface McpServerStatus {
+    serverKey: string;
+    name: string;
+    description: string;
+    category: McpCatalogEntry['category'];
+    transport: 'stdio' | 'http' | 'sse';
+    enabled: boolean;
+    available: boolean;
+    missingEnvVars?: string[];
+    source: 'catalog' | 'config';
+}
 /**
  * Load configuration from ~/.osborn/config.yaml
  * Creates default config if it doesn't exist
@@ -26,8 +98,162 @@ export declare function getMcpServers(config: OsbornConfig): Record<string, McpS
  * Get list of enabled MCP server names (for display)
  */
 export declare function getEnabledMcpServerNames(config: OsbornConfig): string[];
+/**
+ * Get pipelined config with defaults merged
+ */
+export declare function getPipelinedConfig(config: OsbornConfig): Required<PipelinedConfig>;
+/**
+ * Get voice mode from config
+ */
+export declare function getVoiceMode(config: OsbornConfig): VoiceMode;
+/**
+ * Get realtime config with defaults merged
+ */
+export declare function getRealtimeConfig(config: OsbornConfig): Required<RealtimeConfig>;
+/**
+ * Get direct mode config with defaults merged
+ */
+export declare function getDirectConfig(config: OsbornConfig): Required<DirectConfig>;
 /**
  * Save config to file
  */
 export declare function saveConfig(config: OsbornConfig): void;
+/**
+ * Get MCP tool patterns for allowedTools based on configured servers
+ * Returns wildcard patterns like 'mcp__github__.*' for each enabled server
+ */
+export declare function getMcpToolPatterns(config: OsbornConfig): string[];
+/**
+ * Get MCP server status list — merges catalog entries with user config.
+ * Checks env var availability so the UI can show disabled toggles.
+ */
+export declare function getMcpServerStatusList(config: OsbornConfig): McpServerStatus[];
+/**
+ * Build McpServerConfig records for a given set of enabled keys.
+ * Merges catalog defaults with user config overrides.
+ */
+export declare function buildMcpServersForKeys(config: OsbornConfig, enabledKeys: string[]): Record<string, McpServerConfig>;
+/**
+ * Session metadata for listing available sessions
+ */
+export interface SessionInfo {
+    sessionId: string;
+    projectPath: string;
+    timestamp: Date;
+    lastMessage?: string;
+    messageCount: number;
+    filePath: string;
+}
+/**
+ * Get the .claude projects directory
+ */
+export declare function getClaudeProjectsDir(): string;
+/**
+ * Get the session storage directory for a specific project
+ */
+export declare function getSessionDir(projectPath: string): string;
+/**
+ * List all available sessions for the current project
+ */
+export declare function listSessions(projectPath?: string): Promise<SessionInfo[]>;
+/**
+ * Get the most recent session ID for the current project
+ */
+export declare function getMostRecentSessionId(projectPath?: string): Promise<string | null>;
+/**
+ * Check if a session exists
+ */
+export declare function sessionExists(sessionId: string, projectPath?: string): boolean;
+/**
+ * Session summary for context briefing when switching sessions
+ */
+export interface SessionSummary {
+    sessionId: string;
+    messageCount: number;
+    lastMessages: string[];
+}
+/**
+ * Get a summary of a session for context briefing
+ * Extracts last few messages and mode info for realtime agent
+ */
+export declare function getSessionSummary(sessionId: string, projectPath: string): Promise<SessionSummary | null>;
+/**
+ * Represents a single exchange in the conversation
+ */
+export interface ConversationExchange {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp?: string;
+}
+/**
+ * Get conversation history from a session file
+ * Returns the last N exchanges (user/assistant pairs)
+ */
+export declare function getConversationHistory(sessionId: string, projectPath: string, limit?: number): Promise<ConversationExchange[]>;
+/**
+ * Session metadata for persisting mode state
+ */
+export interface SessionMetadata {
+    sessionId: string;
+    lastUpdated: string;
+    projectPath: string;
+    messageCount?: number;
+    lastMessages?: string[];
+    summary?: string;
+    researchDir?: string;
+    researchArtifacts?: string[];
+    agentMode?: AgentMode;
+    editMode?: EditMode;
+}
+/**
+ * Save metadata for a specific session
+ */
+export declare function saveSessionMetadata(projectPath: string, metadata: SessionMetadata): void;
+/**
+ * Get metadata for a specific session
+ */
+export declare function getSessionMetadataById(projectPath: string, sessionId: string): SessionMetadata | null;
+/**
+ * Get metadata for the most recent session
+ */
+export declare function getMostRecentSessionMetadata(projectPath: string): Promise<SessionMetadata | null>;
+/**
+ * Delete metadata for a specific session
+ */
+export declare function deleteSessionMetadata(projectPath: string, sessionId: string): void;
+/**
+ * Clean up metadata for sessions that no longer exist
+ */
+export declare function cleanupOrphanedMetadata(projectPath: string): Promise<number>;
+export declare function getSessionWorkspace(projectPath: string, sessionId: string): string;
+export declare function ensureSessionWorkspace(projectPath: string, sessionId: string): string;
+/**
+ * Rename a session workspace folder to match the SDK session ID.
+ * Returns the new path, or null if rename was not needed/possible.
+ */
+export declare function renameSessionWorkspace(projectPath: string, oldSessionId: string, newSessionId: string): string | null;
+export declare function getResearchDir(projectPath: string, sessionId: string): string;
+export declare function ensureResearchDir(projectPath: string, sessionId: string): string;
+/**
+ * Read the session spec document (spec.md) if it exists
+ */
+export declare function readSessionSpec(projectPath: string, sessionId: string): string | null;
+/**
+ * List files in the session library directory
+ */
+export declare function listLibraryFiles(projectPath: string, sessionId: string): string[];
+export interface ResearchArtifact {
+    fileName: string;
+    filePath: string;
+    type: 'plan' | 'diagram' | 'notes' | 'image' | 'summary' | 'html' | 'other';
+    size: number;
+    updatedAt: string;
+}
+export declare function listResearchArtifacts(projectPath: string, sessionId: string): ResearchArtifact[];
+/**
+ * List artifacts in a session workspace.
+ * When sessionId is provided, scans the per-session folder (.osborn/sessions/{sessionId}/).
+ * Without sessionId, falls back to the flat .osborn/sessions/ directory (legacy).
+ */
+export declare function listWorkspaceArtifacts(projectPath: string, sessionId?: string): ResearchArtifact[];
 export {};