@probelabs/probe-chat 0.6.0-rc191 → 0.6.0-rc198

package/ChatSessionManager.js

@@ -63,15 +63,18 @@ export class ChatSessionManager {
   }
   
   /**
-   * Initialize the ChatSessionManager by loading history
+   * Initialize the ChatSessionManager by initializing ProbeAgent and loading history
    * This must be called before using chat()
    */
   async initialize() {
     if (this._ready) return; // Already initialized
-    
+
+    // Initialize ProbeAgent (handles API key detection and CLI fallback)
+    await this.agent.initialize();
+
     await this.loadHistory();
     this._ready = true;
-    
+
     if (this.debug) {
       console.log(`[ChatSessionManager] Initialized session ${this.sessionId} with ${this.agent.history.length} messages from storage`);
     }

package/index.js

@@ -346,12 +346,6 @@ export function main() {
     process.env.PORT = options.port;
   }
 
-  // Check for API keys
-  const anthropicApiKey = process.env.ANTHROPIC_API_KEY;
-  const openaiApiKey = process.env.OPENAI_API_KEY;
-  const googleApiKey = process.env.GOOGLE_API_KEY;
-  const hasApiKeys = !!(anthropicApiKey || openaiApiKey || googleApiKey);
-
   // --- Bash Configuration Processing ---
   let bashConfig = null;
   if (options.enableBash) {
@@ -406,16 +400,13 @@ export function main() {
 
   // --- Web Mode (check before non-interactive to override) ---
   if (options.web) {
-    if (!hasApiKeys) {
-      // Use logWarn for web mode warning
-      logWarn(chalk.yellow('Warning: No API key provided. The web interface will show instructions on how to set up API keys.'));
-    }
-    // Import and start web server
+    // Note: API key / CLI availability is checked lazily in ProbeAgent.initialize()
+    // when the first chat message is sent. This allows fallback to Claude Code or Codex CLI.
     import('./webServer.js')
       .then(async module => {
         const { startWebServer } = module;
         logInfo(`Starting web server on port ${process.env.PORT || 8080}...`);
-        await startWebServer(version, hasApiKeys, { allowEdit: options.allowEdit });
+        await startWebServer(version, { allowEdit: options.allowEdit });
       })
       .catch(error => {
         logError(chalk.red(`Error starting web server: ${error.message}`));
@@ -427,11 +418,6 @@ export function main() {
 
   // --- Non-Interactive Mode ---
   if (isNonInteractive) {
-    if (!hasApiKeys) {
-      logError(chalk.red('No API key provided. Please set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_API_KEY environment variable.'));
-      process.exit(1);
-    }
-
     let chat;
     try {
       // Pass session ID if provided, ProbeChat generates one otherwise
@@ -445,8 +431,6 @@ export function main() {
         bashConfig: bashConfig,
         completionPrompt: completionPrompt
       });
-      // Model/Provider info is logged via logInfo above if debug enabled
-      logInfo(chalk.blue(`Using Session ID: ${chat.getSessionId()}`)); // Log the actual session ID being used
     } catch (error) {
       logError(chalk.red(`Initializing chat failed: ${error.message}`));
       process.exit(1);
@@ -468,6 +452,19 @@ export function main() {
     // Async function to handle the single chat request
     const runNonInteractiveChat = async () => {
       try {
+        // Initialize the chat (handles API key validation, claude-code/codex fallback)
+        await chat.initialize();
+
+        // Validate provider after initialization
+        const providerInfo = chat.getProviderInfo();
+        if (providerInfo.provider === 'unknown' || providerInfo.provider === 'uninitialized') {
+          throw new Error('No valid AI provider available. Please set an API key or install claude/codex CLI.');
+        }
+
+        // Log provider info after successful initialization
+        logInfo(chalk.green(`Using provider: ${providerInfo.provider} with model: ${providerInfo.model}`));
+        logInfo(chalk.blue(`Using Session ID: ${chat.getSessionId()}`));
+
         // Get message from command line argument or stdin
         let message = options.message;
 
@@ -533,16 +530,6 @@ export function main() {
   // --- Interactive CLI Mode ---
   // (This block only runs if not non-interactive and not web mode)
 
-  if (!hasApiKeys) {
-    // Use logError and standard console.log for setup instructions
-    logError(chalk.red('No API key provided. Please set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_API_KEY environment variable.'));
-    console.log(chalk.cyan('You can find these instructions in the .env.example file:'));
-    console.log(chalk.cyan('1. Create a .env file by copying .env.example'));
-    console.log(chalk.cyan('2. Add your API key to the .env file'));
-    console.log(chalk.cyan('3. Restart the application'));
-    process.exit(1);
-  }
-
   // Initialize ProbeChat for CLI mode
   let chat;
   try {
@@ -557,26 +544,44 @@ export function main() {
       bashConfig: bashConfig,
       completionPrompt: completionPrompt
     });
-
-    // Log model/provider info using logInfo
-    if (chat.apiType === 'anthropic') {
-      logInfo(chalk.green(`Using Anthropic API with model: ${chat.model}`));
-    } else if (chat.apiType === 'openai') {
-      logInfo(chalk.green(`Using OpenAI API with model: ${chat.model}`));
-    } else if (chat.apiType === 'google') {
-      logInfo(chalk.green(`Using Google API with model: ${chat.model}`));
-    }
-
-    logInfo(chalk.blue(`Session ID: ${chat.getSessionId()}`));
-    logInfo(chalk.cyan('Type "exit" or "quit" to end the chat'));
-    logInfo(chalk.cyan('Type "usage" to see token usage statistics'));
-    logInfo(chalk.cyan('Type "clear" to clear the chat history'));
-    logInfo(chalk.cyan('-------------------------------------------'));
   } catch (error) {
-    logError(chalk.red(`Error initializing chat: ${error.message}`));
+    logError(chalk.red(`Error creating chat instance: ${error.message}`));
     process.exit(1);
   }
 
+  // Async initialization wrapper for interactive mode
+  async function initializeAndStartChat() {
+    try {
+      // Initialize the chat (handles API key validation, claude-code/codex fallback)
+      await chat.initialize();
+
+      // Validate provider after initialization
+      const providerInfo = chat.getProviderInfo();
+      if (providerInfo.provider === 'unknown' || providerInfo.provider === 'uninitialized') {
+        throw new Error('No valid AI provider available. Please set an API key or install claude/codex CLI.');
+      }
+
+      // Log provider info after successful initialization
+      if (providerInfo.isCliProvider) {
+        logInfo(chalk.green(`Using ${providerInfo.provider} CLI`));
+      } else {
+        logInfo(chalk.green(`Using ${providerInfo.provider} API with model: ${providerInfo.model}`));
+      }
+
+      logInfo(chalk.blue(`Session ID: ${chat.getSessionId()}`));
+      logInfo(chalk.cyan('Type "exit" or "quit" to end the chat'));
+      logInfo(chalk.cyan('Type "usage" to see token usage statistics'));
+      logInfo(chalk.cyan('Type "clear" to clear the chat history'));
+      logInfo(chalk.cyan('-------------------------------------------'));
+
+      // Start the interactive chat loop
+      await runInteractiveChat();
+    } catch (error) {
+      logError(chalk.red(`Error initializing chat: ${error.message}`));
+      process.exit(1);
+    }
+  }
+
   // Format AI response for interactive mode
   function formatResponseInteractive(response) {
     // Check if response is a structured object with response and tokenUsage properties
@@ -598,7 +603,7 @@ export function main() {
   }
 
   // Main interactive chat loop
-  async function startChat() {
+  async function runInteractiveChat() {
     while (true) {
       const { message } = await inquirer.prompt([
         {
@@ -613,7 +618,7 @@ export function main() {
         logInfo(chalk.yellow('Goodbye!'));
         break;
       } else if (message.toLowerCase() === 'usage') {
-        const usage = chat.getTokenUsage();
+        const usage = chat.getUsageSummary();
         const display = new TokenUsageDisplay();
         const formatted = display.format(usage);
 
@@ -630,9 +635,9 @@ export function main() {
         process.stdout.write('\x1B]0;Context: ' + formatted.contextWindow + '\x07');
         continue;
       } else if (message.toLowerCase() === 'clear') {
-        const newSessionId = chat.clearHistory();
+        chat.clearHistory();
         logInfo(chalk.yellow('Chat history cleared'));
-        logInfo(chalk.blue(`New session ID: ${newSessionId}`));
+        logInfo(chalk.blue(`New session ID: ${chat.getSessionId()}`));
         continue;
       }
 
@@ -656,7 +661,7 @@ export function main() {
     }
   }
 
-  startChat().catch((error) => {
+  initializeAndStartChat().catch((error) => {
     logError(chalk.red(`Fatal error in interactive chat: ${error.message}`));
     process.exit(1);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe-chat",
-  "version": "0.6.0-rc191",
+  "version": "0.6.0-rc198",
   "description": "CLI and web interface for Probe code search (formerly @probelabs/probe-web and @probelabs/probe-chat)",
   "main": "index.js",
   "type": "module",
@@ -32,13 +32,13 @@
     "@ai-sdk/anthropic": "^2.0.8",
     "@ai-sdk/google": "^2.0.14",
     "@ai-sdk/openai": "^2.0.10",
-    "@probelabs/probe": "latest",
+    "@modelcontextprotocol/sdk": "^1.0.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.203.0",
     "@opentelemetry/resources": "^2.0.1",
     "@opentelemetry/sdk-node": "^0.203.0",
     "@opentelemetry/semantic-conventions": "^1.36.0",
-    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@probelabs/probe": "latest",
     "ai": "^5.0.0",
     "chalk": "^5.3.0",
     "commander": "^11.1.0",

package/probeChat.js

@@ -266,6 +266,9 @@ export class ProbeChat {
   constructor(options = {}) {
     this.isNonInteractive = options.isNonInteractive || process.env.PROBE_NON_INTERACTIVE === '1';
     this.debug = options.debug || process.env.DEBUG_CHAT === '1';
+    this._initialized = false;
+    this._initializing = null; // Promise to prevent concurrent initialization
+    this._initError = null; // Store initialization error to prevent infinite retries
 
     // Initialize ProbeAgent with MCP support
     const agentOptions = {
@@ -283,11 +286,81 @@ export class ProbeChat {
 
     if (this.debug) {
       console.log(`[DEBUG] ProbeChat initialized with MCP ${agentOptions.enableMcp ? 'enabled' : 'disabled'}`);
+    }
+  }
+
+  /**
+   * Initialize the chat agent asynchronously.
+   *
+   * This method is safe to call multiple times - subsequent calls will return
+   * immediately if already initialized, or wait for the ongoing initialization.
+   *
+   * If initialization fails, the error is stored and rethrown on subsequent calls
+   * to prevent infinite retry loops.
+   *
+   * This initializes the ProbeAgent which handles:
+   * - API key validation
+   * - Auto-detection of claude-code or codex CLI as fallback
+   * - MCP initialization
+   * - History loading from storage
+   *
+   * @returns {Promise<void>}
+   * @throws {Error} If no valid AI provider is available
+   */
+  async initialize() {
+    // If previous initialization failed, rethrow the stored error
+    if (this._initError) {
+      throw this._initError;
+    }
+
+    // Return existing initialization promise if in progress (prevents concurrent init)
+    if (this._initializing) {
+      return this._initializing;
+    }
 
-      // Log available tools after a short delay to allow MCP initialization
-      setTimeout(() => {
-        this.logAvailableTools();
-      }, 100);
+    // Already initialized successfully
+    if (this._initialized) {
+      return;
+    }
+
+    this._initializing = (async () => {
+      try {
+        await this.agent.initialize();
+
+        // Mark as initialized immediately after agent init succeeds
+        this._initialized = true;
+
+        // Debug logging wrapped in try-catch to not affect initialization state
+        if (this.debug) {
+          try {
+            const provider = this.agent.clientApiProvider || this.agent.apiType || 'unknown';
+            console.log(`[DEBUG] ProbeChat agent initialized with provider: ${provider}`);
+            this.logAvailableTools();
+          } catch (logError) {
+            console.error('[DEBUG] Logging failed:', logError.message);
+          }
+        }
+      } catch (error) {
+        // Store error to prevent infinite retry loops
+        this._initError = error;
+        throw error;
+      } finally {
+        // Always clear the initializing promise
+        this._initializing = null;
+      }
+    })();
+
+    return this._initializing;
+  }
+
+  /**
+   * Ensure the agent is initialized before use.
+   * Called automatically by chat() - you don't need to call this directly.
+   * @private
+   */
+  async _ensureInitialized() {
+    if (!this._initialized) {
+      await this.initialize();
     }
   }
 
@@ -333,18 +406,27 @@ export class ProbeChat {
   }
 
   /**
-   * Answer a question using the agentic flow with optional image support
+   * Send a chat message and get AI response.
+   *
+   * This method automatically initializes the agent on first call if not already
+   * initialized. For explicit control over initialization (e.g., to handle errors
+   * separately), call initialize() first.
+   *
    * @param {string} message - The user's question
    * @param {Object} [options] - Optional configuration
    * @param {string} [options.schema] - JSON schema for structured output
    * @param {Array} [options.images] - Array of image data (base64 strings or URLs)
-   * @returns {Promise<string>} - The final answer
+   * @returns {Promise<Object>} - The AI response with token usage
+   * @throws {Error} If message is empty or if no valid AI provider is available
    */
   async chat(message, options = {}) {
     if (!message || typeof message !== 'string' || message.trim().length === 0) {
       throw new Error('Message is required and must be a non-empty string');
     }
 
+    // Ensure the agent is initialized (handles API key validation, claude-code/codex fallback)
+    await this._ensureInitialized();
+
     // Extract images from the message text if not provided in options
     let images = options.images || [];
     let cleanedMessage = message;
@@ -379,6 +461,26 @@ export class ProbeChat {
     return this.agent.sessionId;
   }
 
+  /**
+   * Get provider information
+   * @returns {Object} - Provider info with type and model
+   */
+  getProviderInfo() {
+    return {
+      provider: this.agent.clientApiProvider || this.agent.apiType || 'unknown',
+      model: this.agent.model || 'unknown',
+      isCliProvider: ['claude-code', 'codex'].includes(this.agent.clientApiProvider || this.agent.apiType)
+    };
+  }
+
+  /**
+   * Check if the agent is initialized
+   * @returns {boolean}
+   */
+  isInitialized() {
+    return this._initialized;
+  }
+
   /**
    * Get usage summary for the current session
    */
@@ -387,11 +489,13 @@ export class ProbeChat {
   }
 
   /**
-   * Clear conversation history
+   * Clear conversation history and return the new session ID
+   * @returns {string} - The new session ID
    */
   clearHistory() {
     this.agent.clearHistory();
     this.tokenUsage.clear();
+    return this.agent.sessionId;
   }
 
   /**

package/test/unit/chatSessionManager.test.js

@@ -0,0 +1,86 @@
+import { describe, it, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert';
+import { ChatSessionManager } from '../../ChatSessionManager.js';
+
+// Store original environment
+let originalEnv;
+
+describe('ChatSessionManager Tests', () => {
+  beforeEach(() => {
+    // Store original environment
+    originalEnv = { ...process.env };
+
+    // Set test mode
+    process.env.NODE_ENV = 'test';
+    process.env.USE_MOCK_AI = 'true';
+  });
+
+  afterEach(() => {
+    // Restore original environment
+    Object.keys(process.env).forEach(key => {
+      if (!(key in originalEnv)) {
+        delete process.env[key];
+      }
+    });
+    Object.assign(process.env, originalEnv);
+  });
+
+  describe('initialize()', () => {
+    it('should call agent.initialize() when initializing', async () => {
+      // Create a ChatSessionManager
+      const session = new ChatSessionManager({
+        sessionId: 'test-session-123',
+        debug: false
+      });
+
+      // Track if agent.initialize was called
+      let agentInitializeCalled = false;
+      const originalInitialize = session.agent.initialize.bind(session.agent);
+      session.agent.initialize = async function() {
+        agentInitializeCalled = true;
+        return originalInitialize();
+      };
+
+      // Initialize the session
+      await session.initialize();
+
+      // Verify agent.initialize was called
+      assert.strictEqual(agentInitializeCalled, true, 'agent.initialize() should be called during ChatSessionManager.initialize()');
+    });
+
+    it('should only initialize once even if called multiple times', async () => {
+      const session = new ChatSessionManager({
+        sessionId: 'test-session-456',
+        debug: false
+      });
+
+      let initializeCallCount = 0;
+      const originalInitialize = session.agent.initialize.bind(session.agent);
+      session.agent.initialize = async function() {
+        initializeCallCount++;
+        return originalInitialize();
+      };
+
+      // Call initialize multiple times
+      await session.initialize();
+      await session.initialize();
+      await session.initialize();
+
+      // Should only be called once due to _ready flag
+      assert.strictEqual(initializeCallCount, 1, 'agent.initialize() should only be called once');
+    });
+
+    it('should set _ready flag after successful initialization', async () => {
+      const session = new ChatSessionManager({
+        sessionId: 'test-session-789',
+        debug: false
+      });
+
+      assert.strictEqual(session._ready, false, '_ready should be false before initialize');
+
+      await session.initialize();
+
+      assert.strictEqual(session._ready, true, '_ready should be true after initialize');
+    });
+  });
+});

package/webServer.js

@@ -98,13 +98,12 @@ function getOrCreateChat(sessionId, apiCredentials = null) {
 /**
  * Start the web server
  * @param {string} version - The version of the application
- * @param {boolean} hasApiKeys - Whether any API keys are configured
  * @param {Object} options - Additional options
  * @param {boolean} options.allowEdit - Whether to allow editing files via the implement tool
  */
-export async function startWebServer(version, hasApiKeys = true, options = {}) {
+export async function startWebServer(version, options = {}) {
 	const allowEdit = options?.allowEdit || false;
-	
+
 	if (allowEdit) {
 		console.log('Edit mode enabled: implement tool is available');
 	}
@@ -120,11 +119,11 @@ export async function startWebServer(version, hasApiKeys = true, options = {}) {
 	}
 
 	// Initialize persistent storage for web mode
-	globalStorage = new JsonChatStorage({ 
-		webMode: true, 
-		verbose: process.env.DEBUG_CHAT === '1' 
+	globalStorage = new JsonChatStorage({
+		webMode: true,
+		verbose: process.env.DEBUG_CHAT === '1'
 	});
-	
+
 	// Initialize storage synchronously before server starts
 	try {
 		await globalStorage.initialize();
@@ -144,13 +143,9 @@ export async function startWebServer(version, hasApiKeys = true, options = {}) {
 		? process.env.ALLOWED_FOLDERS.split(',').map(folder => folder.trim()).filter(Boolean)
 		: [];
 
-
-	let noApiKeysMode = !hasApiKeys;
-	if (noApiKeysMode) {
-		console.log('Running in No API Keys mode - will show setup instructions to users');
-	} else {
-		console.log('API keys detected. Chat functionality enabled.');
-	}
+	// Note: API key / CLI availability is checked lazily in ProbeAgent.initialize()
+	// when the first chat message is sent. This allows fallback to Claude Code or Codex CLI.
+	console.log('Chat functionality enabled (API availability checked on first message)');
 
 
 	// Define the tools available for direct API calls (bypassing LLM loop)
@@ -419,7 +414,7 @@ export async function startWebServer(version, hasApiKeys = true, options = {}) {
 			// UI Routes
 			'GET /': (req, res) => {
 				const htmlPath = join(__dirname, 'index.html');
-				serveHtml(res, htmlPath, { 'data-no-api-keys': noApiKeysMode ? 'true' : 'false' });
+				serveHtml(res, htmlPath, { 'data-no-api-keys': 'false' });
 			},
 
 			// Chat session route - serves HTML with injected session ID
@@ -428,15 +423,15 @@ export async function startWebServer(version, hasApiKeys = true, options = {}) {
 				if (!sessionId) {
 					return sendError(res, 400, 'Invalid session ID in URL');
 				}
-				
+
 				// Validate that session exists or at least has a valid UUID format
 				if (!isValidUUID(sessionId)) {
 					return sendError(res, 400, 'Invalid session ID format');
 				}
 
 				const htmlPath = join(__dirname, 'index.html');
-				serveHtml(res, htmlPath, { 
-					'data-no-api-keys': noApiKeysMode ? 'true' : 'false',
+				serveHtml(res, htmlPath, {
+					'data-no-api-keys': 'false',
 					'data-session-id': sessionId
 				});
 			},
@@ -451,7 +446,7 @@ export async function startWebServer(version, hasApiKeys = true, options = {}) {
 				sendJson(res, 200, {
 					folders: folders,
 					currentDir: currentDir,
-					noApiKeysMode: noApiKeysMode
+					noApiKeysMode: false
 				});
 			},
 
@@ -700,12 +695,6 @@ export async function startWebServer(version, hasApiKeys = true, options = {}) {
 					// Update last activity timestamp
 					chatInstance.lastActivity = Date.now();
 
-					// Check if API keys are needed but missing
-					if (chatInstance.noApiKeysMode) {
-						console.warn(`[WARN] Chat request for session ${chatSessionId} cannot proceed: No API keys configured.`);
-						return sendError(res, 503, 'Chat service unavailable: API key not configured on server.');
-					}
-
 					// Register this request as active for cancellation
 					registerRequest(chatSessionId, { abort: () => chatInstance.abort() });
 					if (DEBUG) console.log(`[DEBUG] Registered cancellable request for session: ${chatSessionId}`);
@@ -918,9 +907,6 @@ export async function startWebServer(version, hasApiKeys = true, options = {}) {
 		console.log(`Probe Web Interface v${version}`);
 		console.log(`Server running on http://localhost:${PORT}`);
 		console.log(`Environment: ${process.env.NODE_ENV || 'development'}`);
-		if (noApiKeysMode) {
-			console.log('*** Running in NO API KEYS mode. Chat functionality disabled. ***');
-		}
 	});
 }