Fix Responses API parallel tool calls and add store parameter (#5571)

Author: colegottdank

packages/__tests__/llm-mapper/openai-chat-to-responses-converters.test.ts

@@ -297,6 +297,82 @@ describe("OpenAI Chat -> Responses converters", () => {
       expect(tool.content).toBe("4");
     });
 
+    it("groups parallel function_call items into a single assistant message with multiple tool_calls", () => {
+      const req: ResponsesRequestBody = {
+        model: "gpt-4o-mini",
+        input: [
+          { type: "message", role: "user", content: "Search for healthcare and finance projects" },
+          { type: "function_call", call_id: "fc_call1", name: "search_projects", arguments: "{\"queries\": [\"healthcare\"]}" },
+          { type: "function_call", call_id: "fc_call2", name: "search_projects", arguments: "{\"queries\": [\"finance\"]}" },
+          { type: "function_call_output", call_id: "fc_call1", output: "{\"projects\": [{\"name\": \"Healthcare Strategy\"}]}" },
+          { type: "function_call_output", call_id: "fc_call2", output: "{\"projects\": [{\"name\": \"Finance Overview\"}]}" },
+        ],
+      };
+      const oai = toChatCompletions(req);
+
+      // Should have: user message, ONE assistant message with 2 tool_calls, 2 tool messages
+      expect(oai.messages?.length).toBe(4);
+
+      // First message: user
+      expect(oai.messages?.[0]).toMatchObject({ role: "user", content: "Search for healthcare and finance projects" });
+
+      // Second message: assistant with BOTH tool_calls in a single message
+      const assistant = oai.messages?.[1] as any;
+      expect(assistant.role).toBe("assistant");
+      expect(assistant.tool_calls?.length).toBe(2);
+      expect(assistant.tool_calls?.[0]).toMatchObject({
+        id: "fc_call1",
+        type: "function",
+        function: { name: "search_projects", arguments: "{\"queries\": [\"healthcare\"]}" }
+      });
+      expect(assistant.tool_calls?.[1]).toMatchObject({
+        id: "fc_call2",
+        type: "function",
+        function: { name: "search_projects", arguments: "{\"queries\": [\"finance\"]}" }
+      });
+
+      // Third and fourth messages: tool responses
+      const tool1 = oai.messages?.[2] as any;
+      expect(tool1.role).toBe("tool");
+      expect(tool1.tool_call_id).toBe("fc_call1");
+
+      const tool2 = oai.messages?.[3] as any;
+      expect(tool2.role).toBe("tool");
+      expect(tool2.tool_call_id).toBe("fc_call2");
+    });
+
+    it("handles multiple separate tool call rounds correctly", () => {
+      const req: ResponsesRequestBody = {
+        model: "gpt-4o-mini",
+        input: [
+          { type: "message", role: "user", content: "Do two things" },
+          // First round: 2 parallel calls
+          { type: "function_call", call_id: "call_a", name: "func_a", arguments: "{}" },
+          { type: "function_call", call_id: "call_b", name: "func_b", arguments: "{}" },
+          { type: "function_call_output", call_id: "call_a", output: "result_a" },
+          { type: "function_call_output", call_id: "call_b", output: "result_b" },
+          // Second round: 1 call
+          { type: "function_call", call_id: "call_c", name: "func_c", arguments: "{}" },
+          { type: "function_call_output", call_id: "call_c", output: "result_c" },
+        ],
+      };
+      const oai = toChatCompletions(req);
+
+      // Should have: user, assistant (2 calls), tool, tool, assistant (1 call), tool
+      expect(oai.messages?.length).toBe(6);
+
+      // First assistant message should have 2 tool_calls
+      const assistant1 = oai.messages?.[1] as any;
+      expect(assistant1.role).toBe("assistant");
+      expect(assistant1.tool_calls?.length).toBe(2);
+
+      // Second assistant message should have 1 tool_call
+      const assistant2 = oai.messages?.[4] as any;
+      expect(assistant2.role).toBe("assistant");
+      expect(assistant2.tool_calls?.length).toBe(1);
+      expect(assistant2.tool_calls?.[0].id).toBe("call_c");
+    });
+
     it("maps Responses tools (flattened) to Chat tools (nested)", () => {
       const req = {
         model: "gpt-4o-mini",

packages/llm-mapper/transform/providers/responses/request/toChatCompletions.ts

@@ -52,9 +52,26 @@ function convertContentParts(
   });
 }
 
+/**
+ * Collects consecutive items of a specific type from the input array.
+ * Returns the collected items and the index after the last collected item.
+ */
+function collectConsecutiveByType<T extends ResponsesInputItem>(
+  input: ResponsesInputItem[],
+  startIndex: number,
+  type: string
+): { items: T[]; endIndex: number } {
+  const items: T[] = [];
+  let index = startIndex;
+  while (index < input.length && input[index].type === type) {
+    items.push(input[index] as T);
+    index++;
+  }
+  return { items, endIndex: index };
+}
+
 function convertInputToMessages(input: ResponsesRequestBody["input"]) {
   const messages: NonNullable<HeliconeChatCreateParams["messages"]> = [];
-  // emit an assistant message for each function_call item to simplify typing
   if (typeof input === "string") {
     messages.push({ role: "user", content: input });
     return messages;
@@ -63,22 +80,29 @@ function convertInputToMessages(input: ResponsesRequestBody["input"]) {
   for (let i = 0; i < input.length; i++) {
     const item: ResponsesInputItem = input[i];
 
+    // Handle function_call: group consecutive function_call items into a single assistant message
+    // with multiple tool_calls. This is required by Chat Completions format for parallel tool calls.
     if (item.type === "function_call") {
-      const fc = item;
+      const { items: functionCalls, endIndex } = collectConsecutiveByType<
+        Extract<ResponsesInputItem, { type: "function_call" }>
+      >(input, i, "function_call");
+
+      const toolCalls = functionCalls.map((fc, idx) => ({
+        id: fc.id || fc.call_id || `call_${i + idx}`,
+        type: "function" as const,
+        function: {
+          name: fc.name,
+          arguments: fc.arguments ?? "{}",
+        },
+      }));
+
       messages.push({
         role: "assistant",
         content: "",
-        tool_calls: [
-          {
-            id: fc.id || fc.call_id || `call_${i}`,
-            type: "function",
-            function: {
-              name: fc.name,
-              arguments: fc.arguments ?? "{}",
-            },
-          },
-        ],
+        tool_calls: toolCalls,
       });
+
+      i = endIndex - 1;
       continue;
     }
 

worker/src/lib/ai-gateway/validators/responses-types.ts

@@ -686,7 +686,7 @@ const CreateResponse = CreateModelResponseProperties.merge(ResponseProperties)
       input: InputParam,
       include: z.union([z.array(IncludeEnum), z.null()]),
       parallel_tool_calls: z.union([z.boolean(), z.null()]),
-      // store was removed
+      store: z.boolean().optional(),
       instructions: z.union([z.string(), z.null()]),
       stream: z.union([z.boolean(), z.null()]),
       stream_options: ResponseStreamOptions,