mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-19 00:13:11 +08:00
910 lines
37 KiB
Go
910 lines
37 KiB
Go
package claude
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/MoeForge/moego/json"
|
|
"github.com/MoeForge/moego/ojson"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/interfaces"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/registry"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/sdk/api/handlers"
|
|
coreauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
|
|
coreexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
|
|
sdkconfig "github.com/router-for-me/CLIProxyAPI/v8/sdk/config"
|
|
)
|
|
|
|
func TestClaudeErrorTypeFromStatus(t *testing.T) {
|
|
for _, tt := range []struct {
|
|
status int
|
|
want string
|
|
}{
|
|
{http.StatusBadRequest, "invalid_request_error"},
|
|
{http.StatusConflict, "conflict_error"},
|
|
{http.StatusRequestTimeout, "timeout_error"},
|
|
{http.StatusTooManyRequests, "rate_limit_error"},
|
|
{http.StatusInternalServerError, "api_error"},
|
|
{http.StatusGatewayTimeout, "timeout_error"},
|
|
} {
|
|
t.Run(http.StatusText(tt.status), func(t *testing.T) {
|
|
if got := claudeErrorTypeFromStatus(tt.status); got != tt.want {
|
|
t.Fatalf("error.type = %q, want %q", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestClaudeIncompleteStreamError(t *testing.T) {
|
|
const message = "stream error: stream disconnected before completion: stream closed before response.completed"
|
|
for _, streaming := range []bool{false, true} {
|
|
name := "JSON"
|
|
if streaming {
|
|
name = "committed SSE"
|
|
}
|
|
t.Run(name, func(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", nil)
|
|
handler := NewClaudeCodeAPIHandler(&handlers.BaseAPIHandler{})
|
|
msg := &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusRequestTimeout,
|
|
Error: errors.New(message),
|
|
}
|
|
wantStatus := http.StatusRequestTimeout
|
|
if streaming {
|
|
c.Header("Content-Type", "text/event-stream")
|
|
_, _ = c.Writer.Write([]byte("event: message_start\ndata: {}\n\n"))
|
|
c.Writer.Flush()
|
|
errs := make(chan *interfaces.ErrorMessage, 1)
|
|
errs <- msg
|
|
close(errs)
|
|
handler.forwardClaudeStream(c, c.Writer, func(err error) {
|
|
if err != msg.Error {
|
|
t.Errorf("cancel error = %v, want %v", err, msg.Error)
|
|
}
|
|
}, nil, errs)
|
|
wantStatus = http.StatusOK
|
|
} else {
|
|
handler.WriteErrorResponse(c, msg)
|
|
}
|
|
if recorder.Code != wantStatus {
|
|
t.Fatalf("status = %d, want %d", recorder.Code, wantStatus)
|
|
}
|
|
body := recorder.Body.String()
|
|
if streaming {
|
|
const prefix = "event: error\ndata: "
|
|
if strings.Count(body, prefix) != 1 {
|
|
t.Fatalf("expected one terminal error event; body=%s", body)
|
|
}
|
|
_, body, _ = strings.Cut(body, prefix)
|
|
body = strings.TrimSpace(body)
|
|
}
|
|
if got := ojson.Get(body, "type").String(); got != "error" {
|
|
t.Errorf("type = %q, want error", got)
|
|
}
|
|
if got := ojson.Get(body, "error.type").String(); got != "timeout_error" {
|
|
t.Errorf("error.type = %q, want timeout_error", got)
|
|
}
|
|
if got := ojson.Get(body, "error.message").String(); got != message {
|
|
t.Errorf("error.message = %q, want %q", got, message)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestClaudeErrorExtractsOpenAIStyleUpstreamJSON(t *testing.T) {
|
|
handler := &ClaudeCodeAPIHandler{}
|
|
msg := &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusBadRequest,
|
|
Error: errors.New(`{"error":{"message":"Your input exceeds the context window of this model. Please adjust your input and try again.","type":"invalid_request_error","code":"context_too_large"}}`),
|
|
}
|
|
|
|
got := handler.toClaudeError(msg)
|
|
|
|
if got.Type != "error" {
|
|
t.Fatalf("type = %q, want error", got.Type)
|
|
}
|
|
if got.Error.Type != "invalid_request_error" {
|
|
t.Fatalf("error.type = %q, want invalid_request_error", got.Error.Type)
|
|
}
|
|
if got.Error.Message != "Your input exceeds the context window of this model. Please adjust your input and try again." {
|
|
t.Fatalf("error.message = %q", got.Error.Message)
|
|
}
|
|
}
|
|
|
|
func TestClaudeErrorExtractsClaudeStyleUpstreamJSON(t *testing.T) {
|
|
handler := &ClaudeCodeAPIHandler{}
|
|
msg := &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusTooManyRequests,
|
|
Error: errors.New(`{"type":"error","error":{"type":"rate_limit_error","message":"This request would exceed your account's rate limit. Please try again later."},"request_id":"req_123"}`),
|
|
}
|
|
|
|
got := handler.toClaudeError(msg)
|
|
|
|
if got.Error.Type != "rate_limit_error" {
|
|
t.Fatalf("error.type = %q, want rate_limit_error", got.Error.Type)
|
|
}
|
|
if got.Error.Message != "This request would exceed your account's rate limit. Please try again later." {
|
|
t.Fatalf("error.message = %q", got.Error.Message)
|
|
}
|
|
}
|
|
|
|
type responseBodyOnlyClaudeError struct {
|
|
body []byte
|
|
}
|
|
|
|
func (e responseBodyOnlyClaudeError) Error() string { return "wrapped upstream error" }
|
|
func (e responseBodyOnlyClaudeError) ResponseBody() []byte { return e.body }
|
|
|
|
func TestClaudeErrorMarksWrappedMissingThreadForClientReplay(t *testing.T) {
|
|
handler := &ClaudeCodeAPIHandler{}
|
|
msg := &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusNotFound,
|
|
Error: responseBodyOnlyClaudeError{body: []byte(`{"type":"error","error":{"type":"not_found_error","message":"No thread state was found for the requested previous_message_id."}}`)},
|
|
}
|
|
|
|
body, errMarshal := json.Marshal(handler.toClaudeError(msg))
|
|
if errMarshal != nil {
|
|
t.Fatalf("marshal Claude error: %v", errMarshal)
|
|
}
|
|
if got := ojson.GetBytesNoCopy(body, "error.details.error_code").String(); got != "thread_not_found" {
|
|
t.Fatalf("error.details.error_code = %q, want thread_not_found; body=%s", got, body)
|
|
}
|
|
}
|
|
|
|
func TestClaudeErrorMarksMissingThreadForClientReplay(t *testing.T) {
|
|
handler := &ClaudeCodeAPIHandler{}
|
|
msg := &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusNotFound,
|
|
Error: errors.New(`{"type":"error","error":{"type":"not_found_error","message":"No thread state was found for the requested previous_message_id. Replay the full conversation with thread create to start a new Thread."}}`),
|
|
}
|
|
|
|
body, errMarshal := json.Marshal(handler.toClaudeError(msg))
|
|
if errMarshal != nil {
|
|
t.Fatalf("marshal Claude error: %v", errMarshal)
|
|
}
|
|
if got := ojson.GetBytesNoCopy(body, "error.details.error_code").String(); got != "thread_not_found" {
|
|
t.Fatalf("error.details.error_code = %q, want thread_not_found; body=%s", got, body)
|
|
}
|
|
}
|
|
|
|
func TestClaudeErrorMarksPlainTextMissingThreadForClientReplay(t *testing.T) {
|
|
handler := &ClaudeCodeAPIHandler{}
|
|
msg := &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusNotFound,
|
|
Error: errors.New("No thread state was found for the requested previous_message_id. Replay the full conversation with thread create to start a new Thread."),
|
|
}
|
|
|
|
body, errMarshal := json.Marshal(handler.toClaudeError(msg))
|
|
if errMarshal != nil {
|
|
t.Fatalf("marshal Claude error: %v", errMarshal)
|
|
}
|
|
if got := ojson.GetBytesNoCopy(body, "error.details.error_code").String(); got != "thread_not_found" {
|
|
t.Fatalf("error.details.error_code = %q, want thread_not_found; body=%s", got, body)
|
|
}
|
|
}
|
|
|
|
type mockClaudeThreadNotFoundError struct {
|
|
msg string
|
|
body []byte
|
|
}
|
|
|
|
func (e mockClaudeThreadNotFoundError) Error() string { return e.msg }
|
|
func (e mockClaudeThreadNotFoundError) ResponseBody() []byte { return e.body }
|
|
|
|
func TestClaudeErrorMarksStructuredExecutorMissingThreadForClientReplay(t *testing.T) {
|
|
handler := &ClaudeCodeAPIHandler{}
|
|
msg := &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusNotFound,
|
|
Error: mockClaudeThreadNotFoundError{
|
|
msg: "No thread state was found for the requested previous_message_id. Replay the full conversation with thread create to start a new Thread.",
|
|
body: []byte(`{"type":"error","error":{"type":"not_found_error","message":"No thread state was found for the requested previous_message_id. Replay the full conversation with thread create to start a new Thread."}}`),
|
|
},
|
|
}
|
|
|
|
body, errMarshal := json.Marshal(handler.toClaudeError(msg))
|
|
if errMarshal != nil {
|
|
t.Fatalf("marshal Claude error: %v", errMarshal)
|
|
}
|
|
if got := ojson.GetBytesNoCopy(body, "error.details.error_code").String(); got != "thread_not_found" {
|
|
t.Fatalf("error.details.error_code = %q, want thread_not_found; body=%s", got, body)
|
|
}
|
|
}
|
|
|
|
func TestWriteClaudeDirectErrorMarksMissingThreadForClientReplay(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
handler := &ClaudeCodeAPIHandler{}
|
|
msg := &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusNotFound,
|
|
DirectResponse: true,
|
|
Body: []byte(`{"type":"error","error":{"type":"not_found_error","message":"No thread state was found for the requested previous_message_id. Replay the full conversation with thread create to start a new Thread."}}`),
|
|
}
|
|
|
|
handler.WriteErrorResponse(c, msg)
|
|
|
|
if got := ojson.GetBytesNoCopy(recorder.Body.Bytes(), "error.details.error_code").String(); got != "thread_not_found" {
|
|
t.Fatalf("error.details.error_code = %q, want thread_not_found; body=%s", got, recorder.Body.Bytes())
|
|
}
|
|
}
|
|
|
|
func TestWriteClaudeErrorResponseUsesClaudeEnvelope(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
handler := &ClaudeCodeAPIHandler{}
|
|
msg := &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusBadRequest,
|
|
Error: errors.New(`{"error":{"message":"Your input exceeds the context window of this model. Please adjust your input and try again.","type":"invalid_request_error","code":"context_too_large"}}`),
|
|
}
|
|
|
|
handler.WriteErrorResponse(c, msg)
|
|
|
|
if recorder.Code != http.StatusBadRequest {
|
|
t.Fatalf("status = %d, want %d", recorder.Code, http.StatusBadRequest)
|
|
}
|
|
body := recorder.Body.Bytes()
|
|
if got := ojson.GetBytesNoCopy(body, "type").String(); got != "error" {
|
|
t.Fatalf("type = %q, want error; body=%s", got, body)
|
|
}
|
|
if got := ojson.GetBytesNoCopy(body, "error.type").String(); got != "invalid_request_error" {
|
|
t.Fatalf("error.type = %q, want invalid_request_error; body=%s", got, body)
|
|
}
|
|
if got := ojson.GetBytesNoCopy(body, "error.message").String(); got != "Your input exceeds the context window of this model. Please adjust your input and try again." {
|
|
t.Fatalf("error.message = %q; body=%s", got, body)
|
|
}
|
|
}
|
|
|
|
func TestWriteClaudeErrorResponse_IncludesRetryAfterForModelCooldownDefaultSettings(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
handler := &ClaudeCodeAPIHandler{}
|
|
|
|
cooldownErr := coreauth.NewManager(nil, nil, nil)
|
|
_ = cooldownErr
|
|
// Create mock model cooldown error
|
|
msg := &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusTooManyRequests,
|
|
Error: coreauth.NewModelCooldownError("claude-sonnet-4-6", "claude", 20*time.Second),
|
|
}
|
|
|
|
handler.WriteErrorResponse(c, msg)
|
|
|
|
if recorder.Code != http.StatusTooManyRequests {
|
|
t.Fatalf("status = %d, want %d", recorder.Code, http.StatusTooManyRequests)
|
|
}
|
|
if got := recorder.Header().Get("Retry-After"); got != "20" {
|
|
t.Fatalf("Retry-After = %q, want 20", got)
|
|
}
|
|
}
|
|
|
|
func TestPendingClaudeStreamErrorUsesBufferedError(t *testing.T) {
|
|
wantErr := &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusBadRequest,
|
|
Error: errors.New(`{"error":{"message":"Your input exceeds the context window of this model. Please adjust your input and try again.","type":"invalid_request_error","code":"context_too_large"}}`),
|
|
}
|
|
errs := make(chan *interfaces.ErrorMessage, 1)
|
|
errs <- wantErr
|
|
close(errs)
|
|
|
|
gotErr, ok := handlers.PendingStreamError(errs)
|
|
if !ok {
|
|
t.Fatal("expected pending stream error")
|
|
}
|
|
if gotErr != wantErr {
|
|
t.Fatalf("pending error = %p, want %p", gotErr, wantErr)
|
|
}
|
|
}
|
|
|
|
type preFTKeepAliveClaudeExecutor struct {
|
|
chunks chan coreexecutor.StreamChunk
|
|
}
|
|
|
|
func (*preFTKeepAliveClaudeExecutor) Identifier() string { return "pre-ft-keepalive-claude-executor" }
|
|
|
|
func (*preFTKeepAliveClaudeExecutor) Execute(context.Context, *coreauth.Auth, coreexecutor.Request, coreexecutor.Options) (coreexecutor.Response, error) {
|
|
return coreexecutor.Response{}, errors.New("not implemented")
|
|
}
|
|
|
|
func (e *preFTKeepAliveClaudeExecutor) ExecuteStream(_ context.Context, _ *coreauth.Auth, _ coreexecutor.Request, _ coreexecutor.Options) (*coreexecutor.StreamResult, error) {
|
|
return &coreexecutor.StreamResult{Chunks: e.chunks}, nil
|
|
}
|
|
|
|
func (*preFTKeepAliveClaudeExecutor) Refresh(_ context.Context, auth *coreauth.Auth) (*coreauth.Auth, error) {
|
|
return auth, nil
|
|
}
|
|
|
|
func (*preFTKeepAliveClaudeExecutor) CountTokens(context.Context, *coreauth.Auth, coreexecutor.Request, coreexecutor.Options) (coreexecutor.Response, error) {
|
|
return coreexecutor.Response{}, errors.New("not implemented")
|
|
}
|
|
|
|
func (*preFTKeepAliveClaudeExecutor) HttpRequest(context.Context, *coreauth.Auth, *http.Request) (*http.Response, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func TestClaudeMessagesHandlerSendKeepAliveBeforeFTWritesSSEErrorOnFailure(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
|
|
tickChan := make(chan time.Time)
|
|
restore := handlers.SetStreamingKeepAliveTickerFactoryForTest(func(time.Duration) (<-chan time.Time, func()) {
|
|
return tickChan, func() {}
|
|
})
|
|
defer restore()
|
|
|
|
chunks := make(chan coreexecutor.StreamChunk, 1)
|
|
executor := &preFTKeepAliveClaudeExecutor{chunks: chunks}
|
|
manager := coreauth.NewManager(nil, nil, nil)
|
|
manager.RegisterExecutor(executor)
|
|
model := "pre-ft-keepalive-claude-model"
|
|
auth := &coreauth.Auth{ID: "pre-ft-keepalive-claude-auth", Provider: executor.Identifier(), Status: coreauth.StatusActive}
|
|
if _, errRegister := manager.Register(context.Background(), auth); errRegister != nil {
|
|
t.Fatalf("register auth: %v", errRegister)
|
|
}
|
|
registry.GetGlobalRegistry().RegisterClient(auth.ID, auth.Provider, []*registry.ModelInfo{{ID: model}})
|
|
t.Cleanup(func() {
|
|
registry.GetGlobalRegistry().UnregisterClient(auth.ID)
|
|
})
|
|
|
|
go func() {
|
|
tickChan <- time.Unix(1, 0)
|
|
tickChan <- time.Unix(2, 0)
|
|
chunks <- coreexecutor.StreamChunk{Err: errors.New("claude upstream failed after keepalive")}
|
|
close(chunks)
|
|
}()
|
|
|
|
base := handlers.NewBaseAPIHandlers(&sdkconfig.SDKConfig{
|
|
Streaming: sdkconfig.StreamingConfig{
|
|
KeepAliveSeconds: 10,
|
|
SendKeepAliveBeforeFT: true,
|
|
},
|
|
}, manager)
|
|
h := NewClaudeCodeAPIHandler(base)
|
|
router := gin.New()
|
|
router.POST("/v1/messages", h.ClaudeMessages)
|
|
|
|
request := httptest.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader("{\"model\":\""+model+"\",\"messages\":[{\"role\":\"user\",\"content\":\"hi\"}],\"stream\":true}"))
|
|
request.Header.Set("Content-Type", "application/json")
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, request)
|
|
|
|
if recorder.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200 after keepalive commits SSE; body=%q", recorder.Code, recorder.Body.String())
|
|
}
|
|
body := recorder.Body.String()
|
|
if !strings.Contains(body, ": keep-alive\n\n") {
|
|
t.Fatalf("missing keep-alive comment: %q", body)
|
|
}
|
|
if !strings.Contains(body, "event: error\ndata: ") || !strings.Contains(body, "claude upstream failed after keepalive") {
|
|
t.Fatalf("missing Claude SSE JSON error event after keepalive: %q", body)
|
|
}
|
|
}
|
|
|
|
func TestClaudeMessagesHandlerDeduplicatesTranslatedSSEErrorAndTerminalChunkError(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
|
|
chunks := make(chan coreexecutor.StreamChunk, 2)
|
|
executor := &preFTKeepAliveClaudeExecutor{chunks: chunks}
|
|
manager := coreauth.NewManager(nil, nil, nil)
|
|
manager.RegisterExecutor(executor)
|
|
model := "dedup-sse-error-claude-model"
|
|
auth := &coreauth.Auth{ID: "dedup-sse-error-claude-auth", Provider: executor.Identifier(), Status: coreauth.StatusActive}
|
|
if _, errRegister := manager.Register(context.Background(), auth); errRegister != nil {
|
|
t.Fatalf("register auth: %v", errRegister)
|
|
}
|
|
registry.GetGlobalRegistry().RegisterClient(auth.ID, auth.Provider, []*registry.ModelInfo{{ID: model}})
|
|
t.Cleanup(func() {
|
|
registry.GetGlobalRegistry().UnregisterClient(auth.ID)
|
|
})
|
|
|
|
const sseErrorChunk = "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_1\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"m\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":10,\"output_tokens\":0}}}\n\nevent: error\ndata: {\"type\":\"error\",\"error\":{\"type\":\"api_error\",\"message\":\"Gemini response finished with MALFORMED_FUNCTION_CALL\"}}\n\n"
|
|
chunks <- coreexecutor.StreamChunk{Payload: []byte(sseErrorChunk)}
|
|
chunks <- coreexecutor.StreamChunk{Err: errors.New(`{"type":"error","error":{"type":"api_error","message":"Gemini response finished with MALFORMED_FUNCTION_CALL"}}`)}
|
|
close(chunks)
|
|
|
|
base := handlers.NewBaseAPIHandlers(&sdkconfig.SDKConfig{}, manager)
|
|
h := NewClaudeCodeAPIHandler(base)
|
|
router := gin.New()
|
|
router.POST("/v1/messages", h.ClaudeMessages)
|
|
|
|
request := httptest.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader("{\"model\":\""+model+"\",\"messages\":[{\"role\":\"user\",\"content\":\"hi\"}],\"stream\":true}"))
|
|
request.Header.Set("Content-Type", "application/json")
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, request)
|
|
|
|
body := recorder.Body.String()
|
|
if got := strings.Count(body, "event: error\n"); got != 1 {
|
|
t.Fatalf("SSE error event count = %d, want 1; body=%q", got, body)
|
|
}
|
|
}
|
|
|
|
func TestClaudeMessagesHandlerTruncatedStreamWithoutMessageStopWritesSSEError(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
|
|
chunks := make(chan coreexecutor.StreamChunk, 2)
|
|
executor := &preFTKeepAliveClaudeExecutor{chunks: chunks}
|
|
manager := coreauth.NewManager(nil, nil, nil)
|
|
manager.RegisterExecutor(executor)
|
|
model := "truncated-stream-claude-model"
|
|
auth := &coreauth.Auth{ID: "truncated-stream-claude-auth", Provider: executor.Identifier(), Status: coreauth.StatusActive}
|
|
if _, errRegister := manager.Register(context.Background(), auth); errRegister != nil {
|
|
t.Fatalf("register auth: %v", errRegister)
|
|
}
|
|
registry.GetGlobalRegistry().RegisterClient(auth.ID, auth.Provider, []*registry.ModelInfo{{ID: model}})
|
|
t.Cleanup(func() {
|
|
registry.GetGlobalRegistry().UnregisterClient(auth.ID)
|
|
})
|
|
|
|
chunks <- coreexecutor.StreamChunk{Payload: []byte("event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_1\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"m\",\"stop_reason\":null,\"usage\":{\"input_tokens\":10,\"output_tokens\":1}}}\n\n")}
|
|
chunks <- coreexecutor.StreamChunk{Payload: []byte("event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"partial\"}}\n\n")}
|
|
close(chunks)
|
|
|
|
base := handlers.NewBaseAPIHandlers(&sdkconfig.SDKConfig{}, manager)
|
|
h := NewClaudeCodeAPIHandler(base)
|
|
router := gin.New()
|
|
router.POST("/v1/messages", h.ClaudeMessages)
|
|
|
|
request := httptest.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader("{\"model\":\""+model+"\",\"messages\":[{\"role\":\"user\",\"content\":\"hi\"}],\"stream\":true}"))
|
|
request.Header.Set("Content-Type", "application/json")
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, request)
|
|
|
|
if recorder.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200; body=%q", recorder.Code, recorder.Body.String())
|
|
}
|
|
body := recorder.Body.String()
|
|
if !strings.Contains(body, "event: error\ndata: ") {
|
|
t.Fatalf("expected terminal SSE error event on truncated stream; body=%q", body)
|
|
}
|
|
if !strings.Contains(body, "message_stop") {
|
|
t.Fatalf("expected terminal error message to mention missing message_stop; body=%q", body)
|
|
}
|
|
}
|
|
|
|
func TestClaudeStreamTerminalErrorDoesNotOverwriteSSEStatusWhenUnwritten(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", nil)
|
|
c.Header("Content-Type", "text/event-stream")
|
|
|
|
handler := NewClaudeCodeAPIHandler(&handlers.BaseAPIHandler{})
|
|
errs := make(chan *interfaces.ErrorMessage, 1)
|
|
errs <- &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusBadGateway,
|
|
Error: errors.New("upstream failed after SSE commit"),
|
|
}
|
|
close(errs)
|
|
|
|
handler.forwardClaudeStream(c, c.Writer, func(error) {}, nil, errs)
|
|
|
|
if recorder.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200 for committed SSE stream; body=%q", recorder.Code, recorder.Body.String())
|
|
}
|
|
if !strings.HasPrefix(recorder.Body.String(), "event: error\ndata: ") {
|
|
t.Fatalf("unexpected SSE error body: %q", recorder.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestClaudeStreamTerminalErrorAfterPartialLineStartsOnNewLine(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", nil)
|
|
c.Header("Content-Type", "text/event-stream")
|
|
|
|
handler := NewClaudeCodeAPIHandler(&handlers.BaseAPIHandler{})
|
|
data := make(chan []byte)
|
|
errs := make(chan *interfaces.ErrorMessage)
|
|
go func() {
|
|
data <- []byte("event: content_block_delta\ndata: {\"type\":\"content_block_delta\"")
|
|
errs <- &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusBadGateway,
|
|
Error: errors.New("stream cut mid-line"),
|
|
}
|
|
close(data)
|
|
close(errs)
|
|
}()
|
|
|
|
handler.forwardClaudeStream(c, c.Writer, func(error) {}, data, errs)
|
|
|
|
body := recorder.Body.String()
|
|
if !strings.Contains(body, "\nevent: error\ndata: ") {
|
|
t.Fatalf("expected event: error to start on a fresh line after partial chunk; body=%q", body)
|
|
}
|
|
}
|
|
|
|
func TestClaudeStreamCompleteWithMessageStopDoesNotEmitErrorOnClose(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
|
|
chunks := make(chan coreexecutor.StreamChunk, 2)
|
|
executor := &preFTKeepAliveClaudeExecutor{chunks: chunks}
|
|
manager := coreauth.NewManager(nil, nil, nil)
|
|
manager.RegisterExecutor(executor)
|
|
model := "complete-stream-claude-model"
|
|
auth := &coreauth.Auth{ID: "complete-stream-claude-auth", Provider: executor.Identifier(), Status: coreauth.StatusActive}
|
|
if _, errRegister := manager.Register(context.Background(), auth); errRegister != nil {
|
|
t.Fatalf("register auth: %v", errRegister)
|
|
}
|
|
registry.GetGlobalRegistry().RegisterClient(auth.ID, auth.Provider, []*registry.ModelInfo{{ID: model}})
|
|
t.Cleanup(func() {
|
|
registry.GetGlobalRegistry().UnregisterClient(auth.ID)
|
|
})
|
|
|
|
chunks <- coreexecutor.StreamChunk{Payload: []byte("event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_1\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"m\",\"stop_reason\":null,\"usage\":{\"input_tokens\":10,\"output_tokens\":1}}}\n\n")}
|
|
chunks <- coreexecutor.StreamChunk{Payload: []byte("event: message_stop\ndata: {\"type\":\"message_stop\"}\n\n")}
|
|
close(chunks)
|
|
|
|
base := handlers.NewBaseAPIHandlers(&sdkconfig.SDKConfig{}, manager)
|
|
h := NewClaudeCodeAPIHandler(base)
|
|
router := gin.New()
|
|
router.POST("/v1/messages", h.ClaudeMessages)
|
|
|
|
request := httptest.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader("{\"model\":\""+model+"\",\"messages\":[{\"role\":\"user\",\"content\":\"hi\"}],\"stream\":true}"))
|
|
request.Header.Set("Content-Type", "application/json")
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, request)
|
|
|
|
if recorder.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200; body=%q", recorder.Code, recorder.Body.String())
|
|
}
|
|
if strings.Contains(recorder.Body.String(), "event: error") {
|
|
t.Fatalf("unexpected error event on completed stream: %q", recorder.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestClaudeStreamTerminalErrorAfterSingleNewlineInsertsBlankLine(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", nil)
|
|
c.Header("Content-Type", "text/event-stream")
|
|
|
|
handler := NewClaudeCodeAPIHandler(&handlers.BaseAPIHandler{})
|
|
data := make(chan []byte)
|
|
errs := make(chan *interfaces.ErrorMessage)
|
|
go func() {
|
|
// Ends with a single '\n' (complete line, but missing the blank-line SSE event separator).
|
|
data <- []byte("event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"hi\"}}\n")
|
|
errs <- &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusBadGateway,
|
|
Error: errors.New("stream cut before blank line"),
|
|
}
|
|
close(data)
|
|
close(errs)
|
|
}()
|
|
|
|
handler.forwardClaudeStream(c, c.Writer, func(error) {}, data, errs)
|
|
|
|
body := recorder.Body.String()
|
|
if !strings.Contains(body, "\n\nevent: error\ndata: ") {
|
|
t.Fatalf("expected blank-line SSE separator (\\n\\n) before event: error when prior chunk ended with a single newline; body=%q", body)
|
|
}
|
|
}
|
|
|
|
func TestClaudeStreamBareCompletedMessageJSONDoesNotEmitErrorOnClose(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
|
|
chunks := make(chan coreexecutor.StreamChunk, 1)
|
|
executor := &preFTKeepAliveClaudeExecutor{chunks: chunks}
|
|
manager := coreauth.NewManager(nil, nil, nil)
|
|
manager.RegisterExecutor(executor)
|
|
model := "bare-json-stream-claude-model"
|
|
auth := &coreauth.Auth{ID: "bare-json-stream-claude-auth", Provider: executor.Identifier(), Status: coreauth.StatusActive}
|
|
if _, errRegister := manager.Register(context.Background(), auth); errRegister != nil {
|
|
t.Fatalf("register auth: %v", errRegister)
|
|
}
|
|
registry.GetGlobalRegistry().RegisterClient(auth.ID, auth.Provider, []*registry.ModelInfo{{ID: model}})
|
|
t.Cleanup(func() {
|
|
registry.GetGlobalRegistry().UnregisterClient(auth.ID)
|
|
})
|
|
|
|
chunks <- coreexecutor.StreamChunk{Payload: []byte("{\"id\":\"msg_1\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"m\",\"content\":[{\"type\":\"text\",\"text\":\"ok\"}],\"stop_reason\":\"end_turn\",\"usage\":{\"input_tokens\":1,\"output_tokens\":1}}\n")}
|
|
close(chunks)
|
|
|
|
base := handlers.NewBaseAPIHandlers(&sdkconfig.SDKConfig{}, manager)
|
|
h := NewClaudeCodeAPIHandler(base)
|
|
router := gin.New()
|
|
router.POST("/v1/messages", h.ClaudeMessages)
|
|
|
|
request := httptest.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader("{\"model\":\""+model+"\",\"messages\":[{\"role\":\"user\",\"content\":\"hi\"}],\"stream\":true}"))
|
|
request.Header.Set("Content-Type", "application/json")
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, request)
|
|
|
|
if recorder.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200; body=%q", recorder.Code, recorder.Body.String())
|
|
}
|
|
if strings.Contains(recorder.Body.String(), "event: error") {
|
|
t.Fatalf("unexpected error event after complete bare message JSON: %q", recorder.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestClaudeStreamMessageStopWithArbitraryJSONFormattingCompletesCleanly(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
|
|
chunks := make(chan coreexecutor.StreamChunk, 2)
|
|
executor := &preFTKeepAliveClaudeExecutor{chunks: chunks}
|
|
manager := coreauth.NewManager(nil, nil, nil)
|
|
manager.RegisterExecutor(executor)
|
|
model := "formatted-message-stop-claude-model"
|
|
auth := &coreauth.Auth{ID: "formatted-message-stop-claude-auth", Provider: executor.Identifier(), Status: coreauth.StatusActive}
|
|
if _, errRegister := manager.Register(context.Background(), auth); errRegister != nil {
|
|
t.Fatalf("register auth: %v", errRegister)
|
|
}
|
|
registry.GetGlobalRegistry().RegisterClient(auth.ID, auth.Provider, []*registry.ModelInfo{{ID: model}})
|
|
t.Cleanup(func() {
|
|
registry.GetGlobalRegistry().UnregisterClient(auth.ID)
|
|
})
|
|
|
|
chunks <- coreexecutor.StreamChunk{Payload: []byte("event:message_start\ndata: {\"type\" : \"message_start\", \"message\":{\"id\":\"msg_1\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"m\",\"stop_reason\":null,\"usage\":{\"input_tokens\":10,\"output_tokens\":1}}}\n\n")}
|
|
chunks <- coreexecutor.StreamChunk{Payload: []byte("event:message_stop\ndata: {\"type\" : \"message_stop\"}\n\n")}
|
|
close(chunks)
|
|
|
|
base := handlers.NewBaseAPIHandlers(&sdkconfig.SDKConfig{}, manager)
|
|
h := NewClaudeCodeAPIHandler(base)
|
|
router := gin.New()
|
|
router.POST("/v1/messages", h.ClaudeMessages)
|
|
|
|
request := httptest.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader("{\"model\":\""+model+"\",\"messages\":[{\"role\":\"user\",\"content\":\"hi\"}],\"stream\":true}"))
|
|
request.Header.Set("Content-Type", "application/json")
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, request)
|
|
|
|
if recorder.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200; body=%q", recorder.Code, recorder.Body.String())
|
|
}
|
|
if strings.Contains(recorder.Body.String(), "event: error") {
|
|
t.Fatalf("unexpected error event when valid message_stop used custom spacing: %q", recorder.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestClaudeStreamTextDeltaMentioningMessageStopStillFailsWhenTruncated(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
|
|
chunks := make(chan coreexecutor.StreamChunk, 2)
|
|
executor := &preFTKeepAliveClaudeExecutor{chunks: chunks}
|
|
manager := coreauth.NewManager(nil, nil, nil)
|
|
manager.RegisterExecutor(executor)
|
|
model := "false-positive-message-stop-claude-model"
|
|
auth := &coreauth.Auth{ID: "false-positive-message-stop-claude-auth", Provider: executor.Identifier(), Status: coreauth.StatusActive}
|
|
if _, errRegister := manager.Register(context.Background(), auth); errRegister != nil {
|
|
t.Fatalf("register auth: %v", errRegister)
|
|
}
|
|
registry.GetGlobalRegistry().RegisterClient(auth.ID, auth.Provider, []*registry.ModelInfo{{ID: model}})
|
|
t.Cleanup(func() {
|
|
registry.GetGlobalRegistry().UnregisterClient(auth.ID)
|
|
})
|
|
|
|
chunks <- coreexecutor.StreamChunk{Payload: []byte("event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_1\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"m\",\"stop_reason\":null,\"usage\":{\"input_tokens\":10,\"output_tokens\":1}}}\n\n")}
|
|
chunks <- coreexecutor.StreamChunk{Payload: []byte("event: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"toolu_1\",\"name\":\"emit\",\"input\":{\"type\":\"message_stop\"}}}\n\n")}
|
|
close(chunks)
|
|
|
|
base := handlers.NewBaseAPIHandlers(&sdkconfig.SDKConfig{}, manager)
|
|
h := NewClaudeCodeAPIHandler(base)
|
|
router := gin.New()
|
|
router.POST("/v1/messages", h.ClaudeMessages)
|
|
|
|
request := httptest.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader("{\"model\":\""+model+"\",\"messages\":[{\"role\":\"user\",\"content\":\"hi\"}],\"stream\":true}"))
|
|
request.Header.Set("Content-Type", "application/json")
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, request)
|
|
|
|
if !strings.Contains(recorder.Body.String(), "event: error\ndata: ") {
|
|
t.Fatalf("expected truncated stream to emit terminal SSE error even if text delta mentioned message_stop; body=%q", recorder.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestClaudeStreamTruncatedErrorEventHeaderDoesNotSuppressTerminalError(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", nil)
|
|
c.Header("Content-Type", "text/event-stream")
|
|
|
|
handler := NewClaudeCodeAPIHandler(&handlers.BaseAPIHandler{})
|
|
data := make(chan []byte)
|
|
errs := make(chan *interfaces.ErrorMessage)
|
|
go func() {
|
|
// Upstream started an error event header but dropped before sending a valid data JSON frame.
|
|
data <- []byte("event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_1\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"m\",\"stop_reason\":null,\"usage\":{\"input_tokens\":10,\"output_tokens\":1}}}\n\nevent: error\n")
|
|
errs <- &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusBadGateway,
|
|
Error: errors.New("upstream stream closed before message_stop"),
|
|
}
|
|
close(data)
|
|
close(errs)
|
|
}()
|
|
|
|
handler.forwardClaudeStream(c, c.Writer, func(error) {}, data, errs)
|
|
|
|
body := recorder.Body.String()
|
|
if !strings.Contains(body, "event: error\ndata: {\"type\":\"error\"") {
|
|
t.Fatalf("expected valid terminal SSE error frame after truncated event: error header; body=%q", body)
|
|
}
|
|
}
|
|
|
|
func TestClaudeStreamErrorEventWithoutTrailingBlankLineIsTerminatedOnEOF(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
suffix string
|
|
}{
|
|
{name: "zero trailing newlines", suffix: ""},
|
|
{name: "single trailing newline", suffix: "\n"},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", nil)
|
|
c.Header("Content-Type", "text/event-stream")
|
|
|
|
handler := NewClaudeCodeAPIHandler(&handlers.BaseAPIHandler{})
|
|
data := make(chan []byte)
|
|
errs := make(chan *interfaces.ErrorMessage)
|
|
go func() {
|
|
data <- []byte("event: error\ndata: {\"type\":\"error\",\"error\":{\"type\":\"api_error\",\"message\":\"failed\"}}" + tc.suffix)
|
|
errs <- &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusBadGateway,
|
|
Error: errors.New(`{"type":"error","error":{"type":"api_error","message":"failed"}}`),
|
|
}
|
|
close(data)
|
|
close(errs)
|
|
}()
|
|
|
|
handler.forwardClaudeStream(c, c.Writer, func(error) {}, data, errs)
|
|
|
|
body := recorder.Body.String()
|
|
want := "event: error\ndata: {\"type\":\"error\",\"error\":{\"type\":\"api_error\",\"message\":\"failed\"}}\n\n"
|
|
if body != want {
|
|
t.Fatalf("SSE body = %q, want %q", body, want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestClaudeStreamMessageStopWithoutTrailingBlankLineIsTerminatedOnEOF(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
suffix string
|
|
}{
|
|
{name: "zero trailing newlines", suffix: ""},
|
|
{name: "single trailing newline", suffix: "\n"},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", nil)
|
|
c.Header("Content-Type", "text/event-stream")
|
|
|
|
handler := NewClaudeCodeAPIHandler(&handlers.BaseAPIHandler{})
|
|
data := make(chan []byte, 1)
|
|
data <- []byte("event: message_stop\ndata: {\"type\":\"message_stop\"}" + tc.suffix)
|
|
close(data)
|
|
|
|
handler.forwardClaudeStream(c, c.Writer, func(error) {}, data, nil)
|
|
|
|
body := recorder.Body.String()
|
|
want := "event: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
|
|
if body != want {
|
|
t.Fatalf("SSE body = %q, want %q", body, want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestClaudeMessagesHandlerEmptyStreamClosesWithSSEError(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", nil)
|
|
c.Header("Content-Type", "text/event-stream")
|
|
|
|
handler := NewClaudeCodeAPIHandler(&handlers.BaseAPIHandler{})
|
|
data := make(chan []byte)
|
|
close(data)
|
|
errs := make(chan *interfaces.ErrorMessage)
|
|
close(errs)
|
|
|
|
done := make(chan struct{})
|
|
go func() {
|
|
handler.forwardClaudeStream(c, c.Writer, func(error) {}, data, errs)
|
|
close(done)
|
|
}()
|
|
|
|
select {
|
|
case <-done:
|
|
case <-time.After(3 * time.Second):
|
|
t.Fatal("forwardClaudeStream hung when data and errs channels closed without chunks")
|
|
}
|
|
|
|
if recorder.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want 200; body=%q", recorder.Code, recorder.Body.String())
|
|
}
|
|
body := recorder.Body.String()
|
|
if !strings.Contains(body, "event: error\ndata: ") || !strings.Contains(body, "message_stop") {
|
|
t.Fatalf("expected terminal SSE error event mentioning message_stop on empty stream; body=%q", body)
|
|
}
|
|
}
|
|
|
|
func TestClaudeStreamMultiLineDataEventsAreRecognizedAcrossChunks(t *testing.T) {
|
|
t.Run("multiline message_stop split across chunks", func(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", nil)
|
|
c.Header("Content-Type", "text/event-stream")
|
|
|
|
handler := NewClaudeCodeAPIHandler(&handlers.BaseAPIHandler{})
|
|
data := make(chan []byte, 2)
|
|
data <- []byte("event: message_stop\ndata: {\"type\":\n")
|
|
data <- []byte("data: \"message_stop\"}\n\n")
|
|
close(data)
|
|
|
|
handler.forwardClaudeStream(c, c.Writer, func(error) {}, data, nil)
|
|
|
|
body := recorder.Body.String()
|
|
if strings.Contains(body, "event: error") {
|
|
t.Fatalf("unexpected error event after valid multi-line message_stop; body=%q", body)
|
|
}
|
|
})
|
|
|
|
t.Run("multiline error event split across chunks", func(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", nil)
|
|
c.Header("Content-Type", "text/event-stream")
|
|
|
|
handler := NewClaudeCodeAPIHandler(&handlers.BaseAPIHandler{})
|
|
data := make(chan []byte)
|
|
errs := make(chan *interfaces.ErrorMessage)
|
|
go func() {
|
|
data <- []byte("event: error\ndata: {\"type\":\"error\",\n")
|
|
data <- []byte("data: \"error\":{\"type\":\"api_error\",\"message\":\"boom\"}}\n\n")
|
|
errs <- &interfaces.ErrorMessage{
|
|
StatusCode: http.StatusBadGateway,
|
|
Error: errors.New("boom"),
|
|
}
|
|
close(data)
|
|
close(errs)
|
|
}()
|
|
|
|
handler.forwardClaudeStream(c, c.Writer, func(error) {}, data, errs)
|
|
|
|
body := recorder.Body.String()
|
|
if got := strings.Count(body, "event: error"); got != 1 {
|
|
t.Fatalf("event: error count = %d, want 1; body=%q", got, body)
|
|
}
|
|
})
|
|
|
|
t.Run("multiline tool_use with standalone nested message_stop line still fails when truncated", func(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", nil)
|
|
c.Header("Content-Type", "text/event-stream")
|
|
|
|
handler := NewClaudeCodeAPIHandler(&handlers.BaseAPIHandler{})
|
|
data := make(chan []byte, 1)
|
|
data <- []byte("event: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"toolu_1\",\"name\":\"emit\",\"input\":\ndata: {\"type\":\"message_stop\"}\ndata: }}\n\n")
|
|
close(data)
|
|
|
|
handler.forwardClaudeStream(c, c.Writer, func(error) {}, data, nil)
|
|
|
|
body := recorder.Body.String()
|
|
if !strings.Contains(body, "event: error\ndata: ") {
|
|
t.Fatalf("expected terminal error event when stream truncated after multiline tool_use containing nested message_stop line; body=%q", body)
|
|
}
|
|
})
|
|
}
|