Delete internal directory

internal/openai/claude_reasoning_roundtrip.go

@@ -1,81 +0,0 @@
-package openai
-
-import (
-	"encoding/json"
-	"strings"
-)
-
-// claudeReasoningRoundTripSep separates human-readable reasoning from a JSON payload of
-// Anthropic thinking blocks (with signatures) for multi-turn extended thinking + tools.
-// Not shown in UI (see DisplayReasoningContent).
-const claudeReasoningRoundTripSep = "\n---CSAI_CLAUDE_THINKING_BLOCKS---\n"
-
-// DisplayReasoningContent returns reasoning text suitable for the UI (strips internal
-// Claude round-trip JSON suffix). Safe for DeepSeek/plain reasoning strings (no-op).
-func DisplayReasoningContent(s string) string {
-	s = strings.TrimSpace(s)
-	if s == "" {
-		return ""
-	}
-	i := strings.LastIndex(s, claudeReasoningRoundTripSep)
-	if i < 0 {
-		return s
-	}
-	return strings.TrimSpace(s[:i])
-}
-
-func appendClaudeReasoningRoundTrip(display string, blocks []claudeContentBlock) string {
-	var payload []map[string]string
-	for _, b := range blocks {
-		if b.Type != "thinking" {
-			continue
-		}
-		payload = append(payload, map[string]string{
-			"type":      b.Type,
-			"thinking":  b.Thinking,
-			"signature": b.Signature,
-		})
-	}
-	if len(payload) == 0 {
-		return strings.TrimSpace(display)
-	}
-	js, err := json.Marshal(payload)
-	if err != nil {
-		return strings.TrimSpace(display)
-	}
-	d := strings.TrimSpace(display)
-	if d == "" {
-		return claudeReasoningRoundTripSep + string(js)
-	}
-	return d + claudeReasoningRoundTripSep + string(js)
-}
-
-// parseClaudeReasoningAssistantBlocks extracts Anthropic thinking blocks from an OpenAI-style
-// reasoning_content string. When no suffix is present, blocks is nil (caller must not invent signatures).
-func parseClaudeReasoningAssistantBlocks(reasoningContent string) (display string, blocks []claudeContentBlock) {
-	reasoningContent = strings.TrimSpace(reasoningContent)
-	if reasoningContent == "" {
-		return "", nil
-	}
-	idx := strings.LastIndex(reasoningContent, claudeReasoningRoundTripSep)
-	if idx < 0 {
-		return reasoningContent, nil
-	}
-	display = strings.TrimSpace(reasoningContent[:idx])
-	jsonPart := strings.TrimSpace(reasoningContent[idx+len(claudeReasoningRoundTripSep):])
-	var arr []struct {
-		Type      string `json:"type"`
-		Thinking  string `json:"thinking"`
-		Signature string `json:"signature"`
-	}
-	if err := json.Unmarshal([]byte(jsonPart), &arr); err != nil {
-		return reasoningContent, nil
-	}
-	for _, x := range arr {
-		if x.Type != "thinking" {
-			continue
-		}
-		blocks = append(blocks, claudeContentBlock{Type: "thinking", Thinking: x.Thinking, Signature: x.Signature})
-	}
-	return display, blocks
-}

internal/openai/claude_reasoning_roundtrip_test.go

@@ -1,102 +0,0 @@
-package openai
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-)
-
-func TestDisplayReasoningContent(t *testing.T) {
-	raw := "hello" + claudeReasoningRoundTripSep + `[{"type":"thinking","thinking":"x","signature":"sig"}]`
-	if d := DisplayReasoningContent(raw); d != "hello" {
-		t.Fatalf("got %q", d)
-	}
-	if DisplayReasoningContent("plain") != "plain" {
-		t.Fatal()
-	}
-}
-
-func TestAppendParseClaudeReasoningRoundTrip(t *testing.T) {
-	blocks := []claudeContentBlock{
-		{Type: "thinking", Thinking: "a", Signature: "s1"},
-		{Type: "thinking", Thinking: "b", Signature: "s2"},
-	}
-	s := appendClaudeReasoningRoundTrip("sum", blocks)
-	if !strings.Contains(s, claudeReasoningRoundTripSep) {
-		t.Fatal("missing sep")
-	}
-	display, back := parseClaudeReasoningAssistantBlocks(s)
-	if display != "sum" || len(back) != 2 {
-		t.Fatalf("display=%q len=%d", display, len(back))
-	}
-	if back[0].Signature != "s1" || back[1].Thinking != "b" {
-		t.Fatalf("%+v", back)
-	}
-}
-
-func TestConvertOpenAIToClaude_AssistantReasoningReplay(t *testing.T) {
-	rc := appendClaudeReasoningRoundTrip("vis", []claudeContentBlock{
-		{Type: "thinking", Thinking: "t1", Signature: "sig1"},
-	})
-	payload := map[string]interface{}{
-		"model": "claude-3-5-sonnet-latest",
-		"messages": []interface{}{
-			map[string]interface{}{
-				"role":              "assistant",
-				"content":           "out",
-				"reasoning_content": rc,
-			},
-		},
-	}
-	req, err := convertOpenAIToClaude(payload)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(req.Messages) != 1 {
-		t.Fatalf("messages=%d", len(req.Messages))
-	}
-	blocks := req.Messages[0].Content.Blocks
-	if len(blocks) < 2 {
-		t.Fatalf("blocks=%d", len(blocks))
-	}
-	if blocks[0].Type != "thinking" || blocks[0].Signature != "sig1" {
-		t.Fatalf("first block %+v", blocks[0])
-	}
-	foundText := false
-	for _, b := range blocks {
-		if b.Type == "text" && b.Text == "out" {
-			foundText = true
-		}
-	}
-	if !foundText {
-		t.Fatalf("blocks=%+v", blocks)
-	}
-}
-
-func TestClaudeToOpenAIResponseJSON_Thinking(t *testing.T) {
-	claudeBody := []byte(`{
-		"id":"msg_1","type":"message","role":"assistant","model":"x","stop_reason":"end_turn",
-		"content":[
-			{"type":"thinking","thinking":"step","signature":"sigx"},
-			{"type":"text","text":"hi"}
-		]
-	}`)
-	oai, err := claudeToOpenAIResponseJSON(claudeBody)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var wrap map[string]interface{}
-	if err := json.Unmarshal(oai, &wrap); err != nil {
-		t.Fatal(err)
-	}
-	choices := wrap["choices"].([]interface{})
-	ch0 := choices[0].(map[string]interface{})
-	msg := ch0["message"].(map[string]interface{})
-	rc, _ := msg["reasoning_content"].(string)
-	if !strings.Contains(rc, "step") || !strings.Contains(rc, claudeReasoningRoundTripSep) {
-		t.Fatalf("reasoning_content=%q", rc)
-	}
-	if msg["content"] != "hi" {
-		t.Fatal()
-	}
-}

