fix(openai): normalize empty tool arguments to prevent silent drop

[PaulyBearCoding]

Fix: Tools with no arguments not being invoked

Fixes #5658

Problem

When using OpenAI-compatible providers (like Ollama) with tools that have no parameters, the tool calls are silently dropped and never invoked.

Technical Root Cause

The bug exists in two locations in openai-chat-language-model.ts:

Location 1: doGenerate (non-streaming)

// Line 348-361 (before fix)
for (const toolCall of choice.message.tool_calls ?? []) {
  content.push({
    type: 'tool-call',
    toolCallId: toolCall.id ?? generateId(),
    toolName: toolCall.function.name,
    input: toolCall.function.arguments,  // Empty string ""
  });
}

Location 2: doStream flush handler (streaming)

// Lines 688-699 (before fix)
flush(controller) {
  // Missing: No logic to process pending tool calls
  controller.enqueue({ type: 'finish', finishReason, usage });
}

Why It Fails

The Issue:
OpenAI-compatible providers send arguments: "" (empty string) for tools with no parameters. In the streaming code (lines 614, 656), there's a check:

if (isParsableJson(toolCall.function.arguments)) {
  controller.enqueue({ type: 'tool-call', ... });
  toolCall.hasFinished = true;
}

The Problem:

• Empty string "" is NOT valid JSON
• isParsableJson("") returns false
• Tool call never gets enqueued
• hasFinished remains false
• Stream ends without emitting the tool call

---

Reproduction

Minimal Example

import { generateText } from 'ai';
import { openai } from '@ai-sdk/openai';

const result = await generateText({
  model: openai('gpt-3.5-turbo'),
  tools: {
    getCurrentTime: {
      description: 'Get the current time',
      parameters: z.object({}),  // NO parameters
    },
  },
  prompt: 'What time is it?',
});

// Expected: Tool call is made
// Actual (before fix): No tool calls in result.toolCalls

Exact API Response That Triggers Bug

{
  "tool_calls": [{
    "id": "call_123",
    "type": "function",
    "function": {
      "name": "getCurrentTime",
      "arguments": ""  // <-- Empty string causes bug
    }
  }]
}

Reproduction Test

Created comprehensive test: packages/openai/src/chat/repro-5658-no-args-tool.test.ts

The test mocks the exact OpenAI streaming response format and verifies:

1. Tool with arguments: "" should emit tool-call event
2. Tool should have input: "{}" (normalized from empty string)
3. Both streaming and non-streaming APIs affected

---

Solution

Code Changes

File: packages/openai/src/chat/openai-chat-language-model.ts

Change 1 - doGenerate (lines 349-351):

// Before
input: toolCall.function.arguments,

// After
const normalizedArguments = toolCall.function.arguments.trim() || '{}';
input: normalizedArguments,

Change 2 - Flush Handler (lines 693-716):

flush(controller) {
  // NEW: Process any pending tool calls
  for (const toolCall of toolCalls) {
    if (
      !toolCall.hasFinished &&
      toolCall.function?.name != null &&
      toolCall.function?.arguments != null
    ) {
      const normalizedArguments = toolCall.function.arguments.trim() || '{}';

      controller.enqueue({ type: 'tool-input-end', id: toolCall.id });
      controller.enqueue({
        type: 'tool-call',
        toolCallId: toolCall.id ?? generateId(),
        toolName: toolCall.function.name,
        input: normalizedArguments,
      });
    }
  }

  // Existing finish logic
  if (isActiveText) {
    controller.enqueue({ type: 'text-end', id: '0' });
  }
  controller.enqueue({ type: 'finish', finishReason, usage });
}

Why This Works

The normalization logic:

const normalizedArguments = toolCall.function.arguments.trim() || '{}';

How it works:

1. trim() removes any whitespace from the string
2. If result is empty string "", it's falsy
3. The || operator returns '{}' as fallback
4. If result is non-empty (e.g., '{"foo":"bar"}'), it's truthy
5. The || operator returns the trimmed value

What it handles:

• Empty string "" → "{}"
• Whitespace only " " → "{}" (trim gives "", then fallback)
• Tabs/newlines "\t\n" → "{}" (same logic)
• Valid empty object "{}" → "{}" (truthy after trim)
• Normal arguments '{"location":"SF"}' → unchanged

Why the flush handler is needed:

In streaming mode, tool arguments are built incrementally:

Chunk 1: arguments: ""
Chunk 2: arguments: "" (stays empty)
Chunk 3: finish_reason: "tool_calls"

If arguments never become parsable JSON, the streaming logic never enqueues the tool call. The flush handler catches these pending tool calls before the stream ends.

---

Testing

Test Coverage

Created: packages/openai/src/chat/repro-5658-no-args-tool.test.ts

7 comprehensive tests:

1. Empty string arguments (streaming) - Tool with arguments: ""

   • Verifies tool-call event emitted
   • Verifies input: "{}"

