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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "converse-mcp-server",
-  "version": "2.0.2-beta.1",
+  "version": "2.0.2-beta.3",
   "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,16 +305,67 @@ 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();
+      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: Sync execution completed', {
+        responseTime,
+        contentLength: content.length,
+        hasUsage: !!usage
+      });
+
+      return {
+        content,
+        stop_reason: StopReasons.STOP,
+        rawResponse: { content, usage },
+        metadata: {
+          provider: 'codex',
+          model,
+          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'
+        }
+      };
+
+      // Legacy non-streaming code below (now unreachable - kept for reference)
+      const legacyStartTime = Date.now();
       debugLog('[Codex] invoke: Starting non-streaming execution with thread.run()', {
         threadId: thread.id,
         hasRunOptions: !!Object.keys(runOptions).length,