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

package/index.js

@@ -427,11 +427,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 +440,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 +461,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 +539,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 +553,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 +612,7 @@ export function main() {
   }
 
   // Main interactive chat loop
-  async function startChat() {
+  async function runInteractiveChat() {
     while (true) {
       const { message } = await inquirer.prompt([
         {
@@ -613,7 +627,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 +644,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 +670,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-rc197",
   "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;
   }
 
   /**