converse-mcp-server 2.0.2-beta.1 → 2.0.2-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "converse-mcp-server",
-  "version": "2.0.2-beta.1",
+  "version": "2.0.2-beta.4",
   "description": "Converse MCP Server - Converse with other LLMs with chat and consensus tools",
   "type": "module",
   "main": "src/index.js",

package/src/providers/codex.js

@@ -305,71 +305,65 @@ export const codexProvider = {
         debugLog('[Codex] Using reasoning_effort:', reasoning_effort);
       }
 
-      // Use streaming when requested
+      // WORKAROUND: SDK's thread.run() hangs due to missing break after turn.completed
+      // Always use streaming internally, consume synchronously when stream=false
       if (stream) {
-        debugLog('[Codex] invoke: Returning streaming generator');
-        const generator = createStreamingGenerator(thread, prompt, signal, runOptions);
-        debugLog('[Codex] invoke: Generator created, returning it');
-        return generator;
+        debugLog('[Codex] invoke: Returning streaming generator (async mode)');
+        return createStreamingGenerator(thread, prompt, signal, runOptions);
       }
 
-      // Non-streaming execution (disabled due to SDK bug - see above)
+      // Synchronous mode: consume streaming internally and return complete response
+      debugLog('[Codex] invoke: Using streaming internally for sync execution (SDK bug workaround)');
       const startTime = Date.now();
-      debugLog('[Codex] invoke: Starting non-streaming execution with thread.run()', {
-        threadId: thread.id,
-        hasRunOptions: !!Object.keys(runOptions).length,
-        promptLength: prompt.length
-      });
-
-      // Try with reasoning_effort, fallback without if SDK doesn't support it
-      let turn;
-      try {
-        debugLog('[Codex] invoke: Calling thread.run() (awaiting response)...');
-        const runStartTime = Date.now();
-        turn = await thread.run(prompt, runOptions);
-        const runDuration = Date.now() - runStartTime;
-        debugLog('[Codex] invoke: thread.run() returned', { runDuration, hasTurn: !!turn });
-      } catch (error) {
-        debugLog('[Codex] invoke: thread.run() threw error', { message: error.message });
-        if (reasoning_effort && (error.message?.includes('reasoningEffort') || error.message?.includes('unknown option'))) {
-          debugLog('[Codex] reasoning_effort not supported by this SDK version, retrying without it');
-          debugLog('[Codex] invoke: Retrying thread.run() without reasoning_effort...');
-          const retryStartTime = Date.now();
-          turn = await thread.run(prompt);
-          const retryDuration = Date.now() - retryStartTime;
-          debugLog('[Codex] invoke: thread.run() retry returned', { retryDuration });
-        } else {
-          throw error;
+      const generator = createStreamingGenerator(thread, prompt, signal, runOptions);
+
+      let content = '';
+      let usage = null;
+      let threadIdFromStream = null;
+
+      debugLog('[Codex] invoke: Consuming stream synchronously...');
+      for await (const event of generator) {
+        debugLog('[Codex] invoke: Sync consume event', { type: event?.type });
+
+        if (event?.type === 'thread.started') {
+          threadIdFromStream = event.thread_id;
+        } else if (event?.type === 'item.completed' && event.item?.type === 'agent_message') {
+          content += event.item.text || '';
+        } else if (event?.type === 'turn.completed') {
+          usage = event.usage;
+          debugLog('[Codex] invoke: turn.completed received in sync mode');
+          break; // Exit after turn.completed
+        } else if (event?.type === 'turn.failed') {
+          throw new CodexProviderError(event.error?.message || 'Turn failed', 'TURN_FAILED');
         }
       }
-      const responseTime = Date.now() - startTime;
-      debugLog('[Codex] invoke: thread.run() completed', { responseTime });
 
-      debugLog('[Codex] Non-streaming execution completed', {
-        threadId: thread.id,
+      const responseTime = Date.now() - startTime;
+      debugLog('[Codex] invoke: Sync execution completed', {
         responseTime,
-        usage: turn.usage,
-        hasContent: !!turn.finalResponse
+        contentLength: content.length,
+        hasUsage: !!usage
       });
 
       return {
-        content: turn.finalResponse || '',
+        content,
         stop_reason: StopReasons.STOP,
-        rawResponse: turn,
+        rawResponse: { content, usage },
         metadata: {
           provider: 'codex',
           model,
-          threadId: thread.id, // Store for continuation
-          usage: turn.usage ? {
-            input_tokens: turn.usage.input_tokens || 0,
-            output_tokens: turn.usage.output_tokens || 0,
-            total_tokens: (turn.usage.input_tokens || 0) + (turn.usage.output_tokens || 0),
-            cached_input_tokens: turn.usage.cached_input_tokens || 0
+          threadId: threadIdFromStream || thread.id,
+          usage: usage ? {
+            input_tokens: usage.input_tokens || 0,
+            output_tokens: usage.output_tokens || 0,
+            total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0),
+            cached_input_tokens: usage.cached_input_tokens || 0
           } : null,
           response_time_ms: responseTime,
           finish_reason: 'stop'
         }
       };
+
     } catch (error) {
       debugError('[Codex] Execution error', error);