2. Empty string sent incrementally - Arguments stay "" across chunks

   • Verifies flush handler catches pending call

3. Empty arguments (non-streaming) - generateText API

   • Verifies doGenerate normalization works

4. Whitespace-only (spaces) - arguments: " "

   • Verifies trim + fallback works

5. Whitespace-only (tabs/newlines) - arguments: "\t\n\r "

   • Verifies all whitespace types handled

6. Valid empty object - arguments: "{}"

   • Verifies we don't break valid input

7. Whitespace in streaming - Stream with arguments: " "

   • Verifies flush handler normalizes whitespace

Test Results

pnpm --filter @ai-sdk/openai test repro-5658-no-args-tool.test.ts

✓ Issue #5658: Tools with no arguments (7 tests) 63ms
  ✓ streamText > should invoke tool with empty string arguments
  ✓ streamText > should invoke tool with empty string arguments sent incrementally
  ✓ generateText > should invoke tool with empty arguments in non-streaming mode
  ✓ Edge Cases > should handle whitespace-only arguments (spaces)
  ✓ Edge Cases > should handle whitespace-only arguments (tabs and newlines)
  ✓ Edge Cases > should NOT normalize valid empty object
  ✓ Edge Cases > should handle whitespace-only arguments in streaming mode

Tests  7 passed (7)

What The Tests Verify

Test 1 output (empty string):

[
  { "type": "tool-input-start", "id": "call_getCurrentTime", "toolName": "getCurrentTime" },
  { "type": "tool-input-end", "id": "call_getCurrentTime" },
  { "type": "tool-call", "toolCallId": "call_getCurrentTime", "toolName": "getCurrentTime", "input": "{}" },
  { "type": "finish", "finishReason": "tool-calls" }
]

Before fix: No tool-call event emitted (bug)
After fix: tool-call emitted with normalized input: "{}"

Existing Test Results

All existing tests still passing:

@ai-sdk/openai:        453/456 passing (99.3%)
  - 73/73 chat model tests passing
  - 177/177 responses tests passing
  - 3 unrelated transcription snapshot failures (pre-existing)

Dependent packages:
  @ai-sdk/azure:       88/88 passing (100%)
  @ai-sdk/openai-compatible: 130/130 passing (100%)

Core integration:
  ai (core):           1468/1468 passing (100%)

---

Edge Cases Handled

Input	Before Fix	After Fix	Why
""	Dropped	"{}"	Empty string normalized
" "	Dropped	"{}"	Whitespace trimmed, then normalized
"\t\n"	Dropped	"{}"	All whitespace handled
"{}"	Works	Works	Valid JSON unchanged
'{"x":1}'	Works	Works	Normal arguments unchanged

---

Impact

Who This Affects

• Ollama users - Ollama sends empty string for no-arg tools
• MCP (Model Context Protocol) - Tools with no parameters
• OpenAI-compatible providers - Any provider that sends arguments: ""
• Small language models - Often used via OpenAI-compatible APIs

Common Use Cases Now Working

// These all work now:

// 1. Get current time (no args)
getCurrentTime: {
  parameters: z.object({}),
  execute: async () => ({ time: new Date().toISOString() })
}

// 2. Refresh data (no args)
refreshData: {
  parameters: z.object({}),
  execute: async () => await fetchLatestData()
}

// 3. Check status (no args)
getStatus: {
  parameters: z.object({}),
  execute: async () => ({ status: 'healthy' })
}

What Doesn't Change

• ✅ Tools with normal arguments - unchanged
• ✅ Streaming with incremental arguments - unchanged
• ✅ Text generation without tools - unchanged
• ✅ All other OpenAI features - unchanged
• ✅ Other AI SDK providers - unaffected

---

Why The Original Code Failed

The Streaming Logic (Intentionally Not Modified)

// Lines 604-656 (unchanged)
if (toolCall.function.arguments.length > 0) {
  controller.enqueue({ type: 'tool-input-delta', ... });
}

if (isParsableJson(toolCall.function.arguments)) {
  controller.enqueue({ type: 'tool-call', ... });
  toolCall.hasFinished = true;
}

Why this is intentionally left unchanged:

This code handles incremental streaming:

Chunk 1: arguments: ""
Chunk 2: arguments: "{"
Chunk 3: arguments: "{\"location"
Chunk 4: arguments: "{\"location\":\"SF\"}"

If we normalized "" to "{}" here, it would:

1. Make isParsableJson return true on first chunk
2. Mark hasFinished = true immediately
3. Block subsequent argument chunks from being processed

Solution: Only normalize in two places:

1. doGenerate - No incremental building needed
2. Flush handler - After all chunks received

---

Implementation Notes

Type Safety

The arguments field is typed as string in OpenAI's API:

function: { name: string; arguments: string };

This means:

• It's always a string (never null/undefined)
• No null checks needed
• No non-null assertions needed

Performance

The normalization is minimal:

toolCall.function.arguments.trim() || '{}'