internal/openai/eino_sse_sanitizer.go

@@ -1,149 +0,0 @@
-package openai
-
-// eino_sse_sanitizer.go 解决 Eino 走 meguminnnnnnnnn/go-openai SDK 时，
-// 中转站心跳/SSE 控制行累计 > 300 行触发 ErrTooManyEmptyStreamMessages
-// （报错文案: "stream has sent too many empty messages"）的问题。
-//
-// 触发链路:
-//   einoopenai.NewChatModel
-//     → eino-ext/libs/acl/openai → meguminnnnnnnnn/go-openai
-//     → streamReader.processLines() 对所有非 "data:" 行计数, > 300 即抛错。
-//
-// 中转站常见的非 data: 行（合法 SSE 但 SDK 不接受）:
-//   ":" / ": keepalive" / ": ping" / "event: ping" / "retry: 3000"
-//   以及思考型模型 prefill 期间穿插的大量心跳。
-//
-// 兜底策略: 在 HTTP transport 层把响应 Body 包一层 reader, 只放行 "data:"
-// 开头的行, 把心跳/注释/事件类型行就地吞掉。下游 SDK 永远见不到非 data: 行,
-// 计数器始终为 0, 该错误不可能再发生。
-//
-// 该层对调用方完全透明:
-//   - 仅当响应 Content-Type 是 text/event-stream 时介入；普通 JSON 响应原样透传
-//   - data: payload (含 [DONE] 与 {"error":...}) 一字节不改
-//   - 上游真断流 (EOF / connection reset / context cancel) 原样透传
-
-import (
-	"bufio"
-	"bytes"
-	"io"
-	"net/http"
-	"strings"
-)
-
-const (
-	// einoSSEReaderBufSize 给 bufio 一个较大的初始缓冲, 避免单行大 JSON chunk
-	// (含工具调用 arguments / reasoning_content) 频繁触发缓冲区扩容。
-	einoSSEReaderBufSize = 64 * 1024
-)
-
-// einoSSESanitizingRoundTripper 包装下游 RoundTripper, 对 SSE 响应做行级清洗。
-type einoSSESanitizingRoundTripper struct {
-	base http.RoundTripper
-}
-
-func (rt *einoSSESanitizingRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
-	resp, err := rt.base.RoundTrip(req)
-	if err != nil || resp == nil {
-		return resp, err
-	}
-	if !isSSEResponse(resp) {
-		return resp, nil
-	}
-	resp.Body = newEinoSSESanitizingBody(resp.Body)
-	return resp, nil
-}
-
-// isSSEResponse 仅对 200 + text/event-stream 的响应做清洗;
-// 错误响应 (4xx/5xx 通常是 application/json) 不动, 由 SDK 走原错误路径。
-func isSSEResponse(resp *http.Response) bool {
-	if resp.StatusCode != http.StatusOK {
-		return false
-	}
-	ct := resp.Header.Get("Content-Type")
-	if ct == "" {
-		return false
-	}
-	ct = strings.ToLower(strings.TrimSpace(ct))
-	// 兼容 "text/event-stream", "text/event-stream; charset=utf-8" 等。
-	return strings.HasPrefix(ct, "text/event-stream")
-}
-
-// einoSSESanitizingBody 是包装后的响应体: 只放行 data: 行, 其它行吞掉。
-type einoSSESanitizingBody struct {
-	upstream io.ReadCloser
-	reader   *bufio.Reader
-	pending  []byte // 已清洗、待返回给下游的字节 (永远以 \n 结尾的完整 data: 行)
-	err      error  // upstream 终态错误 (io.EOF 或网络错误)
-}
-
-func newEinoSSESanitizingBody(body io.ReadCloser) *einoSSESanitizingBody {
-	return &einoSSESanitizingBody{
-		upstream: body,
-		reader:   bufio.NewReaderSize(body, einoSSEReaderBufSize),
-	}
-}
-
-func (b *einoSSESanitizingBody) Read(p []byte) (int, error) {
-	if len(p) == 0 {
-		return 0, nil
-	}
-	if len(b.pending) > 0 {
-		n := copy(p, b.pending)
-		b.pending = b.pending[n:]
-		return n, nil
-	}
-
-	// 从上游读, 直到攒出一行 data: 或拿到终态。
-	// 单次循环可能丢弃任意多行心跳, 但只放行至多一行 data: 后退出,
-	// 避免一次 Read 阻塞过久 / pending 缓冲过大。
-	for b.err == nil {
-		line, err := b.reader.ReadBytes('\n')
-		if len(line) > 0 {
-			if isPassThroughSSELine(line) {
-				if line[len(line)-1] != '\n' {
-					line = append(line, '\n')
-				}
-				b.pending = line
-				if err != nil {
-					b.err = err
-				}
-				break
-			}
-			// 非 data: 行 (空行 / ":" 注释 / event: / retry: / id: / 任何裸文本)
-			// 全部吞掉, 不向下游透出, 继续循环读下一行。
-		}
-		if err != nil {
-			b.err = err
-			break
-		}
-	}
-
-	if len(b.pending) > 0 {
-		n := copy(p, b.pending)
-		b.pending = b.pending[n:]
-		return n, nil
-	}
-	return 0, b.err
-}
-
-func (b *einoSSESanitizingBody) Close() error {
-	return b.upstream.Close()
-}
-
-// isPassThroughSSELine 判定该行是否需要原样放行给下游 SDK。
-// 仅 "data:" (大小写不敏感, 可有任意前导空白) 开头的行需要保留。
-// 注意: 不能用 TrimSpace 去尾部换行后再判, 否则 "  data: x" 会被误判;
-// 我们只 trim 前导空白, 与 SDK 内部 TrimSpace 后再正则 ^data:\s* 的语义一致。
-func isPassThroughSSELine(line []byte) bool {
-	trimmed := bytes.TrimLeft(line, " \t")
-	if len(trimmed) < 5 {
-		return false
-	}
-	// 大小写不敏感比较前 5 字节是否为 "data:"。SSE 规范要求字段名小写,
-	// 但宽松匹配可以兼容个别中转站的非规范实现。
-	return (trimmed[0] == 'd' || trimmed[0] == 'D') &&
-		(trimmed[1] == 'a' || trimmed[1] == 'A') &&
-		(trimmed[2] == 't' || trimmed[2] == 'T') &&
-		(trimmed[3] == 'a' || trimmed[3] == 'A') &&
-		trimmed[4] == ':'
-}

