Fix: Split tool_calls status into multiple chunks for proper Open WebUI display

OpenAI streaming format requires tool calls to be sent across multiple chunks:
1. First chunk: id, type, function name with empty arguments
2. Second chunk: function arguments only

This matches OpenAI's actual streaming behavior where tool_calls are
accumulated incrementally, fixing the display issue in Open WebUI where
the status was showing as empty JSON.

Changes:
- Rename createStatusToolCallChunk -> createStatusToolCallChunks (returns array)
- First chunk contains metadata (id, type, name) with arguments: ''
- Second chunk contains only arguments field
- Both chunks share same chat ID and timestamp
- Update streamingHandler to send both chunks sequentially
- Update all tests to match new multi-chunk format

All 427 tests passing.

Author: sveneisenschmidt

src/handlers/streamingHandler.js

@@ -19,7 +19,7 @@
 const {
   createStreamingChunk,
   createStatus,
-  createStatusToolCallChunk,
+  createStatusToolCallChunks,
   createTypeStatusChunk,
 } = require('../utils/openaiResponse');
 const { createErrorResponse } = require('../utils/errorResponse');
@@ -40,17 +40,22 @@ function emitStatus(res, config, model, message, done = false) {
 
   const status = createStatus(message, done);
 
-  let statusChunk;
   switch (config.statusEmitFormat) {
-    case 'type_status':
-      statusChunk = createTypeStatusChunk(model, status);
+    case 'type_status': {
+      const statusChunk = createTypeStatusChunk(model, status);
+      res.write(`data: ${JSON.stringify(statusChunk)}\n\n`);
       break;
+    }
     case 'tool_calls':
-    default:
-      statusChunk = createStatusToolCallChunk(model, status);
+    default: {
+      // tool_calls format requires multiple chunks
+      const chunks = createStatusToolCallChunks(model, status);
+      chunks.forEach((chunk) => {
+        res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+      });
       break;
+    }
   }
-  res.write(`data: ${JSON.stringify(statusChunk)}\n\n`);
 }
 
 /**

src/utils/openaiResponse.js

@@ -88,19 +88,28 @@ function createStatus(message, done = false) {
 }
 
 /**
- * Creates an OpenAI-compatible tool call chunk for status updates
+ * Creates OpenAI-compatible tool call chunks for status updates
+ * Returns an array of chunks that must be sent sequentially:
+ * 1. First chunk with id, type, and function name
+ * 2. Following chunks with arguments (streamed incrementally)
  *
  * @param {string} model - Model identifier
  * @param {Object} status - Status object from createStatus()
- * @returns {Object} OpenAI-compatible chunk with tool_calls
+ * @returns {Array<Object>} Array of OpenAI-compatible chunks with tool_calls
  */
