fix(core): preserve no-argument tool calls that stream an empty arguments string

packages/core/src/core/openaiContentGenerator/converter.test.ts

@@ -292,6 +292,64 @@ describe('OpenAIContentConverter', () => {
       expect(fnB?.args).toEqual({ file_path: '/b/y.ts' });
       expect(fnB?.id).toBe('call_B');
     });
+
+    it('emits no-argument tool calls that stream an empty arguments string', () => {
+      // Providers may finish a no-argument tool call with `arguments: ""`
+      // and no follow-up fragment (e.g. llama.cpp-style servers). The call
+      // must reach the caller with empty args instead of being dropped,
+      // which would make the whole turn look empty and trigger retries.
+      const stream = withStreamParser(new StreamingToolCallParser());
+
+      const opener = {
+        object: 'chat.completion.chunk',
+        id: 'noargs-open',
+        created: 1,
+        model: 'test',
+        choices: [
+          {
+            index: 0,
+            delta: {
+              tool_calls: [
+                {
+                  index: 0,
+                  id: 'call_noargs',
+                  type: 'function' as const,
+                  function: { name: 'list_sessions', arguments: '' },
+                },
+              ],
+            },
+            finish_reason: null,
+            logprobs: null,
+          },
+        ],
+      } as unknown as OpenAI.Chat.ChatCompletionChunk;
+
+      const finisher = {
+        object: 'chat.completion.chunk',
+        id: 'noargs-finish',
+        created: 2,
+        model: 'test',
+        choices: [
+          {
+            index: 0,
+            delta: {},
+            finish_reason: 'tool_calls',
+            logprobs: null,
+          },
+        ],
+      } as unknown as OpenAI.Chat.ChatCompletionChunk;
+
+      converter.convertOpenAIChunkToGemini(opener, stream);
+      const result = converter.convertOpenAIChunkToGemini(finisher, stream);
+
+      const fn = result.candidates?.[0]?.content?.parts?.find(
+        (p: Part) => p.functionCall,
+      )?.functionCall;
+
+      expect(fn?.name).toBe('list_sessions');
+      expect(fn?.args).toEqual({});
+      expect(fn?.id).toBe('call_noargs');
+    });
   });
 
   describe('convertGeminiRequestToOpenAI', () => {

packages/core/src/core/openaiContentGenerator/streamingToolCallParser.test.ts

@@ -391,11 +391,25 @@ describe('StreamingToolCallParser', () => {
       expect(completed).toHaveLength(0);
     });
 
-    it('should not return tool calls with empty buffer', () => {
-      parser.addChunk(0, '', 'call_1', 'function1'); // Empty buffer
+    it('should return no-argument tool calls with empty args when buffer is empty', () => {
+      // For tools without parameters, some providers stream
+      // `arguments: ""` (or omit the field) and never send an argument
+      // fragment. The call must survive with empty args, matching the
+      // non-streaming path.
+      parser.addChunk(0, '', 'call_1', 'function1');
 
       const completed = parser.getCompletedToolCalls();
-      expect(completed).toHaveLength(0);
+      expect(completed).toEqual([
+        { id: 'call_1', name: 'function1', args: {}, index: 0 },
+      ]);
+    });
+
+    it('should return empty args for whitespace-only argument buffers', () => {
+      parser.addChunk(0, '   ', 'call_1', 'function1');
+
+      const completed = parser.getCompletedToolCalls();
+      expect(completed).toHaveLength(1);
+      expect(completed[0].args).toEqual({});
     });
   });
 

packages/core/src/core/openaiContentGenerator/streamingToolCallParser.ts

@@ -265,7 +265,7 @@ export class StreamingToolCallParser {
 
     for (const [index, buffer] of this.buffers.entries()) {
       const meta = this.toolCallMeta.get(index);
-      if (meta?.name && buffer.trim()) {
+      if (meta?.name) {
         if (meta.id) {
           if (emittedIds.has(meta.id)) {
             continue;
@@ -275,21 +275,27 @@ export class StreamingToolCallParser {
 
         let args: Record<string, unknown> = {};
 
-        // Try to parse the final buffer
-        try {
-          args = JSON.parse(buffer);
-        } catch {
-          // Try with repair (auto-close strings)
-          const inString = this.inStrings.get(index);
-          if (inString) {
-            try {
-              args = JSON.parse(buffer + '"');
-            } catch {
-              // If all parsing fails, use safeJsonParse as fallback
+        // An empty buffer is a legal end state: for no-argument tools some
+        // providers stream `arguments: ""` (or omit the field entirely) and
+        // never send an argument fragment. Keep args as {} to match the
+        // non-streaming path in converter.ts.
+        if (buffer.trim()) {
+          // Try to parse the final buffer
+          try {
+            args = JSON.parse(buffer);
+          } catch {
+            // Try with repair (auto-close strings)
+            const inString = this.inStrings.get(index);
+            if (inString) {
+              try {
+                args = JSON.parse(buffer + '"');
+              } catch {
+                // If all parsing fails, use safeJsonParse as fallback
+                args = safeJsonParse(buffer, {});
+              }
+            } else {
               args = safeJsonParse(buffer, {});
             }
-          } else {
-            args = safeJsonParse(buffer, {});
           }
         }