internal/openai/eino_sse_sanitizer_test.go

@@ -1,303 +0,0 @@
-package openai
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"regexp"
-	"strings"
-	"testing"
-)
-
-// 复现 meguminnnnnnnnn/go-openai 的 SSE 行计数算法 (默认 limit=300):
-// - 逐行读
-// - 非 "data:" 行 (空行 / ":" 注释 / event: / retry:) 累计 emptyMessagesCount
-// - > 300 抛 ErrTooManyEmptyStreamMessages
-// - 遇到 data: 行 reset, 返回 payload
-//
-// 这一算法与上游 SDK 的 stream_reader.go processLines() 严格一致 (验证依据见
-// /Users/temp/go/pkg/mod/github.com/meguminnnnnnnnn/go-openai@v0.1.2/stream_reader.go)。
-// 测试中只复刻 "限制触发" 这一行为, 用来回归验证 sanitizer 的根因修复。
-var errTooManyEmptyStreamMessages = errors.New("stream has sent too many empty messages")
-
-func sdkLikeRecvAll(body io.Reader, limit uint) ([]string, error) {
-	headerData := regexp.MustCompile(`^data:\s*`)
-	r := bufio.NewReader(body)
-	var payloads []string
-	for {
-		var emptyMessagesCount uint
-		var payload []byte
-		for {
-			line, err := r.ReadBytes('\n')
-			if err != nil {
-				if err == io.EOF {
-					return payloads, nil
-				}
-				return payloads, err
-			}
-			noSpace := bytes.TrimSpace(line)
-			if !headerData.Match(noSpace) {
-				emptyMessagesCount++
-				if emptyMessagesCount > limit {
-					return payloads, errTooManyEmptyStreamMessages
-				}
-				continue
-			}
-			payload = headerData.ReplaceAll(noSpace, nil)
-			break
-		}
-		if string(payload) == "[DONE]" {
-			return payloads, nil
-		}
-		payloads = append(payloads, string(payload))
-	}
-}
-
-func newSSEServer(t *testing.T, body string, contentType string, status int) *httptest.Server {
-	t.Helper()
-	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		if contentType != "" {
-			w.Header().Set("Content-Type", contentType)
-		}
-		w.WriteHeader(status)
-		_, _ = io.WriteString(w, body)
-	}))
-}
-
-func sanitizingClient(base *http.Client) *http.Client {
-	if base == nil {
-		base = &http.Client{}
-	}
-	cloned := *base
-	transport := base.Transport
-	if transport == nil {
-		transport = http.DefaultTransport
-	}
-	cloned.Transport = &einoSSESanitizingRoundTripper{base: transport}
-	return &cloned
-}
-
-func readAll(t *testing.T, body io.ReadCloser) string {
-	t.Helper()
-	defer body.Close()
-	out, err := io.ReadAll(body)
-	if err != nil {
-		t.Fatalf("read body: %v", err)
-	}
-	return string(out)
-}
-
-// 1) 仅 data: 行 → 一字节不改地透传。
-func TestSSESanitizer_PassesDataLinesUnchanged(t *testing.T) {
-	body := "data: {\"a\":1}\ndata: {\"b\":2}\ndata: [DONE]\n"
-	srv := newSSEServer(t, body, "text/event-stream", 200)
-	defer srv.Close()
-
-	resp, err := sanitizingClient(nil).Get(srv.URL)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	got := readAll(t, resp.Body)
-	if got != body {
-		t.Fatalf("body mismatch:\nwant %q\ngot  %q", body, got)
-	}
-}
-
-// 2) 心跳/注释/事件类型行被吞掉, 仅保留 data: 行。
-func TestSSESanitizer_DropsHeartbeatsAndControlLines(t *testing.T) {
-	body := strings.Join([]string{
-		": keepalive",
-		"",
-		"event: ping",
-		"retry: 3000",
-		"id: 42",
-		"data: {\"x\":1}",
-		": ping",
-		"",
-		"data: {\"x\":2}",
-		"data: [DONE]",
-		"",
-	}, "\n")
-	srv := newSSEServer(t, body, "text/event-stream", 200)
-	defer srv.Close()
-
-	resp, err := sanitizingClient(nil).Get(srv.URL)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	got := readAll(t, resp.Body)
-	want := "data: {\"x\":1}\ndata: {\"x\":2}\ndata: [DONE]\n"
-	if got != want {
-		t.Fatalf("sanitized body mismatch:\nwant %q\ngot  %q", want, got)
-	}
-}
-
-// 3) 根因回归: 上游堆 500 行心跳后才发 data:, 原始 SDK 算法会抛
-// ErrTooManyEmptyStreamMessages, sanitize 之后必须能正常拿到所有 data:。
-func TestSSESanitizer_ProtectsAgainstTooManyEmptyMessages(t *testing.T) {
-	const heartbeats = 500
-	var buf bytes.Buffer
-	for i := 0; i < heartbeats; i++ {
-		buf.WriteString(": keepalive\n")
-	}
-	buf.WriteString("data: {\"chunk\":1}\n")
-	buf.WriteString("data: {\"chunk\":2}\n")
-	buf.WriteString("data: [DONE]\n")
-
-	t.Run("baseline_without_sanitizer_must_fail", func(t *testing.T) {
-		_, err := sdkLikeRecvAll(bytes.NewReader(buf.Bytes()), 300)
-		if !errors.Is(err, errTooManyEmptyStreamMessages) {
-			t.Fatalf("expected ErrTooManyEmptyStreamMessages, got %v", err)
-		}
-	})
-
-	t.Run("with_sanitizer_must_succeed", func(t *testing.T) {
-		srv := newSSEServer(t, buf.String(), "text/event-stream", 200)
-		defer srv.Close()
-
-		resp, err := sanitizingClient(nil).Get(srv.URL)
-		if err != nil {
-			t.Fatalf("get: %v", err)
-		}
-		defer resp.Body.Close()
-
-		payloads, err := sdkLikeRecvAll(resp.Body, 300)
-		if err != nil {
-			t.Fatalf("sdk-like recv after sanitize: %v", err)
-		}
-		want := []string{`{"chunk":1}`, `{"chunk":2}`}
-		if len(payloads) != len(want) {
-			t.Fatalf("payload count mismatch: want %d got %d (%v)", len(want), len(payloads), payloads)
-		}
-		for i, w := range want {
-			if payloads[i] != w {
-				t.Fatalf("payload[%d] mismatch: want %q got %q", i, w, payloads[i])
-			}
-		}
-	})
-}
-
-// 4) 心跳穿插在 data: 之间也能正确清洗 (思考型模型 prefill 期间常见)。
-func TestSSESanitizer_HeartbeatsInterleavedWithData(t *testing.T) {
-	var buf bytes.Buffer
-	buf.WriteString("data: {\"chunk\":1}\n")
-	for i := 0; i < 400; i++ {
-		buf.WriteString(": keepalive\n")
-	}
-	buf.WriteString("data: {\"chunk\":2}\n")
-	buf.WriteString("data: [DONE]\n")
-
-	srv := newSSEServer(t, buf.String(), "text/event-stream", 200)
-	defer srv.Close()
-
-	resp, err := sanitizingClient(nil).Get(srv.URL)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	defer resp.Body.Close()
-
-	payloads, err := sdkLikeRecvAll(resp.Body, 300)
-	if err != nil {
-		t.Fatalf("sdk-like recv: %v", err)
-	}
-	if got, want := len(payloads), 2; got != want {
-		t.Fatalf("payload count: want %d got %d", want, got)
-	}
-}
-
-// 5) 非 SSE 响应 (例如非流式 JSON) 不应被 sanitizer 介入。
-func TestSSESanitizer_PassesNonSSEResponseUntouched(t *testing.T) {
-	body := `{"id":"x","object":"chat.completion","choices":[]}`
-	srv := newSSEServer(t, body, "application/json", 200)
-	defer srv.Close()
-
-	resp, err := sanitizingClient(nil).Get(srv.URL)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	got := readAll(t, resp.Body)
-	if got != body {
-		t.Fatalf("non-SSE body must be untouched:\nwant %q\ngot  %q", body, got)
-	}
-}
-
-// 6) 错误响应 (4xx/5xx) 不应被 sanitize, 即使 Content-Type 是 SSE 也不动,
-//    避免吞掉类似 "data: " 之外的错误正文。
-func TestSSESanitizer_PassesNon200Untouched(t *testing.T) {
-	body := `{"error":{"message":"rate limit"}}`
-	srv := newSSEServer(t, body, "text/event-stream", 429)
-	defer srv.Close()
-
-	resp, err := sanitizingClient(nil).Get(srv.URL)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	got := readAll(t, resp.Body)
-	if got != body {
-		t.Fatalf("error body must be untouched:\nwant %q\ngot  %q", body, got)
-	}
-}
-
-// 7) data: 行末尾若缺 \n (异常上游) sanitizer 也补齐, 保证下游按行解析。
-func TestSSESanitizer_AppendsTrailingNewlineIfMissing(t *testing.T) {
-	body := "data: {\"a\":1}"
-	srv := newSSEServer(t, body, "text/event-stream", 200)
-	defer srv.Close()
-
-	resp, err := sanitizingClient(nil).Get(srv.URL)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	got := readAll(t, resp.Body)
-	want := "data: {\"a\":1}\n"
-	if got != want {
-		t.Fatalf("trailing newline:\nwant %q\ngot  %q", want, got)
-	}
-}
-
-// 8) 大 chunk (一行数十 KB) 也能完整透传, 不被切断。
-func TestSSESanitizer_LargeDataLinePassesIntact(t *testing.T) {
-	huge := strings.Repeat("x", 80*1024)
-	body := "data: {\"big\":\"" + huge + "\"}\ndata: [DONE]\n"
-	srv := newSSEServer(t, body, "text/event-stream", 200)
-	defer srv.Close()
-
-	resp, err := sanitizingClient(nil).Get(srv.URL)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	got := readAll(t, resp.Body)
-	if got != body {
-		t.Fatalf("large body length mismatch: want %d got %d", len(body), len(got))
-	}
-}
-
-// 9) isPassThroughSSELine 单元覆盖。
-func TestIsPassThroughSSELine(t *testing.T) {
-	cases := []struct {
-		line string
-		want bool
-	}{
-		{"data: {\"a\":1}\n", true},
-		{"DATA: x\n", true},
-		{"  data: x\n", true},
-		{"data:\n", true},
-		{"\n", false},
-		{"\r\n", false},
-		{": keepalive\n", false},
-		{":\n", false},
-		{"event: ping\n", false},
-		{"retry: 3000\n", false},
-		{"id: 42\n", false},
-		{"datax: y\n", false},
-		{"da", false},
-	}
-	for _, c := range cases {
-		if got := isPassThroughSSELine([]byte(c.line)); got != c.want {
-			t.Errorf("isPassThroughSSELine(%q) = %v, want %v", c.line, got, c.want)
-		}
-	}
-}