-function createStatusToolCallChunk(model, status) {
+function createStatusToolCallChunks(model, status) {
   const callId = `call_status_${Date.now()}`;
+  const chatId = `chatcmpl-${uuidv4()}`;
+  const created = Math.floor(Date.now() / 1000);
+  const argsJson = JSON.stringify({ message: status.message });
 
-  return {
-    id: `chatcmpl-${uuidv4()}`,
+  const chunks = [];
+
+  // First chunk: id, type, and function name with empty arguments
+  chunks.push({
+    id: chatId,
     object: 'chat.completion.chunk',
-    created: Math.floor(Date.now() / 1000),
+    created,
     model,
     choices: [
       {
@@ -113,15 +122,42 @@ function createStatusToolCallChunk(model, status) {
               type: 'function',
               function: {
                 name: 'emit_status',
-                arguments: JSON.stringify({ message: status.message }),
+                arguments: '',
               },
             },
           ],
         },
         finish_reason: null,
       },
     ],
-  };
+  });
+
+  // Stream arguments incrementally (can be sent as single chunk or character-by-character)
+  // For simplicity, we send the complete arguments in one chunk
+  chunks.push({
+    id: chatId,
+    object: 'chat.completion.chunk',
+    created,
+    model,
+    choices: [
+      {
+        index: 0,
+        delta: {
+          tool_calls: [
+            {
+              index: 0,
+              function: {
+                arguments: argsJson,
+              },
+            },
+          ],
+        },
+        finish_reason: null,
+      },
+    ],
+  });
+
+  return chunks;
 }
 
 /**
@@ -148,6 +184,6 @@ module.exports = {
   createStreamingChunk,
   createCompletionResponse,
   createStatus,
-  createStatusToolCallChunk,
+  createStatusToolCallChunks,
   createTypeStatusChunk,
 };

tests/utils/openaiResponse.test.js

@@ -20,7 +20,7 @@ const {
   createStreamingChunk,
   createCompletionResponse,
   createStatus,
-  createStatusToolCallChunk,
+  createStatusToolCallChunks,
   createTypeStatusChunk,
 } = require('../../src/utils/openaiResponse');
 
@@ -122,12 +122,21 @@ describe('openaiResponse utility', () => {
     });
   });
 
-  describe('createStatusToolCallChunk', () => {
-    it('should create status tool call chunk with all fields', () => {
+  describe('createStatusToolCallChunks', () => {
+    it('should create array of status tool call chunks', () => {
       const status = createStatus('Processing', false);
-      const chunk = createStatusToolCallChunk('gpt-4', status);
+      const chunks = createStatusToolCallChunks('gpt-4', status);
 
-      expect(chunk).toMatchObject({
+      expect(Array.isArray(chunks)).toBe(true);
+      expect(chunks).toHaveLength(2);
+    });
+
+    it('should have first chunk with id, type, name, and empty arguments', () => {
+      const status = createStatus('Processing', false);
+      const chunks = createStatusToolCallChunks('gpt-4', status);
+      const firstChunk = chunks[0];
+
+      expect(firstChunk).toMatchObject({
         object: 'chat.completion.chunk',
         model: 'gpt-4',
         choices: [
@@ -140,6 +149,36 @@ describe('openaiResponse utility', () => {
                   type: 'function',
                   function: {
                     name: 'emit_status',
+                    arguments: '',
+                  },
+                },
+              ],
+            },
+            finish_reason: null,
+          },
+        ],
+      });
+      expect(firstChunk.id).toMatch(/^chatcmpl-/);
+      expect(firstChunk.created).toBeGreaterThan(0);
+      expect(firstChunk.choices[0].delta.tool_calls[0].id).toMatch(/^call_status_/);
+    });
+
+    it('should have second chunk with arguments only', () => {
+      const status = createStatus('Processing', false);
+      const chunks = createStatusToolCallChunks('gpt-4', status);
+      const secondChunk = chunks[1];
+
+      expect(secondChunk).toMatchObject({
+        object: 'chat.completion.chunk',
+        model: 'gpt-4',
+        choices: [
+          {
+            index: 0,
+            delta: {
+              tool_calls: [
+                {
+                  index: 0,
+                  function: {
                     arguments: JSON.stringify({ message: 'Processing' }),
                   },
                 },
@@ -149,34 +188,32 @@ describe('openaiResponse utility', () => {
           },
         ],
       });
-      expect(chunk.id).toMatch(/^chatcmpl-/);
-      expect(chunk.created).toBeGreaterThan(0);
-      expect(chunk.choices[0].delta.tool_calls[0].id).toMatch(/^call_status_/);
+      expect(secondChunk.id).toMatch(/^chatcmpl-/);
+      expect(secondChunk.created).toBeGreaterThan(0);
     });
 
-    it('should create status tool call chunk for initiating step', () => {
-      const status = createStatus('Initiating', false);
-      const chunk = createStatusToolCallChunk('test-model', status);
+    it('should use same chat ID and timestamp for both chunks', () => {
+      const status = createStatus('Test', false);
+      const chunks = createStatusToolCallChunks('gpt-4', status);
 
-      expect(chunk.choices[0].delta.tool_calls[0].function.arguments).toBe(
-        JSON.stringify({ message: 'Initiating' }),
-      );
+      expect(chunks[0].id).toBe(chunks[1].id);
+      expect(chunks[0].created).toBe(chunks[1].created);
     });
 
-    it('should create status tool call chunk for completed step', () => {
+    it('should create chunks for completed status', () => {
       const status = createStatus('Completed', true);
-      const chunk = createStatusToolCallChunk('test-model', status);
+      const chunks = createStatusToolCallChunks('test-model', status);
 
-      expect(chunk.choices[0].delta.tool_calls[0].function.arguments).toBe(
+      expect(chunks[1].choices[0].delta.tool_calls[0].function.arguments).toBe(
         JSON.stringify({ message: 'Completed' }),
       );
     });
 
     it('should have call ID with correct format', () => {
       const status = createStatus('Step 1', false);
-      const chunk = createStatusToolCallChunk('gpt-4', status);
+      const chunks = createStatusToolCallChunks('gpt-4', status);
 
-      const id = chunk.choices[0].delta.tool_calls[0].id;
+      const id = chunks[0].choices[0].delta.tool_calls[0].id;
 
       expect(id).toMatch(/^call_status_\d+$/);
     });