Cost per tool call:

• One string trim operation (~O(n) where n = string length)
• One boolean check (empty string)
• One fallback assignment (if needed)

For typical tool calls: < 0.1ms

Backward Compatibility

This change is fully backward compatible:

• Empty string now works (was broken)
• Valid arguments still work (unchanged)
• Streaming behavior preserved (unchanged)
• Public API unchanged (internal fix only)

---

Related Issues

• Original issue: @ai-sdk/openai streamText can't use tools/functions with no arguments. #5658
• Related Ollama issue: The stream mode doesnt work with Function Calling ollama/ollama#8887
• Contributor asking for update: @ai-sdk/openai streamText can't use tools/functions with no arguments. #5658 (comment)

---

Checklist

• ✅ Bug reproduced with test
• ✅ Fix implemented
• ✅ All reproduction tests passing (7/7)
• ✅ All existing tests passing (453/456, 3 pre-existing failures)
• ✅ Dependent packages tested (218/218 passing)
• ✅ Core integration tested (1468/1468 passing)
• ✅ Edge cases covered
• ✅ Documentation written
• ✅ No breaking changes

[vercel]

Additional Suggestion:

The streaming code doesn't normalize tool call arguments like the flush handler does, creating inconsistent behavior when providers send JSON with surrounding whitespace (e.g., " {} ").

View Details

📝 Patch Details

diff --git a/packages/openai/src/chat/openai-chat-language-model.ts b/packages/openai/src/chat/openai-chat-language-model.ts
index 3d9495377..1f05252fd 100644
--- a/packages/openai/src/chat/openai-chat-language-model.ts
+++ b/packages/openai/src/chat/openai-chat-language-model.ts
@@ -616,6 +616,10 @@ export class OpenAIChatLanguageModel implements LanguageModelV3 {
                     // check if tool call is complete
                     // (some providers send the full tool call in one chunk):
                     if (isParsableJson(toolCall.function.arguments)) {
+                      // normalize empty/whitespace arguments to empty object:
+                      const normalizedArguments =
+                        toolCall.function.arguments.trim() || '{}';
+
                       controller.enqueue({
                         type: 'tool-input-end',
                         id: toolCall.id,
@@ -625,7 +629,7 @@ export class OpenAIChatLanguageModel implements LanguageModelV3 {
                         type: 'tool-call',
                         toolCallId: toolCall.id ?? generateId(),
                         toolName: toolCall.function.name,
-                        input: toolCall.function.arguments,
+                        input: normalizedArguments,
                       });
                       toolCall.hasFinished = true;
                     }
@@ -659,6 +663,10 @@ export class OpenAIChatLanguageModel implements LanguageModelV3 {
                   toolCall.function?.arguments != null &&
                   isParsableJson(toolCall.function.arguments)
                 ) {
+                  // normalize empty/whitespace arguments to empty object:
+                  const normalizedArguments =
+                    toolCall.function.arguments.trim() || '{}';
+
                   controller.enqueue({
                     type: 'tool-input-end',
                     id: toolCall.id,
@@ -668,7 +676,7 @@ export class OpenAIChatLanguageModel implements LanguageModelV3 {
                     type: 'tool-call',
                     toolCallId: toolCall.id ?? generateId(),
                     toolName: toolCall.function.name,
-                    input: toolCall.function.arguments,
+                    input: normalizedArguments,
                   });
                   toolCall.hasFinished = true;
                 }

Analysis

Streaming tool calls don't normalize whitespace-padded JSON arguments

What fails: OpenAIChatLanguageModel.doStream() emits tool-call events with non-normalized arguments when providers send JSON with surrounding whitespace (e.g., " {} "), while the flush handler normalizes identical arguments, creating inconsistency.

How to reproduce:

// Provider sends: arguments: " {} " (with spaces)
const { stream } = await model.doStream({
  tools: [{ type: 'function', name: 'test', inputSchema: { type: 'object', properties: {} } }],
  prompt: TEST_PROMPT,
});
const result = await convertReadableStreamToArray(stream);
const toolCall = result.find(r => r.type === 'tool-call');
console.log(toolCall.input); // Actual: " {} ", Expected: "{}"

Result: Tool call receives " {} " (with surrounding spaces) during streaming.

Expected: Tool call should receive "{}" (normalized), matching the behavior in the flush handler (lines 693-716) which applies trim() || '{}' normalization.

Root cause: Lines 618-631 and 657-674 emit tool-call events with raw toolCall.function.arguments directly, while line 700 normalizes pending tool calls: const normalizedArguments = toolCall.function.arguments.trim() || '{}';. The inconsistency occurs because isParsableJson() accepts whitespace-padded JSON (JSON.parse silently trims whitespace), allowing streaming path to emit non-normalized arguments that should be normalized.

Fix applied: Added normalization to both streaming emission points to match the flush handler pattern, ensuring consistent behavior regardless of whether tool call completes during streaming or in the flush handler.