internal/openai/normalize_streaming_delta_test.go

@@ -1,56 +0,0 @@
-package openai
-
-import "testing"
-
-func TestNormalizeStreamingDelta_RepeatedCharBoundary(t *testing.T) {
-	// 流式在重复数字边界分片：不得把 "43" 的首字符与 "194" 尾字符误合并。
-	cur, d := normalizeStreamingDelta("https://x:194", "43")
-	if want := "https://x:19443"; cur != want {
-		t.Fatalf("next: want %q got %q", want, cur)
-	}
-	if d != "43" {
-		t.Fatalf("delta: want %q got %q", "43", d)
-	}
-}
-
-func TestNormalizeStreamingDelta_CumulativePrefix(t *testing.T) {
-	cur, d := normalizeStreamingDelta("今天", "今天天气")
-	if cur != "今天天气" || d != "天气" {
-		t.Fatalf("got cur=%q d=%q", cur, d)
-	}
-}
-
-func TestNormalizeStreamingDelta_FullRetransmit(t *testing.T) {
-	cur, d := normalizeStreamingDelta("今天", "今天")
-	if d != "" || cur != "今天" {
-		t.Fatalf("got cur=%q d=%q", cur, d)
-	}
-}
-
-func TestNormalizeStreamingDelta_SingleRuneRepeated(t *testing.T) {
-	cur, d := normalizeStreamingDelta("呀", "呀")
-	if want := "呀呀"; cur != want {
-		t.Fatalf("next: want %q got %q", want, cur)
-	}
-	if d != "呀" {
-		t.Fatalf("delta: want %q got %q", "呀", d)
-	}
-	cur, d = normalizeStreamingDelta("4", "4")
-	if want := "44"; cur != want {
-		t.Fatalf("next: want %q got %q", want, cur)
-	}
-	if d != "4" {
-		t.Fatalf("delta: want %q got %q", "4", d)
-	}
-}
-
-func TestNormalizeStreamingDelta_CumulativeExtendsNumber(t *testing.T) {
-	// 已缓冲 "194" 后收到累计串 "19443"（注意 "1943" 并非 "19443" 的前缀，不能靠误写的中间态测 HasPrefix）。
-	cur, d := normalizeStreamingDelta("194", "19443")
-	if want := "19443"; cur != want {
-		t.Fatalf("next: want %q got %q", want, cur)
-	}
-	if d != "43" {
-		t.Fatalf("delta: want %q got %q", "43", d)
-	}
-}

