feat: Introduce stable call_id for OpenAI function_call and tool_calls events in streaming output, including reasoning text.

internal/format/openai/render.go

@@ -1,6 +1,7 @@
 package openai
 
 import (
+	"encoding/json"
 	"strings"
 	"time"
 
@@ -47,28 +48,24 @@ func BuildResponseObject(responseID, model, finalPrompt, finalThinking, finalTex
 	// produced a standalone structured payload. This prevents accidental
 	// empty output_text on normal prose that merely contains tool_call-like text.
 	detected := util.ParseStandaloneToolCalls(finalText, toolNames)
-	toolCallsFromThinking := false
 	if len(detected) == 0 && strings.TrimSpace(finalThinking) != "" {
 		detected = util.ParseStandaloneToolCalls(finalThinking, toolNames)
-		toolCallsFromThinking = len(detected) > 0
 	}
 	exposedOutputText := finalText
 	output := make([]any, 0, 2)
 	if len(detected) > 0 {
-		if !toolCallsFromThinking || strings.TrimSpace(finalText) != "" {
-			exposedOutputText = ""
-		} else {
-			exposedOutputText = finalThinking
-		}
+		exposedOutputText = ""
 		if strings.TrimSpace(finalThinking) != "" {
 			output = append(output, map[string]any{
 				"type": "reasoning",
 				"text": finalThinking,
 			})
 		}
+		formatted := util.FormatOpenAIToolCalls(detected)
+		output = append(output, toResponsesFunctionCallItems(formatted)...)
 		output = append(output, map[string]any{
 			"type":       "tool_calls",
-			"tool_calls": util.FormatOpenAIToolCalls(detected),
+			"tool_calls": formatted,
 		})
 	} else {
 		content := make([]any, 0, 2)
@@ -114,6 +111,54 @@ func BuildResponseObject(responseID, model, finalPrompt, finalThinking, finalTex
 	}
 }
 
+func toResponsesFunctionCallItems(toolCalls []map[string]any) []any {
+	if len(toolCalls) == 0 {
+		return nil
+	}
+	out := make([]any, 0, len(toolCalls))
+	for _, tc := range toolCalls {
+		callID, _ := tc["id"].(string)
+		if strings.TrimSpace(callID) == "" {
+			callID = "call_" + strings.ReplaceAll(uuid.NewString(), "-", "")
+		}
+		name := ""
+		args := "{}"
+		if fn, ok := tc["function"].(map[string]any); ok {
+			if n, _ := fn["name"].(string); strings.TrimSpace(n) != "" {
+				name = n
+			}
+			if a, _ := fn["arguments"].(string); strings.TrimSpace(a) != "" {
+				args = a
+			}
+		}
+		out = append(out, map[string]any{
+			"id":        "fc_" + strings.ReplaceAll(uuid.NewString(), "-", ""),
+			"type":      "function_call",
+			"call_id":   callID,
+			"name":      name,
+			"arguments": normalizeJSONString(args),
+			"status":    "completed",
+		})
+	}
+	return out
+}
+
+func normalizeJSONString(raw string) string {
+	s := strings.TrimSpace(raw)
+	if s == "" {
+		return "{}"
+	}
+	var v any
+	if err := json.Unmarshal([]byte(s), &v); err != nil {
+		return raw
+	}
+	b, err := json.Marshal(v)
+	if err != nil {
+		return raw
+	}
+	return string(b)
+}
+
 func BuildChatStreamDeltaChoice(index int, delta map[string]any) map[string]any {
 	return map[string]any{
 		"delta": delta,
@@ -159,49 +204,105 @@ func BuildChatUsage(finalPrompt, finalThinking, finalText string) map[string]any
 
 func BuildResponsesCreatedPayload(responseID, model string) map[string]any {
 	return map[string]any{
-		"type":   "response.created",
-		"id":     responseID,
-		"object": "response",
-		"model":  model,
-		"status": "in_progress",
+		"type":        "response.created",
+		"id":          responseID,
+		"response_id": responseID,
+		"object":      "response",
+		"model":       model,
+		"status":      "in_progress",
 	}
 }
 
 func BuildResponsesTextDeltaPayload(responseID, delta string) map[string]any {
 	return map[string]any{
-		"type":  "response.output_text.delta",
-		"id":    responseID,
-		"delta": delta,
+		"type":        "response.output_text.delta",
+		"id":          responseID,
+		"response_id": responseID,
+		"delta":       delta,
 	}
 }
 
 func BuildResponsesReasoningDeltaPayload(responseID, delta string) map[string]any {
 	return map[string]any{
-		"type":  "response.reasoning.delta",
-		"id":    responseID,
-		"delta": delta,
+		"type":        "response.reasoning.delta",
+		"id":          responseID,
+		"response_id": responseID,
+		"delta":       delta,
+	}
+}
+
+func BuildResponsesReasoningTextDeltaPayload(responseID, itemID string, outputIndex, contentIndex int, delta string) map[string]any {
+	return map[string]any{
+		"type":          "response.reasoning_text.delta",
+		"id":            responseID,
+		"response_id":   responseID,
+		"item_id":       itemID,
+		"output_index":  outputIndex,
+		"content_index": contentIndex,
+		"delta":         delta,
+	}
+}
+
+func BuildResponsesReasoningTextDonePayload(responseID, itemID string, outputIndex, contentIndex int, text string) map[string]any {
+	return map[string]any{
+		"type":          "response.reasoning_text.done",
+		"id":            responseID,
+		"response_id":   responseID,
+		"item_id":       itemID,
+		"output_index":  outputIndex,
+		"content_index": contentIndex,
+		"text":          text,
 	}
 }
 
 func BuildResponsesToolCallDeltaPayload(responseID string, toolCalls []map[string]any) map[string]any {
 	return map[string]any{
-		"type":       "response.output_tool_call.delta",
-		"id":         responseID,
-		"tool_calls": toolCalls,
+		"type":        "response.output_tool_call.delta",
+		"id":          responseID,
+		"response_id": responseID,
+		"tool_calls":  toolCalls,
 	}
 }
 
 func BuildResponsesToolCallDonePayload(responseID string, toolCalls []map[string]any) map[string]any {
 	return map[string]any{
-		"type":       "response.output_tool_call.done",
-		"id":         responseID,
-		"tool_calls": toolCalls,
+		"type":        "response.output_tool_call.done",
+		"id":          responseID,
+		"response_id": responseID,
+		"tool_calls":  toolCalls,
+	}
+}
+
+func BuildResponsesFunctionCallArgumentsDeltaPayload(responseID, itemID string, outputIndex int, callID, delta string) map[string]any {
+	return map[string]any{
+		"type":         "response.function_call_arguments.delta",
+		"id":           responseID,
+		"response_id":  responseID,
+		"item_id":      itemID,
+		"output_index": outputIndex,
+		"call_id":      callID,
+		"delta":        delta,
+	}
+}
+
+func BuildResponsesFunctionCallArgumentsDonePayload(responseID, itemID string, outputIndex int, callID, name, arguments string) map[string]any {
+	return map[string]any{
+		"type":         "response.function_call_arguments.done",
+		"id":           responseID,
+		"response_id":  responseID,
+		"item_id":      itemID,
+		"output_index": outputIndex,
+		"call_id":      callID,
+		"name":         name,
+		"arguments":    normalizeJSONString(arguments),
 	}
 }
 
 func BuildResponsesCompletedPayload(response map[string]any) map[string]any {
+	responseID, _ := response["id"].(string)
 	return map[string]any{
-		"type":     "response.completed",
-		"response": response,
+		"type":        "response.completed",
+		"response_id": responseID,
+		"response":    response,
 	}
 }

internal/format/openai/render_test.go

@@ -21,16 +21,23 @@ func TestBuildResponseObjectToolCallsFollowChatShape(t *testing.T) {
 	}
 
 	output, _ := obj["output"].([]any)
-	if len(output) != 1 {
-		t.Fatalf("expected one tool_calls wrapper, got %#v", obj["output"])
+	if len(output) != 2 {
+		t.Fatalf("expected function_call + tool_calls wrapper, got %#v", obj["output"])
 	}
 
 	first, _ := output[0].(map[string]any)
-	if first["type"] != "tool_calls" {
-		t.Fatalf("expected first output item type tool_calls, got %#v", first["type"])
+	if first["type"] != "function_call" {
+		t.Fatalf("expected first output item type function_call, got %#v", first["type"])
+	}
+	if first["call_id"] == "" {
+		t.Fatalf("expected function_call item to have call_id, got %#v", first)
+	}
+	second, _ := output[1].(map[string]any)
+	if second["type"] != "tool_calls" {
+		t.Fatalf("expected second output item type tool_calls, got %#v", second["type"])
 	}
 	var toolCalls []map[string]any
-	switch v := first["tool_calls"].(type) {
+	switch v := second["tool_calls"].(type) {
 	case []map[string]any:
 		toolCalls = v
 	case []any:
@@ -43,7 +50,7 @@ func TestBuildResponseObjectToolCallsFollowChatShape(t *testing.T) {
 		}
 	}
 	if len(toolCalls) != 1 {
-		t.Fatalf("expected one tool call, got %#v", first["tool_calls"])
+		t.Fatalf("expected one tool call, got %#v", second["tool_calls"])
 	}
 	tc := toolCalls[0]
 	if tc["type"] != "function" || tc["id"] == "" {
@@ -132,15 +139,19 @@ func TestBuildResponseObjectDetectsToolCallFromThinkingChannel(t *testing.T) {
 	)
 
 	output, _ := obj["output"].([]any)
-	if len(output) != 2 {
-		t.Fatalf("expected reasoning + tool_calls outputs, got %#v", obj["output"])
+	if len(output) != 3 {
+		t.Fatalf("expected reasoning + function_call + tool_calls outputs, got %#v", obj["output"])
 	}
 	first, _ := output[0].(map[string]any)
 	if first["type"] != "reasoning" {
 		t.Fatalf("expected first output reasoning, got %#v", first["type"])
 	}
 	second, _ := output[1].(map[string]any)
-	if second["type"] != "tool_calls" {
-		t.Fatalf("expected second output tool_calls, got %#v", second["type"])
+	if second["type"] != "function_call" {
+		t.Fatalf("expected second output function_call, got %#v", second["type"])
+	}
+	third, _ := output[2].(map[string]any)
+	if third["type"] != "tool_calls" {
+		t.Fatalf("expected third output tool_calls, got %#v", third["type"])
 	}
 }