feat: enrich task record details

apps/api/internal/clients/helpers.go

@@ -1,6 +1,8 @@
 package clients
 
 import (
+	"bufio"
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -48,6 +50,7 @@ func decodeHTTPResponse(resp *http.Response) (map[string]any, error) {
 			Code:       statusCodeName(resp.StatusCode),
 			Message:    errorMessage(raw, resp.Status),
 			StatusCode: resp.StatusCode,
+			RequestID:  requestIDFromHTTPResponse(resp),
 			Retryable:  HTTPRetryable(resp.StatusCode),
 		}
 	}
@@ -61,6 +64,137 @@ func decodeHTTPResponse(resp *http.Response) (map[string]any, error) {
 	return out, nil
 }
 
+func decodeOpenAIStreamResponse(resp *http.Response, onDelta StreamDelta) (map[string]any, error) {
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		raw, _ := io.ReadAll(io.LimitReader(resp.Body, 16*1024*1024))
+		return nil, &ClientError{
+			Code:       statusCodeName(resp.StatusCode),
+			Message:    errorMessage(raw, resp.Status),
+			StatusCode: resp.StatusCode,
+			RequestID:  requestIDFromHTTPResponse(resp),
+			Retryable:  HTTPRetryable(resp.StatusCode),
+		}
+	}
+	if result, ok, err := decodeOpenAIStreamReader(resp.Body, onDelta); ok || err != nil {
+		return result, err
+	}
+	return map[string]any{}, nil
+}
+
+func decodeOpenAIStreamReader(reader io.Reader, onDelta StreamDelta) (map[string]any, bool, error) {
+	scanner := bufio.NewScanner(reader)
+	scanner.Buffer(make([]byte, 0, 64*1024), 16*1024*1024)
+	rawLines := make([]string, 0)
+	parts := make([]string, 0)
+	var last map[string]any
+	var usage Usage
+	for scanner.Scan() {
+		rawLine := scanner.Text()
+		rawLines = append(rawLines, rawLine)
+		line := strings.TrimSpace(rawLine)
+		if !strings.HasPrefix(line, "data:") {
+			continue
+		}
+		payload := strings.TrimSpace(strings.TrimPrefix(line, "data:"))
+		if payload == "" || payload == "[DONE]" {
+			continue
+		}
+		var event map[string]any
+		if err := json.Unmarshal([]byte(payload), &event); err != nil {
+			continue
+		}
+		last = event
+		if text := streamEventText(event); text != "" {
+			parts = append(parts, text)
+			if onDelta != nil {
+				if err := onDelta(text); err != nil {
+					return nil, true, err
+				}
+			}
+		}
+		if eventUsage := usageFromOpenAI(event); eventUsage.TotalTokens > 0 {
+			usage = eventUsage
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, true, &ClientError{Code: "stream_read_error", Message: err.Error(), Retryable: true}
+	}
+	if last == nil {
+		raw := []byte(strings.Join(rawLines, "\n"))
+		if len(raw) == 0 {
+			return map[string]any{}, true, nil
+		}
+		var out map[string]any
+		if err := json.Unmarshal(raw, &out); err != nil {
+			return nil, false, nil
+		}
+		return out, true, nil
+	}
+	return buildOpenAIStreamResult(last, parts, usage), true, nil
+}
+
+func decodeOpenAIStream(raw []byte) (map[string]any, bool) {
+	if !bytes.Contains(raw, []byte("data:")) {
+		return nil, false
+	}
+	result, ok, err := decodeOpenAIStreamReader(bytes.NewReader(raw), nil)
+	return result, ok && err == nil
+}
+
+func buildOpenAIStreamResult(last map[string]any, parts []string, usage Usage) map[string]any {
+	if len(parts) == 0 {
+		return last
+	}
+	var out map[string]any
+	out = map[string]any{
+		"id":     stringFromAny(firstPresent(last["id"], "chatcmpl-stream")),
+		"object": "chat.completion",
+		"model":  stringFromAny(last["model"]),
+		"choices": []any{map[string]any{
+			"index": 0,
+			"message": map[string]any{
+				"role":    "assistant",
+				"content": strings.Join(parts, ""),
+			},
+			"finish_reason": "stop",
+		}},
+	}
+	if usage.TotalTokens > 0 {
+		out["usage"] = map[string]any{
+			"prompt_tokens":     usage.InputTokens,
+			"completion_tokens": usage.OutputTokens,
+			"total_tokens":      usage.TotalTokens,
+		}
+	}
+	return out
+}
+
+func streamEventText(event map[string]any) string {
+	if choices, ok := event["choices"].([]any); ok {
+		for _, rawChoice := range choices {
+			choice, _ := rawChoice.(map[string]any)
+			if delta, ok := choice["delta"].(map[string]any); ok {
+				if content, ok := delta["content"].(string); ok {
+					return content
+				}
+			}
+			if message, ok := choice["message"].(map[string]any); ok {
+				if content, ok := message["content"].(string); ok {
+					return content
+				}
+			}
+		}
+	}
+	if delta, ok := event["delta"].(string); ok {
+		return delta
+	}
+	if text, ok := event["output_text"].(string); ok {
+		return text
+	}
+	return ""
+}
+
 func usageFromOpenAI(result map[string]any) Usage {
 	usage, _ := result["usage"].(map[string]any)
 	input := intFromAny(firstPresent(usage["prompt_tokens"], usage["input_tokens"]))
@@ -72,6 +206,34 @@ func usageFromOpenAI(result map[string]any) Usage {
 	return Usage{InputTokens: input, OutputTokens: output, TotalTokens: total}
 }
 
+func requestIDFromHTTPResponse(resp *http.Response) string {
+	if resp == nil {
+		return ""
+	}
+	for _, key := range []string{
+		"x-request-id",
+		"x-requestid",
+		"request-id",
+		"x-amzn-requestid",
+		"x-amz-request-id",
+		"cf-ray",
+	} {
+		if value := strings.TrimSpace(resp.Header.Get(key)); value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func requestIDFromResult(result map[string]any) string {
+	for _, key := range []string{"request_id", "requestId", "id", "response_id", "responseId"} {
+		if value := strings.TrimSpace(stringFromAny(result[key])); value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
 func intFromAny(value any) int {
 	switch typed := value.(type) {
 	case float64:
@@ -85,6 +247,13 @@ func intFromAny(value any) int {
 	}
 }
 
+func stringFromAny(value any) string {
+	if text, ok := value.(string); ok {
+		return text
+	}
+	return ""
+}
+
 func firstPresent(values ...any) any {
 	for _, value := range values {
 		if value != nil {