internal/openai/openai.go

@@ -1,537 +0,0 @@
-package openai
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"time"
-	"unicode/utf8"
-
-	"cyberstrike-ai/internal/config"
-
-	"go.uber.org/zap"
-)
-
-// Client 统一封装与OpenAI兼容模型交互的HTTP客户端。
-type Client struct {
-	httpClient *http.Client
-	config     *config.OpenAIConfig
-	logger     *zap.Logger
-}
-
-// APIError 表示OpenAI接口返回的非200错误。
-type APIError struct {
-	StatusCode int
-	Body       string
-}
-
-func (e *APIError) Error() string {
-	return fmt.Sprintf("openai api error: status=%d body=%s", e.StatusCode, e.Body)
-}
-
-// normalizeStreamingDelta 将可能是“累计片段/重发片段”的内容归一化为“纯增量”。
-// 部分兼容网关会返回累计 content；若直接 append 会出现重复文本。
-//
-// 注意：
-//   - 不做「任意后缀与前缀重叠」合并；流式可能在重复字符边界分片（"194"+"43"→"19443"）。
-//   - HasPrefix 仅在 incoming 严格长于 current 时视为累计全文，否则会把分片产生的第二个相同
-//     单字/单码点（叠字、44、22 等）误判为「整段重复」而吞字。
-//   - incoming==current 仅当 current 长度 >1 个码点时才视为整包重发；单码点重复必须走拼接。
-//   - 不再使用「current 以 incoming 结尾则丢弃」：否则 "1943"+"43" 会误吞增量（19443 显示成 1943）。
-//     若网关重复发送尾部片段，应重复送完整累计串，由 HasPrefix 分支去重。
-func normalizeStreamingDelta(current, incoming string) (next, delta string) {
-	if incoming == "" {
-		return current, ""
-	}
-	if current == "" {
-		return incoming, incoming
-	}
-	if strings.HasPrefix(incoming, current) && len(incoming) > len(current) {
-		return incoming, incoming[len(current):]
-	}
-	if incoming == current && utf8.RuneCountInString(current) > 1 {
-		return current, ""
-	}
-	return current + incoming, incoming
-}
-
-// NewClient 创建一个新的OpenAI客户端。
-func NewClient(cfg *config.OpenAIConfig, httpClient *http.Client, logger *zap.Logger) *Client {
-	if httpClient == nil {
-		httpClient = http.DefaultClient
-	}
-	if logger == nil {
-		logger = zap.NewNop()
-	}
-	return &Client{
-		httpClient: httpClient,
-		config:     cfg,
-		logger:     logger,
-	}
-}
-
-// UpdateConfig 动态更新OpenAI配置。
-func (c *Client) UpdateConfig(cfg *config.OpenAIConfig) {
-	c.config = cfg
-}
-
-// ChatCompletion 调用 /chat/completions 接口。
-func (c *Client) ChatCompletion(ctx context.Context, payload interface{}, out interface{}) error {
-	if c == nil {
-		return fmt.Errorf("openai client is not initialized")
-	}
-	if c.config == nil {
-		return fmt.Errorf("openai config is nil")
-	}
-	if strings.TrimSpace(c.config.APIKey) == "" {
-		return fmt.Errorf("openai api key is empty")
-	}
-	if c.isClaude() {
-		return c.claudeChatCompletion(ctx, payload, out)
-	}
-
-	baseURL := strings.TrimSuffix(c.config.BaseURL, "/")
-	if baseURL == "" {
-		baseURL = "https://api.openai.com/v1"
-	}
-
-	body, err := json.Marshal(payload)
-	if err != nil {
-		return fmt.Errorf("marshal openai payload: %w", err)
-	}
-
-	c.logger.Debug("sending OpenAI chat completion request",
-		zap.Int("payloadSizeKB", len(body)/1024))
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+"/chat/completions", bytes.NewReader(body))
-	if err != nil {
-		return fmt.Errorf("build openai request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", "Bearer "+c.config.APIKey)
-
-	requestStart := time.Now()
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return fmt.Errorf("call openai api: %w", err)
-	}
-	defer resp.Body.Close()
-
-	bodyChan := make(chan []byte, 1)
-	errChan := make(chan error, 1)
-	go func() {
-		responseBody, err := io.ReadAll(resp.Body)
-		if err != nil {
-			errChan <- err
-			return
-		}
-		bodyChan <- responseBody
-	}()
-
-	var respBody []byte
-	select {
-	case respBody = <-bodyChan:
-	case err := <-errChan:
-		return fmt.Errorf("read openai response: %w", err)
-	case <-ctx.Done():
-		return fmt.Errorf("read openai response timeout: %w", ctx.Err())
-	case <-time.After(25 * time.Minute):
-		return fmt.Errorf("read openai response timeout (25m)")
-	}
-
-	c.logger.Debug("received OpenAI response",
-		zap.Int("status", resp.StatusCode),
-		zap.Duration("duration", time.Since(requestStart)),
-		zap.Int("responseSizeKB", len(respBody)/1024),
-	)
-
-	if resp.StatusCode != http.StatusOK {
-		c.logger.Warn("OpenAI chat completion returned non-200",
-			zap.Int("status", resp.StatusCode),
-			zap.String("body", string(respBody)),
-		)
-		return &APIError{
-			StatusCode: resp.StatusCode,
-			Body:       string(respBody),
-		}
-	}
-
-	if out != nil {
-		if err := json.Unmarshal(respBody, out); err != nil {
-			c.logger.Error("failed to unmarshal OpenAI response",
-				zap.Error(err),
-				zap.String("body", string(respBody)),
-			)
-			return fmt.Errorf("unmarshal openai response: %w", err)
-		}
-	}
-
-	return nil
-}
-
-// ChatCompletionStream 调用 /chat/completions 的流式模式（stream=true），并在每个 delta 到达时回调 onDelta。
-// 返回最终拼接的 content（只拼 content delta；工具调用 delta 未做处理）。
-func (c *Client) ChatCompletionStream(ctx context.Context, payload interface{}, onDelta func(delta string) error) (string, error) {
-	if c == nil {
-		return "", fmt.Errorf("openai client is not initialized")
-	}
-	if c.config == nil {
-		return "", fmt.Errorf("openai config is nil")
-	}
-	if strings.TrimSpace(c.config.APIKey) == "" {
-		return "", fmt.Errorf("openai api key is empty")
-	}
-	if c.isClaude() {
-		return c.claudeChatCompletionStream(ctx, payload, onDelta)
-	}
-
-	baseURL := strings.TrimSuffix(c.config.BaseURL, "/")
-	if baseURL == "" {
-		baseURL = "https://api.openai.com/v1"
-	}
-
-	body, err := json.Marshal(payload)
-	if err != nil {
-		return "", fmt.Errorf("marshal openai payload: %w", err)
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+"/chat/completions", bytes.NewReader(body))
-	if err != nil {
-		return "", fmt.Errorf("build openai request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", "Bearer "+c.config.APIKey)
-
-	requestStart := time.Now()
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return "", fmt.Errorf("call openai api: %w", err)
-	}
-	defer resp.Body.Close()
-
-	// 非200：读完 body 返回
-	if resp.StatusCode != http.StatusOK {
-		respBody, readErr := io.ReadAll(resp.Body)
-		if readErr != nil {
-			c.logger.Warn("failed to read OpenAI error response body", zap.Error(readErr))
-		}
-		return "", &APIError{
-			StatusCode: resp.StatusCode,
-			Body:       string(respBody),
-		}
-	}
-
-	type streamDelta struct {
-		// OpenAI 兼容流式通常使用 content；但部分兼容实现可能用 text。
-		Content string `json:"content,omitempty"`
-		Text    string `json:"text,omitempty"`
-	}
-	type streamChoice struct {
-		Delta        streamDelta `json:"delta"`
-		FinishReason *string     `json:"finish_reason,omitempty"`
-	}
-	type streamResponse struct {
-		ID      string         `json:"id,omitempty"`
-		Choices []streamChoice `json:"choices"`
-		Error   *struct {
-			Message string `json:"message"`
-			Type    string `json:"type"`
-		} `json:"error,omitempty"`
-	}
-
-	reader := bufio.NewReader(resp.Body)
-	var full strings.Builder
-	fullText := ""
-
-	// 典型 SSE 结构：
-	// data: {...}\n\n
-	// data: [DONE]\n\n
-	for {
-		line, readErr := reader.ReadString('\n')
-		if readErr != nil {
-			if readErr == io.EOF {
-				break
-			}
-			return full.String(), fmt.Errorf("read openai stream: %w", readErr)
-		}
-		trimmed := strings.TrimSpace(line)
-		if trimmed == "" {
-			continue
-		}
-		if !strings.HasPrefix(trimmed, "data:") {
-			continue
-		}
-		dataStr := strings.TrimSpace(strings.TrimPrefix(trimmed, "data:"))
-		if dataStr == "[DONE]" {
-			break
-		}
-
-		var chunk streamResponse
-		if err := json.Unmarshal([]byte(dataStr), &chunk); err != nil {
-			// 解析失败跳过（兼容各种兼容层的差异）
-			continue
-		}
-		if chunk.Error != nil && strings.TrimSpace(chunk.Error.Message) != "" {
-			return full.String(), fmt.Errorf("openai stream error: %s", chunk.Error.Message)
-		}
-		if len(chunk.Choices) == 0 {
-			continue
-		}
-
-		delta := chunk.Choices[0].Delta.Content
-		if delta == "" {
-			delta = chunk.Choices[0].Delta.Text
-		}
-		if delta == "" {
-			continue
-		}
-
-		var deltaOut string
-		fullText, deltaOut = normalizeStreamingDelta(fullText, delta)
-		if deltaOut == "" {
-			continue
-		}
-		full.WriteString(deltaOut)
-		if onDelta != nil {
-			if err := onDelta(deltaOut); err != nil {
-				return full.String(), err
-			}
-		}
-	}
-
-	c.logger.Debug("received OpenAI stream completion",
-		zap.Duration("duration", time.Since(requestStart)),
-		zap.Int("contentLen", full.Len()),
-	)
-
-	return full.String(), nil
-}
-
-// StreamToolCall 流式工具调用的累积结果（arguments 以字符串形式拼接，留给上层再解析为 JSON）。
-type StreamToolCall struct {
-	Index           int
-	ID              string
-	Type            string
-	FunctionName    string
-	FunctionArgsStr string
-}
-
-// ChatCompletionStreamWithToolCalls 流式模式：同时把 content delta 实时回调，并在结束后返回 tool_calls 和 finish_reason。
-func (c *Client) ChatCompletionStreamWithToolCalls(
-	ctx context.Context,
-	payload interface{},
-	onContentDelta func(delta string) error,
-) (string, []StreamToolCall, string, error) {
-	if c == nil {
-		return "", nil, "", fmt.Errorf("openai client is not initialized")
-	}
-	if c.config == nil {
-		return "", nil, "", fmt.Errorf("openai config is nil")
-	}
-	if strings.TrimSpace(c.config.APIKey) == "" {
-		return "", nil, "", fmt.Errorf("openai api key is empty")
-	}
-	if c.isClaude() {
-		return c.claudeChatCompletionStreamWithToolCalls(ctx, payload, onContentDelta)
-	}
-
-	baseURL := strings.TrimSuffix(c.config.BaseURL, "/")
-	if baseURL == "" {
-		baseURL = "https://api.openai.com/v1"
-	}
-
-	body, err := json.Marshal(payload)
-	if err != nil {
-		return "", nil, "", fmt.Errorf("marshal openai payload: %w", err)
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, baseURL+"/chat/completions", bytes.NewReader(body))
-	if err != nil {
-		return "", nil, "", fmt.Errorf("build openai request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", "Bearer "+c.config.APIKey)
-
-	requestStart := time.Now()
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return "", nil, "", fmt.Errorf("call openai api: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		respBody, readErr := io.ReadAll(resp.Body)
-		if readErr != nil {
-			c.logger.Warn("failed to read OpenAI error response body", zap.Error(readErr))
-		}
-		return "", nil, "", &APIError{
-			StatusCode: resp.StatusCode,
-			Body:       string(respBody),
-		}
-	}
-
-	// delta tool_calls 的增量结构
-	type toolCallFunctionDelta struct {
-		Name      string `json:"name,omitempty"`
-		Arguments string `json:"arguments,omitempty"`
-	}
-	type toolCallDelta struct {
-		Index    int                   `json:"index,omitempty"`
-		ID       string                `json:"id,omitempty"`
-		Type     string                `json:"type,omitempty"`
-		Function toolCallFunctionDelta `json:"function,omitempty"`
-	}
-	type streamDelta2 struct {
-		Content   string          `json:"content,omitempty"`
-		Text      string          `json:"text,omitempty"`
-		ToolCalls []toolCallDelta `json:"tool_calls,omitempty"`
-	}
-	type streamChoice2 struct {
-		Delta        streamDelta2 `json:"delta"`
-		FinishReason *string      `json:"finish_reason,omitempty"`
-	}
-	type streamResponse2 struct {
-		Choices []streamChoice2 `json:"choices"`
-		Error   *struct {
-			Message string `json:"message"`
-			Type    string `json:"type"`
-		} `json:"error,omitempty"`
-	}
-
-	type toolCallAccum struct {
-		id   string
-		typ  string
-		name string
-		args strings.Builder
-	}
-	toolCallAccums := make(map[int]*toolCallAccum)
-
-	reader := bufio.NewReader(resp.Body)
-	var full strings.Builder
-	fullText := ""
-	finishReason := ""
-
-	for {
-		line, readErr := reader.ReadString('\n')
-		if readErr != nil {
-			if readErr == io.EOF {
-				break
-			}
-			return full.String(), nil, finishReason, fmt.Errorf("read openai stream: %w", readErr)
-		}
-		trimmed := strings.TrimSpace(line)
-		if trimmed == "" {
-			continue
-		}
-		if !strings.HasPrefix(trimmed, "data:") {
-			continue
-		}
-		dataStr := strings.TrimSpace(strings.TrimPrefix(trimmed, "data:"))
-		if dataStr == "[DONE]" {
-			break
-		}
-
-		var chunk streamResponse2
-		if err := json.Unmarshal([]byte(dataStr), &chunk); err != nil {
-			// 兼容：解析失败跳过
-			continue
-		}
-		if chunk.Error != nil && strings.TrimSpace(chunk.Error.Message) != "" {
-			return full.String(), nil, finishReason, fmt.Errorf("openai stream error: %s", chunk.Error.Message)
-		}
-		if len(chunk.Choices) == 0 {
-			continue
-		}
-
-		choice := chunk.Choices[0]
-		if choice.FinishReason != nil && strings.TrimSpace(*choice.FinishReason) != "" {
-			finishReason = strings.TrimSpace(*choice.FinishReason)
-		}
-
-		delta := choice.Delta
-
-		content := delta.Content
-		if content == "" {
-			content = delta.Text
-		}
-		if content != "" {
-			var contentOut string
-			fullText, contentOut = normalizeStreamingDelta(fullText, content)
-			if contentOut != "" {
-				full.WriteString(contentOut)
-				if onContentDelta != nil {
-					if err := onContentDelta(contentOut); err != nil {
-						return full.String(), nil, finishReason, err
-					}
-				}
-			}
-		}
-
-		if len(delta.ToolCalls) > 0 {
-			for _, tc := range delta.ToolCalls {
-				acc, ok := toolCallAccums[tc.Index]
-				if !ok {
-					acc = &toolCallAccum{}
-					toolCallAccums[tc.Index] = acc
-				}
-				if tc.ID != "" {
-					acc.id = tc.ID
-				}
-				if tc.Type != "" {
-					acc.typ = tc.Type
-				}
-				if tc.Function.Name != "" {
-					acc.name = tc.Function.Name
-				}
-				if tc.Function.Arguments != "" {
-					acc.args.WriteString(tc.Function.Arguments)
-				}
-			}
-		}
-	}
-
-	// 组装 tool calls
-	indices := make([]int, 0, len(toolCallAccums))
-	for idx := range toolCallAccums {
-		indices = append(indices, idx)
-	}
-	// 手写简单排序（避免额外 import）
-	for i := 0; i < len(indices); i++ {
-		for j := i + 1; j < len(indices); j++ {
-			if indices[j] < indices[i] {
-				indices[i], indices[j] = indices[j], indices[i]
-			}
-		}
-	}
-
-	toolCalls := make([]StreamToolCall, 0, len(indices))
-	for _, idx := range indices {
-		acc := toolCallAccums[idx]
-		tc := StreamToolCall{
-			Index:           idx,
-			ID:              acc.id,
-			Type:            acc.typ,
-			FunctionName:    acc.name,
-			FunctionArgsStr: acc.args.String(),
-		}
-		toolCalls = append(toolCalls, tc)
-	}
-
-	c.logger.Debug("received OpenAI stream completion (tool_calls)",
-		zap.Duration("duration", time.Since(requestStart)),
-		zap.Int("contentLen", full.Len()),
-		zap.Int("toolCalls", len(toolCalls)),
-		zap.String("finishReason", finishReason),
-	)
-
-	if strings.TrimSpace(finishReason) == "" {
-		finishReason = "stop"
-	}
-
-	return full.String(), toolCalls, finishReason, nil
-}

internal/openai/sse_stream.go

@@ -1,20 +0,0 @@
-package openai
-
-// SSEAccumulatedKey 为 SSE progress 事件 data 中的服务端权威流式全文快照字段。
-// 前端应优先用该字段更新 buffer，避免对 delta 二次 normalize 导致叠字。
-const SSEAccumulatedKey = "accumulated"
-
-// WithSSEAccumulated 在 progress data 中附带当前流式累计全文（权威快照）。
-func WithSSEAccumulated(data map[string]interface{}, accumulated string) map[string]interface{} {
-	if data == nil {
-		data = make(map[string]interface{}, 1)
-	}
-	data[SSEAccumulatedKey] = accumulated
-	return data
-}
-
-// NormalizeStreamingDelta 将可能是“累计片段/重发片段”的内容归一化为“纯增量”。
-// 与 unexported normalizeStreamingDelta 相同，供 agent / multiagent 等包在发 SSE 前累计正文。
-func NormalizeStreamingDelta(current, incoming string) (next, delta string) {
-	return normalizeStreamingDelta(current, incoming)
-}

internal/openai/summarization_diag.go

@@ -1,88 +0,0 @@
-package openai
-
-import (
-	"bytes"
-	"io"
-	"net/http"
-	"strings"
-
-	"github.com/bytedance/sonic"
-	"go.uber.org/zap"
-)
-
-// SummarizationRequestHeader marks chat/completion requests issued by Eino summarization
-// middleware (via model.WithExtraHeader). The diagnostic transport logs empty-choices bodies
-// only for these requests so main-agent traffic stays quiet.
-const SummarizationRequestHeader = "X-CyberStrike-Summarization"
-
-const summarizationDiagBodyMaxBytes = 8192
-
-// AttachSummarizationDiagTransport wraps client.Transport to log raw API bodies when
-// summarization receives HTTP 200 with an empty choices array.
-func AttachSummarizationDiagTransport(client *http.Client, logger *zap.Logger) {
-	if client == nil || logger == nil {
-		return
-	}
-	base := client.Transport
-	if base == nil {
-		base = http.DefaultTransport
-	}
-	client.Transport = &summarizationDiagRoundTripper{base: base, logger: logger}
-}
-
-type summarizationDiagRoundTripper struct {
-	base   http.RoundTripper
-	logger *zap.Logger
-}
-
-func (rt *summarizationDiagRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
-	resp, err := rt.base.RoundTrip(req)
-	if err != nil || resp == nil || resp.Body == nil {
-		return resp, err
-	}
-	if !isSummarizationRequest(req) || !strings.Contains(strings.ToLower(resp.Header.Get("Content-Type")), "json") {
-		return resp, err
-	}
-
-	body, readErr := io.ReadAll(resp.Body)
-	_ = resp.Body.Close()
-	if readErr != nil {
-		resp.Body = io.NopCloser(bytes.NewReader(nil))
-		return resp, err
-	}
-	resp.Body = io.NopCloser(bytes.NewReader(body))
-	resp.ContentLength = int64(len(body))
-
-	if rt.logger != nil && summarizationResponseEmptyChoices(body) {
-		rt.logger.Warn("eino summarization: API returned empty choices",
-			zap.Int("status", resp.StatusCode),
-			zap.Int("response_bytes", len(body)),
-			zap.String("raw_body", truncateForLog(string(body), summarizationDiagBodyMaxBytes)),
-		)
-	}
-	return resp, err
-}
-
-func isSummarizationRequest(req *http.Request) bool {
-	if req == nil {
-		return false
-	}
-	return strings.TrimSpace(req.Header.Get(SummarizationRequestHeader)) == "1"
-}
-
-func summarizationResponseEmptyChoices(body []byte) bool {
-	var parsed struct {
-		Choices []any `json:"choices"`
-	}
-	if err := sonic.Unmarshal(body, &parsed); err != nil {
-		return false
-	}
-	return len(parsed.Choices) == 0
-}
-
-func truncateForLog(s string, maxBytes int) string {
-	if maxBytes <= 0 || len(s) <= maxBytes {
-		return s
-	}
-	return s[:maxBytes] + "…(truncated)"
-}

internal/openai/summarization_diag_test.go

@@ -1,47 +0,0 @@
-package openai
-
-import (
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-
-	"go.uber.org/zap"
-)
-
-type staticRoundTripper struct {
-	status int
-	body   string
-}
-
-func (s *staticRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
-	return &http.Response{
-		StatusCode: s.status,
-		Header:     http.Header{"Content-Type": []string{"application/json"}},
-		Body:       io.NopCloser(strings.NewReader(s.body)),
-	}, nil
-}
-
-func TestSummarizationResponseEmptyChoices(t *testing.T) {
-	if !summarizationResponseEmptyChoices([]byte(`{"choices":[]}`)) {
-		t.Fatal("expected empty choices")
-	}
-	if summarizationResponseEmptyChoices([]byte(`{"choices":[{"index":0}]}`)) {
-		t.Fatal("expected non-empty choices")
-	}
-}
-
-func TestSummarizationDiagRoundTripper_SkipsWithoutHeader(t *testing.T) {
-	client := &http.Client{
-		Transport: &summarizationDiagRoundTripper{
-			base:   &staticRoundTripper{status: 200, body: `{"choices":[]}`},
-			logger: zap.NewNop(),
-		},
-	}
-	req, _ := http.NewRequest(http.MethodPost, "https://example.com/v1/chat/completions", nil)
-	resp, err := client.Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	_ = resp.Body.Close()
-}