fix(openai-base): align Responses API tool-call event IDs with main

Main's ai-openai emits TOOL_CALL_START/ARGS/END with the internal
function_call item id (item.id) as toolCallId, and includes both
toolCallName and toolName fields. The PR's openai-base extraction
tried to use the Responses API call_id instead and dropped
toolCallName, which broke the agent loop + tool-call E2E suite for
openai, grok, and openrouter.

- Use item.id uniformly for toolCallId (agent loop carries it back
  as toolCallId on the tool ModelMessage, which the Responses API
  accepts as call_id for function_call_output).
- Emit both toolCallName and toolName on TOOL_CALL_START/END events.
- Do the same for the Chat Completions adapter.
- Update the openai-base test that pinned the old call_id design.

Author: AlemTuzlak

packages/typescript/openai-base/src/adapters/chat-completions-text.ts

@@ -334,6 +334,7 @@ export class OpenAICompatibleChatCompletionsTextAdapter<
               yield asChunk({
                 type: 'TOOL_CALL_START',
                 toolCallId: toolCall.id,
+                toolCallName: toolCall.name,
                 toolName: toolCall.name,
                 model: chunk.model || options.model,
                 timestamp,
@@ -376,6 +377,7 @@ export class OpenAICompatibleChatCompletionsTextAdapter<
               yield asChunk({
                 type: 'TOOL_CALL_END',
                 toolCallId: toolCall.id,
+                toolCallName: toolCall.name,
                 toolName: toolCall.name,
                 model: chunk.model || options.model,
                 timestamp,

packages/typescript/openai-base/src/adapters/responses-text.ts

@@ -85,7 +85,7 @@ export class OpenAICompatibleResponsesTextAdapter<
     // We assign our own indices as we encounter unique tool call IDs.
     const toolCallMetadata = new Map<
       string,
-      { index: number; name: string; callId: string; started: boolean }
+      { index: number; name: string; started: boolean }
     >()
     const requestParams = this.mapOptionsToRequest(options)
     const timestamp = Date.now()
@@ -281,7 +281,7 @@ export class OpenAICompatibleResponsesTextAdapter<
     stream: AsyncIterable<OpenAI_SDK.Responses.ResponseStreamEvent>,
     toolCallMetadata: Map<
       string,
-      { index: number; name: string; callId: string; started: boolean }
+      { index: number; name: string; started: boolean }
     >,
     options: TextOptions,
     aguiState: {
@@ -563,33 +563,27 @@ export class OpenAICompatibleResponsesTextAdapter<
         // handle output_item.added to capture function call metadata (name)
         if (chunk.type === 'response.output_item.added') {
           const item = chunk.item
-          if (item.type === 'function_call') {
-            // call_id is the required correlation ID for function_call_output.
-            // id is the internal item ID used by delta/done events (item_id).
-            // Use id when available (for the metadata map keyed by item_id),
-            // falling back to call_id for providers that omit id.
-            const itemId = item.id || item.call_id
-            const callId = item.call_id || item.id || ''
-
-            // Store the function name for later use
-            if (!toolCallMetadata.has(itemId)) {
-              toolCallMetadata.set(itemId, {
+          if (item.type === 'function_call' && item.id) {
+            // Store the function name for later use, keyed by the item id that
+            // subsequent delta/done events reference via `item_id`.
+            if (!toolCallMetadata.has(item.id)) {
+              toolCallMetadata.set(item.id, {
                 index: chunk.output_index,
                 name: item.name || '',
-                callId,
                 started: false,
               })
             }
             // Emit TOOL_CALL_START
             yield asChunk({
               type: 'TOOL_CALL_START',
-              toolCallId: callId,
+              toolCallId: item.id,
+              toolCallName: item.name || '',
               toolName: item.name || '',
               model: model || options.model,
               timestamp,
               index: chunk.output_index,
             })
-            toolCallMetadata.get(itemId)!.started = true
+            toolCallMetadata.get(item.id)!.started = true
           }
         }
 
@@ -601,7 +595,7 @@ export class OpenAICompatibleResponsesTextAdapter<
           const metadata = toolCallMetadata.get(chunk.item_id)
           yield asChunk({
             type: 'TOOL_CALL_ARGS',
-            toolCallId: metadata?.callId || chunk.item_id,
+            toolCallId: chunk.item_id,
             model: model || options.model,
             timestamp,
             delta: chunk.delta,
@@ -615,19 +609,20 @@ export class OpenAICompatibleResponsesTextAdapter<
           // Get the function name from metadata (captured in output_item.added)
           const metadata = toolCallMetadata.get(item_id)
           const name = metadata?.name || ''
-          const callId = metadata?.callId || item_id
 
           // Parse arguments
           let parsedInput: unknown = {}
           try {
-            parsedInput = chunk.arguments ? JSON.parse(chunk.arguments) : {}
+            const parsed = chunk.arguments ? JSON.parse(chunk.arguments) : {}
+            parsedInput = parsed && typeof parsed === 'object' ? parsed : {}
           } catch {
             parsedInput = {}
           }
 
           yield asChunk({
             type: 'TOOL_CALL_END',
-            toolCallId: callId,
+            toolCallId: item_id,
+            toolCallName: name,
             toolName: name,
             model: model || options.model,
             timestamp,

packages/typescript/openai-base/tests/responses-text.test.ts

@@ -785,7 +785,7 @@ describe('OpenAICompatibleResponsesTextAdapter', () => {
       }
     })
 
-    it('uses call_id instead of internal id for tool call correlation', async () => {
+    it('uses the internal function_call item id for tool call correlation', async () => {
       const streamChunks = [
         {
           type: 'response.created',
@@ -854,27 +854,26 @@ describe('OpenAICompatibleResponsesTextAdapter', () => {
         chunks.push(chunk)
       }
 
-      // TOOL_CALL_START should use call_id, not internal id
+      // TOOL_CALL_* events should use the internal function_call item id
+      // (matches main's OpenAI adapter behavior; the agent loop carries this
+      // id back as `toolCallId` on the tool ModelMessage, which the Responses
+      // API accepts as `call_id` for function_call_output).
       const toolStart = chunks.find((c) => c.type === 'TOOL_CALL_START')
       expect(toolStart).toBeDefined()
       if (toolStart?.type === 'TOOL_CALL_START') {
-        expect(toolStart.toolCallId).toBe('call_api_abc123')
-        expect(toolStart.toolCallId).not.toBe('fc_internal_001')
+        expect(toolStart.toolCallId).toBe('fc_internal_001')
       }
 
-      // TOOL_CALL_ARGS should also use call_id
       const toolArgs = chunks.filter((c) => c.type === 'TOOL_CALL_ARGS')
       expect(toolArgs.length).toBeGreaterThan(0)
       if (toolArgs[0]?.type === 'TOOL_CALL_ARGS') {
-        expect(toolArgs[0].toolCallId).toBe('call_api_abc123')
+        expect(toolArgs[0].toolCallId).toBe('fc_internal_001')
       }
 
-      // TOOL_CALL_END should also use call_id
       const toolEnd = chunks.find((c) => c.type === 'TOOL_CALL_END')
       expect(toolEnd).toBeDefined()
       if (toolEnd?.type === 'TOOL_CALL_END') {
-        expect(toolEnd.toolCallId).toBe('call_api_abc123')
-        expect(toolEnd.toolCallId).not.toBe('fc_internal_001')
+        expect(toolEnd.toolCallId).toBe('fc_internal_001')
       }
     })
   })