diff --git a/.env.example b/.env.example index 522c8a3..974a3ec 100644 --- a/.env.example +++ b/.env.example @@ -15,5 +15,10 @@ DINGTALK_CLIENT_SECRET= # Tenant key this DingTalk ingress serves (matches tenant_key used by QA). DOBOTAI_TENANT_KEY= +# Optional DingTalk AI card template ID. Leave empty to use markdown-only replies. +# When set, a successful QA answer will be delivered as an AI card; markdown +# is only sent as a fallback when card delivery fails. Never commit real values. +DINGTALK_CARD_TEMPLATE_ID= + # Independent DobotAI PostgreSQL; never point this at WeKnora's database DATABASE_URL=postgres://dobotai:replace-me@127.0.0.1:5432/dobotai?sslmode=disable diff --git a/cmd/dobotai/main.go b/cmd/dobotai/main.go index 3b3a84d..a5f40dc 100644 --- a/cmd/dobotai/main.go +++ b/cmd/dobotai/main.go @@ -72,11 +72,19 @@ func main() { if err != nil { log.Fatal(err) } - handler, err := dingtalk.NewHandler( + var cardSender dingtalk.FinalCardSender + if cardTemplateID := strings.TrimSpace(os.Getenv("DINGTALK_CARD_TEMPLATE_ID")); cardTemplateID != "" { + cs, err := dingtalk.NewCardSender(dingCfg.ClientID, dingCfg.ClientSecret, cardTemplateID, nil) + if err != nil { + log.Fatalf("DingTalk card sender init failed: %v", err) + } + cardSender = cs + } + handler, err := dingtalk.NewHandlerWithOptions( dingtalk.TenantConfig{TenantKey: dingCfg.TenantKey, Channel: "dingtalk"}, qaService, sender, - downloader, + dingtalk.HandlerOptions{ImageDownloader: downloader, CardSender: cardSender}, ) if err != nil { log.Fatal(err) diff --git a/internal/channels/dingtalk/card.go b/internal/channels/dingtalk/card.go new file mode 100644 index 0000000..bc7bafe --- /dev/null +++ b/internal/channels/dingtalk/card.go @@ -0,0 +1,351 @@ +package dingtalk + +import ( + "bytes" + "context" + "crypto/rand" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "strings" + "sync" + "time" + + "gitea.zheromiku.top/Weknora/dobotai-platform/internal/core" +) + +const ( + cardCreateURL = "https://api.dingtalk.com/v1.0/card/instances/createAndDeliver" + cardStreamingURL = "https://api.dingtalk.com/v1.0/card/streaming" +) + +// CardRequest is the input for sending a final AI card. +type CardRequest struct { + ConversationType core.ConversationType + ExternalUserID string + ExternalChatID string + Content string +} + +// CardSender sends DingTalk AI cards via the OpenAPI. +type CardSender struct { + clientID string + clientSecret string + cardTemplateID string + tokenURL string + createURL string + streamURL string + apiClient *http.Client + allowTestURL bool + + mu sync.Mutex + token string + tokenTill time.Time +} + +// NewCardSender creates a CardSender. All three config values are required +// after trimming whitespace. A nil http.Client installs a hardened default +// (no redirects, Proxy=nil, 15s timeout). +func NewCardSender(clientID, clientSecret, cardTemplateID string, client *http.Client) (*CardSender, error) { + return newCardSender(clientID, clientSecret, cardTemplateID, client, oauthTokenURL, cardCreateURL, cardStreamingURL, false) +} + +// newCardSenderForTest is used by tests to inject httptest URLs. +func newCardSenderForTest(clientID, clientSecret, cardTemplateID string, client *http.Client, tokenURL, createURL string) (*CardSender, error) { + streamURL := strings.TrimSuffix(createURL, "/create") + "/stream" + return newCardSender(clientID, clientSecret, cardTemplateID, client, tokenURL, createURL, streamURL, true) +} + +func newCardSender(clientID, clientSecret, cardTemplateID string, client *http.Client, tokenURL, createURL, streamURL string, allowTest bool) (*CardSender, error) { + clientID = strings.TrimSpace(clientID) + clientSecret = strings.TrimSpace(clientSecret) + cardTemplateID = strings.TrimSpace(cardTemplateID) + if clientID == "" { + return nil, errors.New("dingtalk card sender: clientID is required") + } + if clientSecret == "" { + return nil, errors.New("dingtalk card sender: clientSecret is required") + } + if cardTemplateID == "" { + return nil, errors.New("dingtalk card sender: cardTemplateID is required") + } + + base := &http.Client{Timeout: 15 * time.Second} + if client != nil { + copyClient := *client + base = ©Client + if base.Timeout <= 0 { + base.Timeout = 15 * time.Second + } + } + + apiClient := *base + apiClient.CheckRedirect = func(*http.Request, []*http.Request) error { + return errors.New("dingtalk API redirect refused") + } + if !allowTest { + transport := http.DefaultTransport.(*http.Transport).Clone() + transport.Proxy = nil + apiClient.Transport = transport + } + + return &CardSender{ + clientID: clientID, + clientSecret: clientSecret, + cardTemplateID: cardTemplateID, + tokenURL: tokenURL, + createURL: createURL, + streamURL: streamURL, + apiClient: &apiClient, + allowTestURL: allowTest, + }, nil +} + +// SendFinalCard sends the AI card to DingTalk and returns the generated outTrackID. +// It is a thin wrapper: StartCard → UpdateCard(finalize=true). +func (s *CardSender) SendFinalCard(ctx context.Context, req CardRequest) (string, error) { + outTrackID, err := s.StartCard(ctx, req) + if err != nil { + return "", err + } + if err := s.UpdateCard(ctx, outTrackID, req.Content, true, false); err != nil { + return "", err + } + return outTrackID, nil +} + +// StartCard creates a card instance via createAndDeliver and returns the +// generated outTrackID. It does NOT call the streaming finalize endpoint; +// callers must use UpdateCard to stream content. +func (s *CardSender) StartCard(ctx context.Context, req CardRequest) (string, error) { + // Validate conversation type before any API call + if req.ConversationType != core.ConversationDirect && req.ConversationType != core.ConversationGroup { + return "", fmt.Errorf("dingtalk card: unsupported conversation type %q", req.ConversationType) + } + + // Validate content + req.Content = strings.TrimSpace(req.Content) + if req.Content == "" { + return "", errors.New("dingtalk card: content is required") + } + if len(req.Content) > 64*1024 { + return "", errors.New("dingtalk card: content exceeds 64 KiB") + } + + // Validate identity fields + if req.ConversationType == core.ConversationDirect { + req.ExternalUserID = strings.TrimSpace(req.ExternalUserID) + if req.ExternalUserID == "" { + return "", errors.New("dingtalk card: ExternalUserID is required for direct conversations") + } + } else { + req.ExternalChatID = strings.TrimSpace(req.ExternalChatID) + if req.ExternalChatID == "" { + return "", errors.New("dingtalk card: ExternalChatID is required for group conversations") + } + } + + // Generate outTrackID + outTrackID, err := generateUUID() + if err != nil { + return "", fmt.Errorf("dingtalk card: generate outTrackId: %w", err) + } + + // Build card body + body := s.buildCardBody(req, outTrackID) + + // Get access token + token, err := s.accessToken(ctx) + if err != nil { + return "", err + } + + // Send card (create only, no finalize) + if err := s.postCard(ctx, body, token); err != nil { + return "", err + } + + return outTrackID, nil +} + +// UpdateCard sends a streaming update to an existing card. outTrackID and +// content must be non-empty after trimming; content must not exceed 64 KiB. +// Set isFinalize=true to close the card; set isError=true to mark the card +// as an error state. +func (s *CardSender) UpdateCard(ctx context.Context, outTrackID, content string, isFinalize, isError bool) error { + outTrackID = strings.TrimSpace(outTrackID) + if outTrackID == "" { + return errors.New("dingtalk card: outTrackID is required") + } + content = strings.TrimSpace(content) + if content == "" { + return errors.New("dingtalk card: content is required") + } + if len(content) > 64*1024 { + return errors.New("dingtalk card: content exceeds 64 KiB") + } + + token, err := s.accessToken(ctx) + if err != nil { + return err + } + + return s.finalizeCard(ctx, outTrackID, content, token, isFinalize, isError) +} + +func (s *CardSender) buildCardBody(req CardRequest, outTrackID string) map[string]any { + body := map[string]any{ + "cardTemplateId": s.cardTemplateID, + "outTrackId": outTrackID, + "callbackType": "STREAM", + "cardData": map[string]any{ + "cardParamMap": map[string]any{ + "content": req.Content, + }, + }, + "userIdType": 1, + } + + if req.ConversationType == core.ConversationDirect { + body["openSpaceId"] = "dtv1.card//IM_ROBOT." + req.ExternalUserID + body["imRobotOpenSpaceModel"] = map[string]any{ + "supportForward": true, + } + body["imRobotOpenDeliverModel"] = map[string]any{ + "robotCode": s.clientID, + "spaceType": "IM_ROBOT", + "extension": map[string]any{}, + } + } else { + body["openSpaceId"] = "dtv1.card//IM_GROUP." + req.ExternalChatID + body["imGroupOpenSpaceModel"] = map[string]any{ + "supportForward": true, + } + body["imGroupOpenDeliverModel"] = map[string]any{ + "robotCode": s.clientID, + "extension": map[string]any{}, + } + } + return body +} + +func (s *CardSender) accessToken(ctx context.Context) (string, error) { + s.mu.Lock() + defer s.mu.Unlock() + if s.token != "" && time.Now().Before(s.tokenTill) { + return s.token, nil + } + + payload, err := s.postJSON(ctx, s.tokenURL, map[string]string{ + "appKey": s.clientID, + "appSecret": s.clientSecret, + }, "") + if err != nil { + return "", err + } + + var response struct { + AccessToken string `json:"accessToken"` + ExpireIn int64 `json:"expireIn"` + } + if json.Unmarshal(payload, &response) != nil || strings.TrimSpace(response.AccessToken) == "" { + return "", errors.New("dingtalk card: invalid OAuth response") + } + + ttl := time.Duration(response.ExpireIn) * time.Second + refreshAfter := ttl - 5*time.Minute + if refreshAfter <= 0 { + refreshAfter = ttl / 2 + } + if refreshAfter <= 0 { + refreshAfter = time.Minute + } + s.token = response.AccessToken + s.tokenTill = time.Now().Add(refreshAfter) + return s.token, nil +} + +func (s *CardSender) postCard(ctx context.Context, body map[string]any, token string) error { + payload, err := s.postJSON(ctx, s.createURL, body, token) + if err != nil { + return err + } + // Discard successful response body + if len(payload) > 0 { + // Body is already bounded by postJSON→readBoundedAPIResponse; just discard + } + return nil +} + +func (s *CardSender) finalizeCard(ctx context.Context, outTrackID, content, token string, isFinalize, isError bool) error { + guid, err := generateUUID() + if err != nil { + return errors.New("dingtalk card: generate stream guid failed") + } + body := map[string]any{ + "outTrackId": outTrackID, + "guid": guid, + "key": "content", + "content": content, + "isFull": true, + "isFinalize": isFinalize, + "isError": isError, + } + _, err = s.doJSON(ctx, http.MethodPut, s.streamURL, body, token) + return err +} + +func (s *CardSender) postJSON(ctx context.Context, endpoint string, value any, token string) ([]byte, error) { + return s.doJSON(ctx, http.MethodPost, endpoint, value, token) +} + +func (s *CardSender) doJSON(ctx context.Context, method, endpoint string, value any, token string) ([]byte, error) { + body, err := json.Marshal(value) + if err != nil { + return nil, errors.New("dingtalk card: encode API request failed") + } + + req, err := http.NewRequestWithContext(ctx, method, endpoint, bytes.NewReader(body)) + if err != nil { + return nil, errors.New("dingtalk card: create API request failed") + } + req.Header.Set("Content-Type", "application/json") + if token != "" { + req.Header.Set("x-acs-dingtalk-access-token", token) + } + + resp, err := s.apiClient.Do(req) + if err != nil { + if ctx.Err() != nil { + return nil, ctx.Err() + } + return nil, errors.New("dingtalk card: API request failed") + } + defer resp.Body.Close() + + if resp.StatusCode < 200 || resp.StatusCode >= 300 { + // Discard body without reading it + _, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, maxAPIResponseBytes)) + return nil, fmt.Errorf("dingtalk card: API HTTP %d", resp.StatusCode) + } + + return readBoundedAPIResponse(resp) +} + +// generateUUID creates a UUID v4 (random) using crypto/rand, formatted as +// lowercase hex with dashes: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx. +func generateUUID() (string, error) { + var b [16]byte + if _, err := rand.Read(b[:]); err != nil { + return "", err + } + // Set version 4 + b[6] = (b[6] & 0x0f) | 0x40 + // Set variant bits (10xx) + b[8] = (b[8] & 0x3f) | 0x80 + + return fmt.Sprintf("%x-%x-%x-%x-%x", + b[0:4], b[4:6], b[6:8], b[8:10], b[10:16]), nil +} diff --git a/internal/channels/dingtalk/card_pump.go b/internal/channels/dingtalk/card_pump.go new file mode 100644 index 0000000..dcdd22a --- /dev/null +++ b/internal/channels/dingtalk/card_pump.go @@ -0,0 +1,91 @@ +package dingtalk + +import ( + "context" + "log" + "sync" + "time" +) + +type cardPumpUpdate func(context.Context, string) error + +type cardUpdatePump struct { + updates chan string + stop chan struct{} + done chan struct{} + once sync.Once +} + +func newCardUpdatePump(ctx context.Context, interval time.Duration, update cardPumpUpdate) *cardUpdatePump { + if interval <= 0 { + interval = 500 * time.Millisecond + } + ticker := time.NewTicker(interval) + return newCardUpdatePumpWithTicks(ctx, ticker.C, ticker.Stop, update) +} + +func newCardUpdatePumpWithTicks(ctx context.Context, ticks <-chan time.Time, stopTicks func(), update cardPumpUpdate) *cardUpdatePump { + p := &cardUpdatePump{ + updates: make(chan string, 1), + stop: make(chan struct{}), + done: make(chan struct{}), + } + go p.run(ctx, ticks, stopTicks, update) + return p +} + +func (p *cardUpdatePump) run(ctx context.Context, ticks <-chan time.Time, stopTicks func(), update cardPumpUpdate) { + defer close(p.done) + if stopTicks != nil { + defer stopTicks() + } + for { + select { + case <-ctx.Done(): + return + case <-p.stop: + return + case <-ticks: + var latest string + select { + case latest = <-p.updates: + default: + continue + } + if err := update(ctx, latest); err != nil { + log.Printf("DingTalk async card update failed, continuing") + } + } + } +} + +// Offer replaces any pending content with the newest full card state. It never +// waits for DingTalk I/O, so the WeKnora SSE reader cannot be back-pressured by +// card delivery latency. +func (p *cardUpdatePump) Offer(content string) { + select { + case <-p.stop: + return + default: + } + select { + case p.updates <- content: + return + default: + } + select { + case <-p.updates: + default: + } + select { + case p.updates <- content: + case <-p.stop: + } +} + +// Stop prevents stale non-final updates from racing with the synchronous final +// card update and waits for any in-flight DingTalk request to finish. +func (p *cardUpdatePump) Stop() { + p.once.Do(func() { close(p.stop) }) + <-p.done +} diff --git a/internal/channels/dingtalk/card_pump_test.go b/internal/channels/dingtalk/card_pump_test.go new file mode 100644 index 0000000..4e4859b --- /dev/null +++ b/internal/channels/dingtalk/card_pump_test.go @@ -0,0 +1,109 @@ +package dingtalk + +import ( + "context" + "errors" + "testing" + "time" +) + +func waitPumpUpdate(t *testing.T, updates <-chan string) string { + t.Helper() + select { + case got := <-updates: + return got + case <-time.After(time.Second): + t.Fatal("timed out waiting for card pump update") + return "" + } +} + +func TestCardUpdatePumpCoalescesToLatestWithoutBlockingOffer(t *testing.T) { + ticks := make(chan time.Time, 2) + observed := make(chan string, 2) + pump := newCardUpdatePumpWithTicks(context.Background(), ticks, nil, func(_ context.Context, content string) error { + observed <- content + return nil + }) + defer pump.Stop() + + pump.Offer("one") + pump.Offer("two") + pump.Offer("latest") + ticks <- time.Now() + if got := waitPumpUpdate(t, observed); got != "latest" { + t.Fatalf("update=%q want latest", got) + } +} + +func TestCardUpdatePumpCoalescesWhileDingTalkRequestIsBlocked(t *testing.T) { + ticks := make(chan time.Time, 3) + started := make(chan string, 2) + release := make(chan struct{}) + pump := newCardUpdatePumpWithTicks(context.Background(), ticks, nil, func(_ context.Context, content string) error { + started <- content + <-release + return nil + }) + + pump.Offer("first") + ticks <- time.Now() + if got := waitPumpUpdate(t, started); got != "first" { + t.Fatalf("first update=%q", got) + } + + // These offers must not block behind the in-flight HTTP request and only the + // newest state should survive. + pump.Offer("second") + pump.Offer("third") + pump.Offer("newest") + close(release) + ticks <- time.Now() + if got := waitPumpUpdate(t, started); got != "newest" { + t.Fatalf("coalesced update=%q want newest", got) + } + pump.Stop() +} + +func TestCardUpdatePumpContinuesAfterUpdateError(t *testing.T) { + ticks := make(chan time.Time, 2) + calls := make(chan string, 2) + count := 0 + pump := newCardUpdatePumpWithTicks(context.Background(), ticks, nil, func(_ context.Context, content string) error { + count++ + calls <- content + if count == 1 { + return errors.New("token and content must not be logged") + } + return nil + }) + defer pump.Stop() + + pump.Offer("first") + ticks <- time.Now() + _ = waitPumpUpdate(t, calls) + pump.Offer("second") + ticks <- time.Now() + if got := waitPumpUpdate(t, calls); got != "second" { + t.Fatalf("second update=%q", got) + } +} + +func TestCardUpdatePumpStopDropsPendingAndIsIdempotent(t *testing.T) { + ticks := make(chan time.Time, 1) + observed := make(chan string, 1) + pump := newCardUpdatePumpWithTicks(context.Background(), ticks, nil, func(_ context.Context, content string) error { + observed <- content + return nil + }) + pump.Offer("stale") + pump.Stop() + pump.Stop() + pump.Offer("after-stop") + + select { + case got := <-observed: + t.Fatalf("unexpected update after stop: %q", got) + default: + } +} diff --git a/internal/channels/dingtalk/card_test.go b/internal/channels/dingtalk/card_test.go new file mode 100644 index 0000000..02369ea --- /dev/null +++ b/internal/channels/dingtalk/card_test.go @@ -0,0 +1,1178 @@ +package dingtalk + +import ( + "context" + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "gitea.zheromiku.top/Weknora/dobotai-platform/internal/core" +) + +// --------------------------------------------------------------------------- +// Helper: start a test server with token + create endpoints +// --------------------------------------------------------------------------- + +type cardTestServer struct { + server *httptest.Server + tokenCalls int + createCalls int + streamCalls int + lastTokenBody map[string]string + lastCreateBody map[string]any + lastCreateHeader string + lastStreamBody map[string]any + lastStreamHeader string + lastStreamMethod string + // configurable responses + tokenResponse any + tokenStatus int + createResponse any + createStatus int + createBodySize int64 // Content-Length for oversized response + streamStatus int + streamBodySize int64 +} + +func newCardTestServer() *cardTestServer { + ts := &cardTestServer{ + tokenStatus: http.StatusOK, + createStatus: http.StatusOK, + streamStatus: http.StatusOK, + tokenResponse: map[string]any{"accessToken": "test-access-token", "expireIn": 3600}, + createResponse: map[string]any{"result": "ok"}, + } + ts.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case "/token": + ts.tokenCalls++ + if ts.tokenStatus != http.StatusOK { + w.WriteHeader(ts.tokenStatus) + return + } + ts.lastTokenBody = make(map[string]string) + json.NewDecoder(r.Body).Decode(&ts.lastTokenBody) + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(ts.tokenResponse) + case "/create": + ts.createCalls++ + ts.lastCreateHeader = r.Header.Get("x-acs-dingtalk-access-token") + if ts.createStatus != http.StatusOK { + w.WriteHeader(ts.createStatus) + return + } + if ts.createBodySize > 0 { + // Write the oversized body; Content-Length is deliberately omitted + // so the reader sees the actual size via LimitReader. + w.WriteHeader(ts.createStatus) + io.Copy(w, io.LimitReader(strings.NewReader(strings.Repeat("x", int(ts.createBodySize))), ts.createBodySize)) + return + } + ts.lastCreateBody = make(map[string]any) + json.NewDecoder(r.Body).Decode(&ts.lastCreateBody) + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(ts.createResponse) + case "/stream": + ts.streamCalls++ + ts.lastStreamMethod = r.Method + ts.lastStreamHeader = r.Header.Get("x-acs-dingtalk-access-token") + ts.lastStreamBody = make(map[string]any) + json.NewDecoder(r.Body).Decode(&ts.lastStreamBody) + if ts.streamStatus != http.StatusOK { + w.WriteHeader(ts.streamStatus) + return + } + if ts.streamBodySize > 0 { + w.WriteHeader(ts.streamStatus) + io.Copy(w, io.LimitReader(strings.NewReader(strings.Repeat("x", int(ts.streamBodySize))), ts.streamBodySize)) + return + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string]any{"result": "ok"}) + default: + http.NotFound(w, r) + } + })) + return ts +} + +func (ts *cardTestServer) Close() { + ts.server.Close() +} + +func (ts *cardTestServer) URL() string { + return ts.server.URL +} + +func (ts *cardTestServer) Client() *http.Client { + return ts.server.Client() +} + +// --------------------------------------------------------------------------- +// Test: missing config +// --------------------------------------------------------------------------- + +func TestCardSenderMissingConfig(t *testing.T) { + tests := []struct { + name, id, secret, template string + }{ + {"empty id", "", "secret", "tpl"}, + {"empty secret", "id", "", "tpl"}, + {"empty template", "id", "secret", ""}, + {"whitespace id", " ", "secret", "tpl"}, + {"whitespace secret", "id", " ", "tpl"}, + {"whitespace template", "id", "secret", " "}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := NewCardSender(tt.id, tt.secret, tt.template, nil) + if err == nil { + t.Fatal("expected error, got nil") + } + if got != nil { + t.Fatal("expected nil sender on error") + } + }) + } +} + +// --------------------------------------------------------------------------- +// Test: direct conversation full payload +// --------------------------------------------------------------------------- + +func TestCardSendDirectPayload(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("client-id", "client-secret", "card-template-123", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + req := CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user-456", + Content: "Hello from AI", + } + outTrackID, err := sender.SendFinalCard(context.Background(), req) + if err != nil { + t.Fatalf("SendFinalCard: %v", err) + } + + // Verify outTrackID is UUID format + if !isUUID(outTrackID) { + t.Fatalf("outTrackID is not a UUID: %q", outTrackID) + } + + // Verify token was called + if ts.tokenCalls != 1 { + t.Fatalf("tokenCalls=%d, want 1", ts.tokenCalls) + } + + // Verify OAuth body fields + if ts.lastTokenBody["appKey"] != "client-id" || ts.lastTokenBody["appSecret"] != "client-secret" { + t.Fatalf("OAuth body fields: appKey=%q appSecret=%q", ts.lastTokenBody["appKey"], ts.lastTokenBody["appSecret"]) + } + + // Verify create header + if ts.lastCreateHeader != "test-access-token" { + t.Fatalf("create header token=%q", ts.lastCreateHeader) + } + if ts.streamCalls != 1 { + t.Fatalf("streamCalls=%d, want 1", ts.streamCalls) + } + if ts.lastStreamMethod != http.MethodPut { + t.Fatalf("stream method=%q, want PUT", ts.lastStreamMethod) + } + if ts.lastStreamHeader != "test-access-token" { + t.Fatalf("stream header token=%q", ts.lastStreamHeader) + } + if ts.lastStreamBody["outTrackId"] != outTrackID || ts.lastStreamBody["key"] != "content" || + ts.lastStreamBody["content"] != "Hello from AI" || ts.lastStreamBody["isFull"] != true || + ts.lastStreamBody["isFinalize"] != true || ts.lastStreamBody["isError"] != false { + t.Fatalf("unexpected final stream body: %#v", ts.lastStreamBody) + } + + // Verify create body + body := ts.lastCreateBody + if body["cardTemplateId"] != "card-template-123" { + t.Errorf("cardTemplateId=%v", body["cardTemplateId"]) + } + if body["outTrackId"] != outTrackID { + t.Errorf("outTrackId=%v, want %v (returned value must equal body)", body["outTrackId"], outTrackID) + } + if body["callbackType"] != "STREAM" { + t.Errorf("callbackType=%v", body["callbackType"]) + } + cardData, ok := body["cardData"].(map[string]any) + if !ok { + t.Fatal("cardData missing or wrong type") + } + paramMap, ok := cardData["cardParamMap"].(map[string]any) + if !ok { + t.Fatal("cardParamMap missing or wrong type") + } + if paramMap["content"] != "Hello from AI" { + t.Errorf("content=%v", paramMap["content"]) + } + if body["userIdType"] != float64(1) { + t.Errorf("userIdType=%v", body["userIdType"]) + } + + // Direct-specific fields + if body["openSpaceId"] != "dtv1.card//IM_ROBOT.user-456" { + t.Errorf("openSpaceId=%v", body["openSpaceId"]) + } + imRobotModel, ok := body["imRobotOpenSpaceModel"].(map[string]any) + if !ok { + t.Fatal("imRobotOpenSpaceModel missing") + } + if imRobotModel["supportForward"] != true { + t.Errorf("supportForward=%v", imRobotModel["supportForward"]) + } + + deliverModel, ok := body["imRobotOpenDeliverModel"].(map[string]any) + if !ok { + t.Fatal("imRobotOpenDeliverModel missing") + } + if deliverModel["robotCode"] != "client-id" { + t.Errorf("robotCode=%v", deliverModel["robotCode"]) + } + if deliverModel["spaceType"] != "IM_ROBOT" { + t.Errorf("spaceType=%v", deliverModel["spaceType"]) + } + ext, ok := deliverModel["extension"].(map[string]any) + if !ok { + t.Fatal("extension missing") + } + if len(ext) != 0 { + t.Errorf("extension should be empty, got %v", ext) + } + + // Group-specific fields must NOT be present + if _, ok := body["imGroupOpenSpaceModel"]; ok { + t.Error("imGroupOpenSpaceModel should not be present for direct") + } + if _, ok := body["imGroupOpenDeliverModel"]; ok { + t.Error("imGroupOpenDeliverModel should not be present for direct") + } +} + +// --------------------------------------------------------------------------- +// Test: group conversation full payload +// --------------------------------------------------------------------------- + +func TestCardSendGroupPayload(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("client-id", "client-secret", "card-template-123", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + req := CardRequest{ + ConversationType: core.ConversationGroup, + ExternalChatID: "chat-789", + Content: "Group message", + } + outTrackID, err := sender.SendFinalCard(context.Background(), req) + if err != nil { + t.Fatalf("SendFinalCard: %v", err) + } + + if !isUUID(outTrackID) { + t.Fatalf("outTrackID is not a UUID: %q", outTrackID) + } + + body := ts.lastCreateBody + + // Group-specific fields + if body["openSpaceId"] != "dtv1.card//IM_GROUP.chat-789" { + t.Errorf("openSpaceId=%v", body["openSpaceId"]) + } + + groupModel, ok := body["imGroupOpenSpaceModel"].(map[string]any) + if !ok { + t.Fatal("imGroupOpenSpaceModel missing") + } + if groupModel["supportForward"] != true { + t.Errorf("supportForward=%v", groupModel["supportForward"]) + } + + deliverModel, ok := body["imGroupOpenDeliverModel"].(map[string]any) + if !ok { + t.Fatal("imGroupOpenDeliverModel missing") + } + if deliverModel["robotCode"] != "client-id" { + t.Errorf("robotCode=%v", deliverModel["robotCode"]) + } + ext, ok := deliverModel["extension"].(map[string]any) + if !ok { + t.Fatal("extension missing") + } + if len(ext) != 0 { + t.Errorf("extension should be empty, got %v", ext) + } + + // Direct-specific fields must NOT be present + if _, ok := body["imRobotOpenSpaceModel"]; ok { + t.Error("imRobotOpenSpaceModel should not be present for group") + } + if _, ok := body["imRobotOpenDeliverModel"]; ok { + t.Error("imRobotOpenDeliverModel should not be present for group") + } +} + +// --------------------------------------------------------------------------- +// Test: OAuth token reuse (cache) +// --------------------------------------------------------------------------- + +func TestCardOAuthTokenReuse(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("client-id", "client-secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + for i := 0; i < 3; i++ { + req := CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user-1", + Content: "msg", + } + if _, err := sender.SendFinalCard(context.Background(), req); err != nil { + t.Fatalf("call %d: %v", i, err) + } + } + + if ts.tokenCalls != 1 { + t.Fatalf("tokenCalls=%d, want 1 (token should be cached)", ts.tokenCalls) + } + if ts.createCalls != 3 { + t.Fatalf("createCalls=%d, want 3", ts.createCalls) + } +} + +// --------------------------------------------------------------------------- +// Test: missing identity fields +// --------------------------------------------------------------------------- + +func TestCardSendMissingIdentity(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + // Direct without ExternalUserID + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + Content: "msg", + }) + if err == nil { + t.Fatal("direct without ExternalUserID should fail") + } + + // Group without ExternalChatID + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationGroup, + Content: "msg", + }) + if err == nil { + t.Fatal("group without ExternalChatID should fail") + } + + // Verify no API calls were made + if ts.tokenCalls != 0 || ts.createCalls != 0 { + t.Fatal("API should not be called when identity is missing") + } +} + +// --------------------------------------------------------------------------- +// Test: empty content and over 64KiB +// --------------------------------------------------------------------------- + +func TestCardSendContentValidation(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + // Empty content + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user", + Content: "", + }) + if err == nil { + t.Fatal("empty content should fail") + } + + // Whitespace-only content + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user", + Content: " ", + }) + if err == nil { + t.Fatal("whitespace-only content should fail") + } + + // Over 64KiB (UTF-8 bytes) + over64KiB := strings.Repeat("中", 21846) // 21846*3 = 65538 > 64*1024 + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user", + Content: over64KiB, + }) + if err == nil { + t.Fatal("over 64KiB content should fail") + } + + // Verify no API calls were made + if ts.tokenCalls != 0 || ts.createCalls != 0 { + t.Fatal("API should not be called when content validation fails") + } +} + +// --------------------------------------------------------------------------- +// Test: OAuth non-2xx +// --------------------------------------------------------------------------- + +func TestCardOAuthNon2xx(t *testing.T) { + ts := newCardTestServer() + ts.tokenStatus = http.StatusUnauthorized + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user", + Content: "msg", + }) + if err == nil { + t.Fatal("OAuth non-2xx should fail") + } + + // Error must not contain secret + if strings.Contains(err.Error(), "secret") { + t.Fatalf("error should not leak secret: %v", err) + } +} + +// --------------------------------------------------------------------------- +// Test: create card non-2xx (no body leaked) +// --------------------------------------------------------------------------- + +func TestCardCreateNon2xx(t *testing.T) { + ts := newCardTestServer() + ts.createStatus = http.StatusInternalServerError + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user", + Content: "msg", + }) + if err == nil { + t.Fatal("create non-2xx should fail") + } + + // Error must not contain secret, token, or content + for _, secret := range []string{"secret", "test-access-token", "msg"} { + if strings.Contains(err.Error(), secret) { + t.Fatalf("error leaked %q: %v", secret, err) + } + } +} + +// --------------------------------------------------------------------------- +// Test: redirect does not leak token +// --------------------------------------------------------------------------- + +func TestCardRedirectNoTokenLeak(t *testing.T) { + var leaked string + target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + leaked = r.Header.Get("x-acs-dingtalk-access-token") + w.WriteHeader(http.StatusNoContent) + })) + defer target.Close() + + var source *httptest.Server + source = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path == "/token" { + json.NewEncoder(w).Encode(map[string]any{"accessToken": "top-secret-token", "expireIn": 3600}) + return + } + http.Redirect(w, r, target.URL, http.StatusFound) + })) + defer source.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", source.Client(), source.URL+"/token", source.URL+"/create") + if err != nil { + t.Fatal(err) + } + + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user", + Content: "msg", + }) + if err == nil { + t.Fatal("API redirect should fail") + } + if leaked != "" { + t.Fatalf("token leaked across redirect: %q", leaked) + } +} + +// --------------------------------------------------------------------------- +// Test: API response over 1MiB +// --------------------------------------------------------------------------- + +func TestCardAPIResponseOversize(t *testing.T) { + ts := newCardTestServer() + ts.createBodySize = maxAPIResponseBytes + 1 + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user", + Content: "msg", + }) + if err == nil { + t.Fatal("oversized API response should fail") + } +} + +// --------------------------------------------------------------------------- +// Test: error does not contain secret, token, or content +// --------------------------------------------------------------------------- + +func TestCardErrorNoSecrets(t *testing.T) { + // Use a server that returns HTTP 500 for create + ts := newCardTestServer() + ts.createStatus = http.StatusInternalServerError + defer ts.Close() + + sender, err := newCardSenderForTest("my-client", "my-secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user", + Content: "sensitive content here", + }) + if err == nil { + t.Fatal("should fail") + } + + errStr := err.Error() + for _, secret := range []string{"my-secret", "test-access-token", "sensitive content here"} { + if strings.Contains(errStr, secret) { + t.Fatalf("error leaked %q: %v", secret, err) + } + } +} + +// --------------------------------------------------------------------------- +// Test: outTrackID is UUID format and equals body value +// --------------------------------------------------------------------------- + +func TestCardOutTrackIDUUID(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + outTrackID, err := sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user", + Content: "msg", + }) + if err != nil { + t.Fatal(err) + } + + if !isUUID(outTrackID) { + t.Fatalf("outTrackID is not a valid UUID: %q", outTrackID) + } + + // Verify the outTrackID returned matches the body field + body := ts.lastCreateBody + bodyTrackID, ok := body["outTrackId"].(string) + if !ok || bodyTrackID != outTrackID { + t.Fatalf("body outTrackId=%v, return value=%v", bodyTrackID, outTrackID) + } +} + +// --------------------------------------------------------------------------- +// Test: unsupported conversation type rejected before API +// --------------------------------------------------------------------------- + +func TestCardSendUnsupportedConversationType(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: "unknown", + Content: "msg", + }) + if err == nil { + t.Fatal("unsupported conversation type should fail") + } + + // Verify no API calls were made + if ts.tokenCalls != 0 || ts.createCalls != 0 { + t.Fatal("API should not be called for unsupported conversation type") + } +} + +// --------------------------------------------------------------------------- +// Test: 64KiB boundary — exactly 64KiB should succeed +// --------------------------------------------------------------------------- + +func TestCardSend64KiBBoundary(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + // Exactly 64KiB of ASCII + content64KiB := strings.Repeat("a", 64*1024) + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user", + Content: content64KiB, + }) + if err != nil { + t.Fatalf("exactly 64KiB should succeed: %v", err) + } + + // 64KiB + 1 byte should fail + content64KiBPlus1 := strings.Repeat("a", 64*1024+1) + _, err = sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user", + Content: content64KiBPlus1, + }) + if err == nil { + t.Fatal("64KiB+1 should fail") + } +} + +// --------------------------------------------------------------------------- +// Test: StartCard creates only — no stream finalize call +// --------------------------------------------------------------------------- + +func TestStartCardCreateOnly(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + outTrackID, err := sender.StartCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user-1", + Content: "Thinking...", + }) + if err != nil { + t.Fatalf("StartCard: %v", err) + } + if !isUUID(outTrackID) { + t.Fatalf("outTrackID is not a UUID: %q", outTrackID) + } + + // Must have exactly 1 create call, 0 stream calls + if ts.createCalls != 1 { + t.Fatalf("createCalls=%d, want 1", ts.createCalls) + } + if ts.streamCalls != 0 { + t.Fatalf("streamCalls=%d, want 0 (StartCard must not finalize)", ts.streamCalls) + } + if ts.tokenCalls != 1 { + t.Fatalf("tokenCalls=%d, want 1", ts.tokenCalls) + } +} + +// --------------------------------------------------------------------------- +// Test: UpdateCard sends PUT with exact payload fields +// --------------------------------------------------------------------------- + +func TestUpdateCardExactPayload(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + // Start a card first + outTrackID, err := sender.StartCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user-1", + Content: "Thinking...", + }) + if err != nil { + t.Fatalf("StartCard: %v", err) + } + + // Reset stream call count (StartCard doesn't call stream) + streamCallsBefore := ts.streamCalls + + // UpdateCard with finalize + err = sender.UpdateCard(context.Background(), outTrackID, "Updated content", true, false) + if err != nil { + t.Fatalf("UpdateCard: %v", err) + } + + if ts.streamCalls != streamCallsBefore+1 { + t.Fatalf("streamCalls=%d, want %d", ts.streamCalls, streamCallsBefore+1) + } + if ts.lastStreamMethod != http.MethodPut { + t.Fatalf("stream method=%q, want PUT", ts.lastStreamMethod) + } + if ts.lastStreamHeader != "test-access-token" { + t.Fatalf("stream header token=%q", ts.lastStreamHeader) + } + + body := ts.lastStreamBody + if body["outTrackId"] != outTrackID { + t.Errorf("outTrackId=%v, want %v", body["outTrackId"], outTrackID) + } + if body["key"] != "content" { + t.Errorf("key=%v, want content", body["key"]) + } + if body["content"] != "Updated content" { + t.Errorf("content=%v, want Updated content", body["content"]) + } + if body["isFull"] != true { + t.Errorf("isFull=%v, want true", body["isFull"]) + } + if body["isFinalize"] != true { + t.Errorf("isFinalize=%v, want true", body["isFinalize"]) + } + if body["isError"] != false { + t.Errorf("isError=%v, want false", body["isError"]) + } + if body["guid"] == nil || body["guid"] == "" { + t.Error("guid is missing or empty") + } +} + +// --------------------------------------------------------------------------- +// Test: SendFinalCard calls create exactly once and stream exactly once with finalize=true +// --------------------------------------------------------------------------- + +func TestSendFinalCardCreateStreamOnce(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + outTrackID, err := sender.SendFinalCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user-1", + Content: "Hello", + }) + if err != nil { + t.Fatalf("SendFinalCard: %v", err) + } + if !isUUID(outTrackID) { + t.Fatalf("outTrackID is not a UUID: %q", outTrackID) + } + + // Must create exactly once, stream exactly once + if ts.createCalls != 1 { + t.Fatalf("createCalls=%d, want 1", ts.createCalls) + } + if ts.streamCalls != 1 { + t.Fatalf("streamCalls=%d, want 1", ts.streamCalls) + } + + // Stream must be finalize=true + if ts.lastStreamBody["isFinalize"] != true { + t.Fatalf("isFinalize=%v, want true", ts.lastStreamBody["isFinalize"]) + } + if ts.lastStreamBody["content"] != "Hello" { + t.Fatalf("content=%v, want Hello", ts.lastStreamBody["content"]) + } +} + +// --------------------------------------------------------------------------- +// Test: UpdateCard with non-final / error flags +// --------------------------------------------------------------------------- + +func TestUpdateCardNonFinalAndError(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + outTrackID, err := sender.StartCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user-1", + Content: "Processing...", + }) + if err != nil { + t.Fatalf("StartCard: %v", err) + } + + // Non-final update (streaming progress) + err = sender.UpdateCard(context.Background(), outTrackID, "Step 1 complete", false, false) + if err != nil { + t.Fatalf("UpdateCard (non-final): %v", err) + } + if ts.lastStreamBody["isFinalize"] != false { + t.Errorf("isFinalize should be false, got %v", ts.lastStreamBody["isFinalize"]) + } + if ts.lastStreamBody["isError"] != false { + t.Errorf("isError should be false, got %v", ts.lastStreamBody["isError"]) + } + + // Error update + err = sender.UpdateCard(context.Background(), outTrackID, "Something went wrong", true, true) + if err != nil { + t.Fatalf("UpdateCard (error): %v", err) + } + if ts.lastStreamBody["isFinalize"] != true { + t.Errorf("isFinalize should be true, got %v", ts.lastStreamBody["isFinalize"]) + } + if ts.lastStreamBody["isError"] != true { + t.Errorf("isError should be true, got %v", ts.lastStreamBody["isError"]) + } + if ts.lastStreamBody["content"] != "Something went wrong" { + t.Errorf("content=%v", ts.lastStreamBody["content"]) + } +} + +// --------------------------------------------------------------------------- +// Test: StartCard rejects empty content +// --------------------------------------------------------------------------- + +func TestStartCardEmptyContent(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + _, err = sender.StartCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user-1", + Content: "", + }) + if err == nil { + t.Fatal("empty content should fail") + } + if ts.tokenCalls != 0 || ts.createCalls != 0 { + t.Fatal("API should not be called when content is empty") + } +} + +// --------------------------------------------------------------------------- +// Test: UpdateCard rejects empty outTrackID +// --------------------------------------------------------------------------- + +func TestUpdateCardEmptyOutTrackID(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + err = sender.UpdateCard(context.Background(), "", "content", true, false) + if err == nil { + t.Fatal("empty outTrackID should fail") + } + if ts.tokenCalls != 0 || ts.streamCalls != 0 { + t.Fatal("API should not be called when outTrackID is empty") + } + + err = sender.UpdateCard(context.Background(), " ", "content", true, false) + if err == nil { + t.Fatal("whitespace-only outTrackID should fail") + } +} + +// --------------------------------------------------------------------------- +// Test: UpdateCard rejects empty content +// --------------------------------------------------------------------------- + +func TestUpdateCardEmptyContent(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + err = sender.UpdateCard(context.Background(), "some-id", "", true, false) + if err == nil { + t.Fatal("empty content should fail") + } + if ts.tokenCalls != 0 || ts.streamCalls != 0 { + t.Fatal("API should not be called when content is empty") + } +} + +// --------------------------------------------------------------------------- +// Test: UpdateCard rejects content over 64KiB +// --------------------------------------------------------------------------- + +func TestUpdateCardOver64KiB(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + over64KiB := strings.Repeat("x", 64*1024+1) + err = sender.UpdateCard(context.Background(), "some-id", over64KiB, true, false) + if err == nil { + t.Fatal("over 64KiB content should fail") + } + if ts.tokenCalls != 0 || ts.streamCalls != 0 { + t.Fatal("API should not be called when content exceeds 64KiB") + } +} + +// --------------------------------------------------------------------------- +// Test: UpdateCard stream non-2xx — error must not leak secret/token/content +// --------------------------------------------------------------------------- + +func TestUpdateCardStreamNon2xx(t *testing.T) { + ts := newCardTestServer() + ts.streamStatus = http.StatusInternalServerError + defer ts.Close() + + sender, err := newCardSenderForTest("my-client", "my-secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + outTrackID, err := sender.StartCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user-1", + Content: "Thinking...", + }) + if err != nil { + t.Fatalf("StartCard: %v", err) + } + + err = sender.UpdateCard(context.Background(), outTrackID, "sensitive data", true, false) + if err == nil { + t.Fatal("stream non-2xx should fail") + } + + errStr := err.Error() + for _, secret := range []string{"my-secret", "test-access-token", "sensitive data"} { + if strings.Contains(errStr, secret) { + t.Fatalf("error leaked %q: %v", secret, err) + } + } +} + +// --------------------------------------------------------------------------- +// Test: UpdateCard redirect does not leak token +// --------------------------------------------------------------------------- + +func TestUpdateCardStreamRedirectNoTokenLeak(t *testing.T) { + var leaked string + target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + leaked = r.Header.Get("x-acs-dingtalk-access-token") + w.WriteHeader(http.StatusNoContent) + })) + defer target.Close() + + // Create a server that redirects stream calls + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case "/token": + json.NewEncoder(w).Encode(map[string]any{"accessToken": "top-secret-token", "expireIn": 3600}) + case "/create": + json.NewEncoder(w).Encode(map[string]any{"result": "ok"}) + default: + http.Redirect(w, r, target.URL, http.StatusFound) + } + })) + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL+"/token", ts.URL+"/create") + if err != nil { + t.Fatal(err) + } + + outTrackID, err := sender.StartCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user-1", + Content: "Thinking...", + }) + if err != nil { + t.Fatalf("StartCard: %v", err) + } + + err = sender.UpdateCard(context.Background(), outTrackID, "content", true, false) + if err == nil { + t.Fatal("API redirect should fail") + } + if leaked != "" { + t.Fatalf("token leaked across redirect: %q", leaked) + } +} + +// --------------------------------------------------------------------------- +// Test: UpdateCard stream oversize response +// --------------------------------------------------------------------------- + +func TestUpdateCardStreamOversize(t *testing.T) { + ts := newCardTestServer() + ts.streamBodySize = maxAPIResponseBytes + 1 + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + outTrackID, err := sender.StartCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user-1", + Content: "Thinking...", + }) + if err != nil { + t.Fatalf("StartCard: %v", err) + } + + err = sender.UpdateCard(context.Background(), outTrackID, "content", true, false) + if err == nil { + t.Fatal("oversized stream response should fail") + } +} + +// --------------------------------------------------------------------------- +// Test: OAuth called only once across StartCard + multiple UpdateCard +// --------------------------------------------------------------------------- + +func TestOAuthAcrossStartAndUpdates(t *testing.T) { + ts := newCardTestServer() + defer ts.Close() + + sender, err := newCardSenderForTest("id", "secret", "tpl", ts.Client(), ts.URL()+"/token", ts.URL()+"/create") + if err != nil { + t.Fatal(err) + } + + outTrackID, err := sender.StartCard(context.Background(), CardRequest{ + ConversationType: core.ConversationDirect, + ExternalUserID: "user-1", + Content: "Processing...", + }) + if err != nil { + t.Fatalf("StartCard: %v", err) + } + + // Multiple updates + for i := 0; i < 3; i++ { + err = sender.UpdateCard(context.Background(), outTrackID, "chunk "+string(rune('0'+i)), false, false) + if err != nil { + t.Fatalf("UpdateCard %d: %v", i, err) + } + } + + // Final update + err = sender.UpdateCard(context.Background(), outTrackID, "done", true, false) + if err != nil { + t.Fatalf("UpdateCard final: %v", err) + } + + // Token should be called exactly once (cached across all calls) + if ts.tokenCalls != 1 { + t.Fatalf("tokenCalls=%d, want 1 (token should be cached)", ts.tokenCalls) + } + if ts.createCalls != 1 { + t.Fatalf("createCalls=%d, want 1", ts.createCalls) + } + if ts.streamCalls != 4 { + t.Fatalf("streamCalls=%d, want 4", ts.streamCalls) + } +} + +// --------------------------------------------------------------------------- +// Helpers +// --------------------------------------------------------------------------- + +func isUUID(s string) bool { + if len(s) != 36 { + return false + } + // UUID format: 8-4-4-4-12 + for i, c := range s { + switch i { + case 8, 13, 18, 23: + if c != '-' { + return false + } + default: + if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')) { + return false + } + } + } + return true +} diff --git a/internal/channels/dingtalk/handler.go b/internal/channels/dingtalk/handler.go index d895dfb..0e3cc1a 100644 --- a/internal/channels/dingtalk/handler.go +++ b/internal/channels/dingtalk/handler.go @@ -6,8 +6,10 @@ import ( "fmt" "log" "strings" + "time" "gitea.zheromiku.top/Weknora/dobotai-platform/internal/core" + "gitea.zheromiku.top/Weknora/dobotai-platform/internal/weknora" ) const ( @@ -21,6 +23,7 @@ const ( qaErrorReply = "抱歉,当前暂时无法完成回答,请稍后重试。" imageErrorReply = "图片识别暂时不可用,请稍后重试或发送文字。" imageQuery = "请描述并分析这张图片。" + streamingPlaceholder = "正在理解问题…" ) type TenantConfig struct { @@ -46,6 +49,18 @@ type QAAsker interface { Ask(ctx context.Context, req core.QARequest) (core.QAResult, error) } +// StreamingQAAsker asks the QA backend with streaming observer support. +type StreamingQAAsker interface { + QAAsker + AskStream(ctx context.Context, req core.QARequest, observer weknora.AnswerObserver) (core.QAResult, error) +} + +// EventQAAsker exposes safe stage metadata without thinking/tool payloads. +type EventQAAsker interface { + QAAsker + AskEvents(ctx context.Context, req core.QARequest, observer weknora.StreamObserver) (core.QAResult, error) +} + type MarkdownSender interface { SendMarkdown(ctx context.Context, webhookURL, title, text string) error } @@ -54,16 +69,52 @@ type ImageDownloader interface { Download(ctx context.Context, downloadCode string) (core.ImageInput, error) } +// FinalCardSender sends an AI card as the final reply. Implementations must +// not log err, outTrackID, or content at any level. +type FinalCardSender interface { + SendFinalCard(context.Context, CardRequest) (string, error) +} + +// StreamingCardSender supports streaming card lifecycle: start, update, and finalize. +type StreamingCardSender interface { + FinalCardSender + StartCard(ctx context.Context, req CardRequest) (string, error) + UpdateCard(ctx context.Context, id, content string, isFinalize, isError bool) error +} + +type HandlerOptions struct { + ImageDownloader ImageDownloader + CardSender FinalCardSender +} + type Handler struct { - cfg TenantConfig - qa QAAsker - reply MarkdownSender - downloader ImageDownloader + cfg TenantConfig + qa QAAsker + reply MarkdownSender + downloader ImageDownloader + card FinalCardSender + now func() time.Time + cardUpdateInterval time.Duration + finalDeliveryTimeout time.Duration } // NewHandler accepts at most one image downloader. A nil/omitted downloader // keeps text ingress available while picture messages fail closed. func NewHandler(cfg TenantConfig, qa QAAsker, reply MarkdownSender, downloaders ...ImageDownloader) (*Handler, error) { + var downloader ImageDownloader + if len(downloaders) > 1 { + return nil, errors.New("dingtalk handler: at most one image downloader is allowed") + } + if len(downloaders) == 1 { + downloader = downloaders[0] + } + return NewHandlerWithOptions(cfg, qa, reply, HandlerOptions{ImageDownloader: downloader}) +} + +// NewHandlerWithOptions creates a Handler with an optional image downloader +// and optional card sender. Passing nil for either option is equivalent to +// omitting the feature. +func NewHandlerWithOptions(cfg TenantConfig, qa QAAsker, reply MarkdownSender, opts HandlerOptions) (*Handler, error) { if strings.TrimSpace(cfg.TenantKey) == "" { return nil, errors.New("dingtalk handler: tenant key is required") } @@ -76,14 +127,16 @@ func NewHandler(cfg TenantConfig, qa QAAsker, reply MarkdownSender, downloaders if reply == nil { return nil, errors.New("dingtalk handler: markdown sender is required") } - if len(downloaders) > 1 { - return nil, errors.New("dingtalk handler: at most one image downloader is allowed") - } - var downloader ImageDownloader - if len(downloaders) == 1 { - downloader = downloaders[0] - } - return &Handler{cfg: cfg, qa: qa, reply: reply, downloader: downloader}, nil + return &Handler{ + cfg: cfg, + qa: qa, + reply: reply, + downloader: opts.ImageDownloader, + card: opts.CardSender, + now: time.Now, + cardUpdateInterval: 500 * time.Millisecond, + finalDeliveryTimeout: defaultHTTPTimeout, + }, nil } func (h *Handler) Handle(ctx context.Context, cb BotCallback) error { @@ -160,6 +213,42 @@ func (h *Handler) Handle(ctx context.Context, cb BotCallback) error { return h.sendReply(ctx, webhookURL, unsupportedMessageReply) } + if eventCard, eventQA := h.eventStreamingCapable(); eventCard != nil && eventQA != nil { + return h.handleEventStreaming(ctx, webhookURL, req, eventCard, eventQA) + } + // Backward-compatible A3.2 answer-only streaming capability. + streamingCard, streamingQA := h.streamingCapable() + if streamingCard != nil && streamingQA != nil { + return h.handleStreaming(ctx, webhookURL, req, streamingCard, streamingQA) + } + return h.handleNonStreaming(ctx, webhookURL, req) +} + +func (h *Handler) eventStreamingCapable() (StreamingCardSender, EventQAAsker) { + sc, ok := h.card.(StreamingCardSender) + if !ok { + return nil, nil + } + eq, ok := h.qa.(EventQAAsker) + if !ok { + return nil, nil + } + return sc, eq +} + +func (h *Handler) streamingCapable() (StreamingCardSender, StreamingQAAsker) { + sc, ok := h.card.(StreamingCardSender) + if !ok { + return nil, nil + } + sq, ok := h.qa.(StreamingQAAsker) + if !ok { + return nil, nil + } + return sc, sq +} + +func (h *Handler) handleNonStreaming(ctx context.Context, webhookURL string, req core.QARequest) error { result, err := h.qa.Ask(ctx, req) if err != nil { if replyErr := h.sendReply(ctx, webhookURL, qaErrorReply); replyErr != nil { @@ -167,9 +256,156 @@ func (h *Handler) Handle(ctx context.Context, cb BotCallback) error { } return nil } + + if h.card != nil { + cardReq := CardRequest{ + ConversationType: req.ConversationType, + ExternalUserID: req.ExternalUserID, + ExternalChatID: req.ExternalChatID, + Content: result.Answer, + } + if _, cardErr := h.card.SendFinalCard(ctx, cardReq); cardErr == nil { + return nil + } + log.Printf("DingTalk card delivery failed, falling back to markdown") + } return h.sendReply(ctx, webhookURL, result.Answer) } +func (h *Handler) handleStreaming(ctx context.Context, webhookURL string, req core.QARequest, streamingCard StreamingCardSender, streamingQA StreamingQAAsker) error { + cardReq := CardRequest{ + ConversationType: req.ConversationType, + ExternalUserID: req.ExternalUserID, + ExternalChatID: req.ExternalChatID, + Content: streamingPlaceholder, + } + outTrackID, err := streamingCard.StartCard(ctx, cardReq) + if err != nil { + log.Printf("DingTalk streaming card start failed, falling back to non-streaming") + // Fallback: Ask → Markdown only (no SendFinalCard, no AskStream) + result, askErr := h.qa.Ask(ctx, req) + if askErr != nil { + if replyErr := h.sendReply(ctx, webhookURL, qaErrorReply); replyErr != nil { + return replyErr + } + return nil + } + return h.sendReply(ctx, webhookURL, result.Answer) + } + + // Streaming observer with the configured update throttle (500ms by default). + var lastUpdate time.Time + observer := func(fullContent string) { + if strings.TrimSpace(fullContent) == "" { + return + } + now := h.now() + if lastUpdate.IsZero() || now.Sub(lastUpdate) >= h.cardUpdateInterval { + // Advance the throttle window before I/O so a failing DingTalk API + // cannot be hammered once per model chunk. The final update below is + // always attempted regardless of this timestamp. + lastUpdate = now + if updateErr := streamingCard.UpdateCard(ctx, outTrackID, fullContent, false, false); updateErr != nil { + log.Printf("DingTalk streaming card update failed, continuing") + } + } + } + + result, err := streamingQA.AskStream(ctx, req, observer) + if err != nil || strings.TrimSpace(result.Answer) == "" { + return h.finalizeCardOrMarkdown(ctx, webhookURL, streamingCard, outTrackID, qaErrorReply, true) + } + return h.finalizeCardOrMarkdown(ctx, webhookURL, streamingCard, outTrackID, result.Answer, false) +} + +func (h *Handler) handleEventStreaming(ctx context.Context, webhookURL string, req core.QARequest, streamingCard StreamingCardSender, eventQA EventQAAsker) error { + cardReq := CardRequest{ + ConversationType: req.ConversationType, + ExternalUserID: req.ExternalUserID, + ExternalChatID: req.ExternalChatID, + Content: streamingPlaceholder, + } + outTrackID, err := streamingCard.StartCard(ctx, cardReq) + if err != nil { + log.Printf("DingTalk event card start failed, falling back to markdown") + result, askErr := h.qa.Ask(ctx, req) + if askErr != nil { + return h.sendReply(ctx, webhookURL, qaErrorReply) + } + return h.sendReply(ctx, webhookURL, result.Answer) + } + + pump := newCardUpdatePump(ctx, h.cardUpdateInterval, func(updateCtx context.Context, content string) error { + return streamingCard.UpdateCard(updateCtx, outTrackID, content, false, false) + }) + answerStarted := false + result, err := eventQA.AskEvents(ctx, req, func(event weknora.StreamEvent) { + if event.ResponseType == "answer" && strings.TrimSpace(event.FullAnswer) != "" { + answerStarted = true + pump.Offer(event.FullAnswer) + return + } + if answerStarted { + return + } + if content := renderProgressEvent(event); content != "" { + pump.Offer(content) + } + }) + // Stop and drain the asynchronous worker before the synchronous final update + // so no stale progress/partial answer can overwrite the terminal card state. + pump.Stop() + + if err != nil || strings.TrimSpace(result.Answer) == "" { + return h.finalizeCardOrMarkdown(ctx, webhookURL, streamingCard, outTrackID, qaErrorReply, true) + } + return h.finalizeCardOrMarkdown(ctx, webhookURL, streamingCard, outTrackID, result.Answer, false) +} + +func (h *Handler) finalizeCardOrMarkdown(ctx context.Context, webhookURL string, streamingCard StreamingCardSender, outTrackID, content string, isError bool) error { + timeout := h.finalDeliveryTimeout + if timeout <= 0 { + timeout = defaultHTTPTimeout + } + + // Final card convergence must still be attempted when the QA context was + // canceled or timed out; otherwise the card can remain "processing". + finalCtx, cancelFinal := context.WithTimeout(context.WithoutCancel(ctx), timeout) + updateErr := streamingCard.UpdateCard(finalCtx, outTrackID, content, true, isError) + cancelFinal() + if updateErr == nil { + return nil + } + + // The card attempt may have consumed its entire deadline. Markdown must get + // a fresh delivery window rather than reusing the expired finalCtx. + fallbackCtx, cancelFallback := context.WithTimeout(context.WithoutCancel(ctx), timeout) + defer cancelFallback() + return h.sendReply(fallbackCtx, webhookURL, content) +} + +func renderProgressEvent(event weknora.StreamEvent) string { + switch event.ResponseType { + case "tool_call": + switch strings.TrimSpace(event.ToolName) { + case "query_understand": + return "正在理解问题…" + case "knowledge_search": + return "正在检索知识库…" + } + case "tool_result": + switch strings.TrimSpace(event.ToolName) { + case "query_understand": + return "问题理解完成\n\n正在检索知识库…" + case "knowledge_search": + return "知识库检索完成\n\n正在生成答案…" + } + case "references": + return fmt.Sprintf("检索到 %d 条相关内容\n\n正在生成答案…", event.ReferenceCount) + } + return "" +} + func imageFailureStage(err error) string { message := strings.ToLower(err.Error()) switch { diff --git a/internal/channels/dingtalk/handler_test.go b/internal/channels/dingtalk/handler_test.go index 85d795d..f14f915 100644 --- a/internal/channels/dingtalk/handler_test.go +++ b/internal/channels/dingtalk/handler_test.go @@ -5,8 +5,10 @@ import ( "errors" "strings" "testing" + "time" "gitea.zheromiku.top/Weknora/dobotai-platform/internal/core" + "gitea.zheromiku.top/Weknora/dobotai-platform/internal/weknora" ) type fakeQA struct { @@ -51,11 +53,26 @@ func (f *fakeImageDownloader) Download(_ context.Context, code string) (core.Ima return f.image, f.err } -func newTestHandler(t *testing.T, qa *fakeQA, reply *fakeReply) *Handler { +// fakeCard implements FinalCardSender for tests. It must not log err, outTrackID, +// or content. All fields are test-observable and never leak sensitive values. +type fakeCard struct { + called bool + lastReq CardRequest + returnID string + err error +} + +func (f *fakeCard) SendFinalCard(_ context.Context, req CardRequest) (string, error) { + f.called = true + f.lastReq = req + return f.returnID, f.err +} + +func newTestHandler(t *testing.T, qa QAAsker, reply *fakeReply) *Handler { return newTestHandlerWithDownloader(t, qa, reply, nil) } -func newTestHandlerWithDownloader(t *testing.T, qa *fakeQA, reply *fakeReply, downloader ImageDownloader) *Handler { +func newTestHandlerWithDownloader(t *testing.T, qa QAAsker, reply *fakeReply, downloader ImageDownloader) *Handler { t.Helper() cfg := TenantConfig{ TenantKey: "tenant-a", @@ -68,6 +85,19 @@ func newTestHandlerWithDownloader(t *testing.T, qa *fakeQA, reply *fakeReply, do return h } +func newTestHandlerWithCard(t *testing.T, qa QAAsker, reply *fakeReply, card *fakeCard) *Handler { + t.Helper() + cfg := TenantConfig{ + TenantKey: "tenant-a", + Channel: "dingtalk", + } + h, err := NewHandlerWithOptions(cfg, qa, reply, HandlerOptions{CardSender: card}) + if err != nil { + t.Fatalf("NewHandlerWithOptions: %v", err) + } + return h +} + func directTextCallback() BotCallback { return BotCallback{ ConversationType: "1", @@ -603,3 +633,1024 @@ func TestHandleReplySendFailureReturnsError(t *testing.T) { t.Fatal("expected error when reply send fails") } } + +// --- A3.1: AI card priority / markdown fallback --- + +func TestHandleCardSuccessDirectFieldsCorrectNoMarkdown(t *testing.T) { + qa := &fakeQA{result: core.QAResult{Answer: "**card answer**"}} + reply := &fakeReply{} + card := &fakeCard{returnID: "out-track-123"} + h := newTestHandlerWithCard(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + if !card.called { + t.Fatal("card.SendFinalCard was not called") + } + if card.lastReq.ConversationType != core.ConversationDirect { + t.Fatalf("card ConversationType = %q, want direct", card.lastReq.ConversationType) + } + if card.lastReq.ExternalUserID != "staff-123" { + t.Fatalf("card ExternalUserID = %q, want staff-123", card.lastReq.ExternalUserID) + } + if card.lastReq.Content != "**card answer**" { + t.Fatalf("card Content = %q, want answer", card.lastReq.Content) + } + if reply.called { + t.Fatal("SendMarkdown must not be called when card succeeds") + } +} + +func TestHandleCardSuccessGroupChatIDCorrect(t *testing.T) { + qa := &fakeQA{result: core.QAResult{Answer: "group card answer"}} + reply := &fakeReply{} + card := &fakeCard{returnID: "out-track-group"} + h := newTestHandlerWithCard(t, qa, reply, card) + + err := h.Handle(context.Background(), groupTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + if !card.called { + t.Fatal("card.SendFinalCard was not called") + } + if card.lastReq.ConversationType != core.ConversationGroup { + t.Fatalf("card ConversationType = %q, want group", card.lastReq.ConversationType) + } + if card.lastReq.ExternalChatID != "cid-group-1" { + t.Fatalf("card ExternalChatID = %q, want cid-group-1", card.lastReq.ExternalChatID) + } + if reply.called { + t.Fatal("SendMarkdown must not be called when card succeeds") + } +} + +func TestHandleCardFailureFallsBackToMarkdown(t *testing.T) { + qa := &fakeQA{result: core.QAResult{Answer: "**fallback answer**"}} + reply := &fakeReply{} + card := &fakeCard{err: errors.New("card API 500")} + h := newTestHandlerWithCard(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + if !card.called { + t.Fatal("card.SendFinalCard was not called") + } + if !reply.called { + t.Fatal("SendMarkdown must be called when card fails (fallback)") + } + if reply.lastText != "**fallback answer**" { + t.Fatalf("fallback reply text = %q, want answer", reply.lastText) + } +} + +func TestHandleQAFailureNoCardAndFriendlyMarkdown(t *testing.T) { + qa := &fakeQA{err: errors.New("internal weknora error")} + reply := &fakeReply{} + card := &fakeCard{} + h := newTestHandlerWithCard(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + if card.called { + t.Fatal("card.SendFinalCard must not be called on QA failure") + } + if !reply.called { + t.Fatal("SendMarkdown must be called on QA failure") + } + if !strings.Contains(reply.lastText, "暂时无法完成回答") { + t.Fatalf("friendly reply text = %q", reply.lastText) + } + if strings.Contains(reply.lastText, "weknora") { + t.Fatalf("reply text leaks internal error: %q", reply.lastText) + } +} + +func TestHandleNilCardNormalTextRegression(t *testing.T) { + qa := &fakeQA{result: core.QAResult{Answer: "**plain markdown**"}} + reply := &fakeReply{} + // Use NewHandler (no card) — must behave exactly as before + h := newTestHandler(t, qa, reply) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + if !reply.called { + t.Fatal("SendMarkdown must be called when no card sender") + } + if reply.lastText != "**plain markdown**" { + t.Fatalf("reply text = %q, want answer", reply.lastText) + } +} + +func TestHandleImageDownloadFailureNoCard(t *testing.T) { + qa := &fakeQA{} + reply := &fakeReply{} + card := &fakeCard{} + downloader := &fakeImageDownloader{err: errors.New("download failed")} + h := newTestHandlerWithDownloader(t, qa, reply, downloader) + // Inject card via options — test that download failure short-circuits before card + h.card = card + + data := directPictureCallback() + data.DownloadCode = "broken-code" + if err := h.Handle(context.Background(), data); err != nil { + t.Fatalf("Handle: %v", err) + } + if card.called { + t.Fatal("card.SendFinalCard must not be called on image download failure") + } + if qa.called { + t.Fatal("QA must not be called on download failure") + } + if !reply.called || reply.lastText != imageErrorReply { + t.Fatalf("friendly reply=%q, want %q", reply.lastText, imageErrorReply) + } +} + +func TestHandleNewHandlerBackwardCompat(t *testing.T) { + qa := &fakeQA{result: core.QAResult{Answer: "ok"}} + reply := &fakeReply{} + + // one downloader + h, err := NewHandler(TenantConfig{TenantKey: "t", Channel: "c"}, qa, reply, &fakeImageDownloader{}) + if err != nil { + t.Fatalf("NewHandler with one downloader: %v", err) + } + if h.downloader == nil { + t.Fatal("downloader should be set") + } + if h.card != nil { + t.Fatal("card should be nil when using NewHandler") + } + + // zero downloader + h2, err := NewHandler(TenantConfig{TenantKey: "t", Channel: "c"}, qa, reply) + if err != nil { + t.Fatalf("NewHandler with zero downloader: %v", err) + } + if h2.downloader != nil { + t.Fatal("downloader should be nil when not provided") + } + if h2.card != nil { + t.Fatal("card should be nil when using NewHandler") + } + + // two downloaders — must error + _, err = NewHandler(TenantConfig{TenantKey: "t", Channel: "c"}, qa, reply, &fakeImageDownloader{}, &fakeImageDownloader{}) + if err == nil { + t.Fatal("NewHandler with two downloaders should error") + } +} + +// --- A3.2: Streaming QA + Card integration --- + +// fakeStreamingQA implements both QAAsker and StreamingQAAsker. +// The observer is called synchronously with cumulative content during AskStream. +type fakeStreamingQA struct { + called bool + lastReq core.QARequest + result core.QAResult + err error + // streaming + streamCalled bool + chunks []string // observer receives cumulated content after each chunk + observerCaptured weknora.AnswerObserver +} + +func (f *fakeStreamingQA) Ask(_ context.Context, req core.QARequest) (core.QAResult, error) { + f.called = true + f.lastReq = req + return f.result, f.err +} + +func (f *fakeStreamingQA) AskStream(_ context.Context, req core.QARequest, observer weknora.AnswerObserver) (core.QAResult, error) { + f.streamCalled = true + f.lastReq = req + f.observerCaptured = observer + var accumulated string + for _, ch := range f.chunks { + accumulated += ch + if observer != nil { + observer(accumulated) + } + } + return f.result, f.err +} + +// fakeStreamingCard implements both FinalCardSender and StreamingCardSender. +type fakeStreamingCard struct { + // FinalCardSender + finalCalled bool + finalReq CardRequest + finalID string + finalErr error + + // StreamingCardSender + startCalled bool + startReq CardRequest + startID string + startErr error + + updates []cardUpdate + updateErr error +} + +type cardUpdate struct { + id string + content string + isFinalize bool + isError bool +} + +func (f *fakeStreamingCard) SendFinalCard(_ context.Context, req CardRequest) (string, error) { + f.finalCalled = true + f.finalReq = req + return f.finalID, f.finalErr +} + +func (f *fakeStreamingCard) StartCard(_ context.Context, req CardRequest) (string, error) { + f.startCalled = true + f.startReq = req + return f.startID, f.startErr +} + +func (f *fakeStreamingCard) UpdateCard(_ context.Context, id, content string, isFinalize, isError bool) error { + f.updates = append(f.updates, cardUpdate{id: id, content: content, isFinalize: isFinalize, isError: isError}) + return f.updateErr +} + +func newTestHandlerWithStreaming(t *testing.T, qa QAAsker, reply *fakeReply, card FinalCardSender) *Handler { + t.Helper() + cfg := TenantConfig{TenantKey: "tenant-a", Channel: "dingtalk"} + h, err := NewHandlerWithOptions(cfg, qa, reply, HandlerOptions{CardSender: card}) + if err != nil { + t.Fatalf("NewHandlerWithOptions: %v", err) + } + return h +} + +func TestHandleStreamingHappyPathDirect(t *testing.T) { + card := &fakeStreamingCard{startID: "track-happy-1"} + qa := &fakeStreamingQA{ + chunks: []string{"Hello", " World", "!"}, + result: core.QAResult{Answer: "Hello World!"}, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + // StartCard called once with placeholder + if !card.startCalled { + t.Fatal("StartCard was not called") + } + if card.startReq.Content != streamingPlaceholder { + t.Fatalf("StartCard Content = %q, want %q", card.startReq.Content, streamingPlaceholder) + } + if card.startReq.ConversationType != core.ConversationDirect { + t.Fatalf("StartCard ConversationType = %q, want direct", card.startReq.ConversationType) + } + if card.startReq.ExternalUserID != "staff-123" { + t.Fatalf("StartCard ExternalUserID = %q, want staff-123", card.startReq.ExternalUserID) + } + + // AskStream called, not Ask + if !qa.streamCalled { + t.Fatal("AskStream was not called") + } + + // First non-empty chunk → immediate update (not finalize) + if len(card.updates) < 1 { + t.Fatal("expected at least one update") + } + first := card.updates[0] + if first.id != "track-happy-1" { + t.Fatalf("first update id = %q, want track-happy-1", first.id) + } + if first.content != "Hello" { + t.Fatalf("first update content = %q, want Hello", first.content) + } + if first.isFinalize || first.isError { + t.Fatal("first update should not be finalize or error") + } + + // Final update must be the last one: content=full answer, isFinalize=true, isError=false + last := card.updates[len(card.updates)-1] + if last.content != "Hello World!" { + t.Fatalf("final update content = %q, want full answer", last.content) + } + if !last.isFinalize { + t.Fatal("final update must be finalize") + } + if last.isError { + t.Fatal("final update must not be error") + } + + // No markdown fallback + if reply.called { + t.Fatal("SendMarkdown must not be called on streaming success") + } +} + +func TestHandleStreamingThrottleSecondUpdate(t *testing.T) { + card := &fakeStreamingCard{startID: "track-throttle"} + qa := &fakeStreamingQA{ + chunks: []string{"A", "B", "C"}, + result: core.QAResult{Answer: "ABC"}, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + // Simulate clock advancing past interval + base := int64(0) + h.now = func() time.Time { return time.Unix(0, base) } + h.cardUpdateInterval = time.Millisecond + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + // All updates happen in the same goroutine, so the clock never advances + // during the single observer call chain. The first chunk fires immediately, + // subsequent chunks are throttled (clock hasn't advanced). + // The final update always fires. + if len(card.updates) < 2 { + t.Fatalf("expected at least first + final update, got %d", len(card.updates)) + } + // First update is immediate + if card.updates[0].isFinalize || card.updates[0].isError { + t.Fatal("first update must not be finalize/error") + } + // Last update is final + last := card.updates[len(card.updates)-1] + if !last.isFinalize || last.isError { + t.Fatal("last update must be finalize, not error") + } + if last.content != "ABC" { + t.Fatalf("final content = %q, want ABC", last.content) + } + if reply.called { + t.Fatal("SendMarkdown must not be called") + } +} + +func TestHandleStreamingThrottleClockAdvances(t *testing.T) { + card := &fakeStreamingCard{startID: "track-adv"} + qa := &fakeStreamingQA{ + chunks: []string{"X", "Y", "Z"}, + result: core.QAResult{Answer: "XYZ"}, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + callCount := int64(0) + h.now = func() time.Time { + c := callCount + callCount++ + // Each call advances by 800ms to cross the 750ms interval + return time.Unix(0, c*800_000_000) + } + h.cardUpdateInterval = 750 * time.Millisecond + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + // First chunk fires immediately (1 update), then each subsequent observer call + // sees clock advanced past interval → fires another update. + // So we should see: first("X"), second("XY"), final("XYZ") + nonFinal := 0 + for _, u := range card.updates { + if !u.isFinalize && !u.isError { + nonFinal++ + } + } + if nonFinal < 2 { + t.Fatalf("expected at least 2 intermediate updates with clock advance, got %d (updates=%+v)", nonFinal, card.updates) + } + last := card.updates[len(card.updates)-1] + if !last.isFinalize || last.isError { + t.Fatal("last update must be finalize") + } + if last.content != "XYZ" { + t.Fatalf("final content = %q, want XYZ", last.content) + } + if reply.called { + t.Fatal("SendMarkdown must not be called") + } +} + +func TestHandleStreamingStartFailsFallbackAskMarkdown(t *testing.T) { + card := &fakeStreamingCard{startErr: errors.New("card API unavailable")} + qa := &fakeStreamingQA{ + result: core.QAResult{Answer: "**fallback markdown**"}, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + // StartCard was attempted + if !card.startCalled { + t.Fatal("StartCard was not called") + } + + // Fallback: Ask (not AskStream) was called + if !qa.called { + t.Fatal("Ask (fallback) was not called") + } + if qa.streamCalled { + t.Fatal("AskStream must not be called on Start failure") + } + + // No SendFinalCard + if card.finalCalled { + t.Fatal("SendFinalCard must not be called on Start failure") + } + + // Markdown fallback + if !reply.called { + t.Fatal("SendMarkdown must be called on Start failure") + } + if reply.lastText != "**fallback markdown**" { + t.Fatalf("markdown text = %q, want fallback markdown", reply.lastText) + } + + // No card updates + if len(card.updates) > 0 { + t.Fatal("no card updates expected on Start failure") + } +} + +func TestHandleStreamingIntermediateUpdateFailsContinuesQA(t *testing.T) { + card := &fakeStreamingCard{startID: "track-midfail", updateErr: errors.New("update HTTP 500")} + qa := &fakeStreamingQA{ + chunks: []string{"Hello", " World"}, + result: core.QAResult{Answer: "Hello World"}, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + // QA still completed (AskStream must have been called and returned) + if !qa.streamCalled { + t.Fatal("AskStream must be called") + } + + // There must be a final update attempt (even though intermediate failed) + foundFinal := false + for _, u := range card.updates { + if u.isFinalize && !u.isError { + foundFinal = true + } + } + if !foundFinal { + t.Fatal("final update must be attempted even after intermediate failures") + } + + // Since updateErr is set, the final update also fails → markdown fallback + if !reply.called { + t.Fatal("SendMarkdown must be called when final update fails") + } + if reply.lastText != "Hello World" { + t.Fatalf("markdown text = %q, want full answer", reply.lastText) + } +} + +func TestHandleStreamingFinalUpdateFailsMarkdown(t *testing.T) { + card := &fakeStreamingCard{startID: "track-finalfail"} + qa := &fakeStreamingQA{ + chunks: []string{"OK"}, + result: core.QAResult{Answer: "OK"}, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + // Make only the final update fail by using a counter in updateErr + updateCount := 0 + card.updateErr = nil // will be set per-call via a wrapper + // We'll use a different approach: make the final call fail by checking content + // Actually, simplest: set updateErr to an error, and the test checks markdown fallback + card.updateErr = errors.New("finalize API error") + _ = updateCount + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + if !qa.streamCalled { + t.Fatal("AskStream must be called") + } + + // Markdown fallback with full answer + if !reply.called { + t.Fatal("SendMarkdown must be called when final update fails") + } + if reply.lastText != "OK" { + t.Fatalf("markdown text = %q, want OK", reply.lastText) + } +} + +func TestHandleStreamingQAErrorConvergesErrorCard(t *testing.T) { + card := &fakeStreamingCard{startID: "track-errcard"} + qa := &fakeStreamingQA{ + chunks: []string{"Partial"}, + err: errors.New("secret weknora internal failure"), + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + if !qa.streamCalled { + t.Fatal("AskStream must be called") + } + + // Last update must be error card: isFinalize=true, isError=true, content=qaErrorReply + last := card.updates[len(card.updates)-1] + if !last.isFinalize { + t.Fatal("error card must be finalize") + } + if !last.isError { + t.Fatal("error card must be isError") + } + if last.content != qaErrorReply { + t.Fatalf("error card content = %q, want %q", last.content, qaErrorReply) + } + // Must not leak QA error + if strings.Contains(last.content, "weknora") || strings.Contains(last.content, "secret") { + t.Fatalf("error card leaks internal error: %q", last.content) + } + + // No markdown (error card succeeded) + if reply.called { + t.Fatal("SendMarkdown must not be called when error card succeeds") + } + + // QA error was not leaked in any update content + for _, u := range card.updates { + if strings.Contains(u.content, "weknora") || strings.Contains(u.content, "secret") { + t.Fatalf("update leaks internal error: %q", u.content) + } + } +} + +func TestHandleStreamingErrorCardFinalizeFailsMarkdown(t *testing.T) { + card := &fakeStreamingCard{startID: "track-errfinalfail", updateErr: errors.New("finalize API error")} + qa := &fakeStreamingQA{ + chunks: []string{"Partial"}, + err: errors.New("secret weknora internal failure"), + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + // Markdown fallback with friendly error message + if !reply.called { + t.Fatal("SendMarkdown must be called when error card finalize fails") + } + if reply.lastText != qaErrorReply { + t.Fatalf("markdown text = %q, want %q", reply.lastText, qaErrorReply) + } + // Must not leak QA error + if strings.Contains(reply.lastText, "weknora") || strings.Contains(reply.lastText, "secret") { + t.Fatalf("markdown leaks internal error: %q", reply.lastText) + } +} + +func TestHandleOldFakeCardStillA31(t *testing.T) { + // fakeCard does NOT implement StreamingCardSender — must use A3.1 path + card := &fakeCard{returnID: "out-a31"} + qa := &fakeStreamingQA{ + result: core.QAResult{Answer: "**a31 answer**"}, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + // A3.1: Ask (not AskStream) + SendFinalCard + if !qa.called { + t.Fatal("Ask must be called (A3.1 path)") + } + if qa.streamCalled { + t.Fatal("AskStream must not be called (A3.1 path)") + } + if !card.called { + t.Fatal("SendFinalCard must be called (A3.1 path)") + } + if card.lastReq.Content != "**a31 answer**" { + t.Fatalf("card content = %q, want a31 answer", card.lastReq.Content) + } + if reply.called { + t.Fatal("SendMarkdown must not be called when card succeeds") + } +} + +func TestHandleStreamingGroupNotAtNoStart(t *testing.T) { + card := &fakeStreamingCard{startID: "track-group"} + qa := &fakeStreamingQA{} + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + data := groupTextCallback() + data.IsInAtList = false + err := h.Handle(context.Background(), data) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + if card.startCalled { + t.Fatal("StartCard must not be called for non-@ group message") + } + if qa.called || qa.streamCalled { + t.Fatal("QA must not be called for non-@ group message") + } + if reply.called { + t.Fatal("SendMarkdown must not be called for non-@ group message") + } +} + +func TestHandleStreamingImageDownloadFailureNoStart(t *testing.T) { + card := &fakeStreamingCard{startID: "track-img"} + qa := &fakeStreamingQA{} + reply := &fakeReply{} + downloader := &fakeImageDownloader{err: errors.New("download failed")} + h := newTestHandlerWithDownloader(t, qa, reply, downloader) + h.card = card + + data := directPictureCallback() + data.DownloadCode = "broken-code" + if err := h.Handle(context.Background(), data); err != nil { + t.Fatalf("Handle: %v", err) + } + + if card.startCalled { + t.Fatal("StartCard must not be called on image download failure") + } + if qa.called || qa.streamCalled { + t.Fatal("QA must not be called on download failure") + } + if !reply.called || reply.lastText != imageErrorReply { + t.Fatalf("friendly reply=%q, want %q", reply.lastText, imageErrorReply) + } +} + +func TestHandleStreamingQAEmptyAnswerConvergesErrorCard(t *testing.T) { + card := &fakeStreamingCard{startID: "track-empty"} + qa := &fakeStreamingQA{ + chunks: []string{}, + result: core.QAResult{Answer: ""}, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + if !qa.streamCalled { + t.Fatal("AskStream must be called") + } + + // Empty answer: error card with qaErrorReply + last := card.updates[len(card.updates)-1] + if !last.isFinalize || !last.isError { + t.Fatal("empty answer must produce error card") + } + if last.content != qaErrorReply { + t.Fatalf("error card content = %q, want %q", last.content, qaErrorReply) + } + if reply.called { + t.Fatal("SendMarkdown must not be called when error card succeeds") + } +} + +func TestHandleStreamingObserverIgnoresWhitespaceOnly(t *testing.T) { + card := &fakeStreamingCard{startID: "track-ws"} + qa := &fakeStreamingQA{ + // The observer is called with cumulative content; whitespace-only + // chunks should not trigger updates. + chunks: []string{" ", " \n ", "Real"}, + result: core.QAResult{Answer: " \n Real"}, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + // First non-whitespace update is "Real" (cumulated) + firstUpdate := card.updates[0] + if firstUpdate.content != " \n Real" { + t.Fatalf("first update content = %q, want cumulative whitespace plus Real", firstUpdate.content) + } + if firstUpdate.isFinalize || firstUpdate.isError { + t.Fatal("first update must not be finalize/error") + } + + last := card.updates[len(card.updates)-1] + if !last.isFinalize || last.isError { + t.Fatal("last update must be finalize, not error") + } + if reply.called { + t.Fatal("SendMarkdown must not be called") + } +} + +func TestHandleStreamingStartFailsQAFailsMarkdownFriendly(t *testing.T) { + // Start fails → fallback to Ask → Ask also fails → friendly markdown + card := &fakeStreamingCard{startErr: errors.New("card API unavailable")} + qa := &fakeStreamingQA{ + err: errors.New("secret weknora internal failure"), + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + if !card.startCalled { + t.Fatal("StartCard was not called") + } + if !qa.called { + t.Fatal("Ask (fallback) was not called") + } + if qa.streamCalled { + t.Fatal("AskStream must not be called") + } + if !reply.called { + t.Fatal("SendMarkdown must be called") + } + if !strings.Contains(reply.lastText, "暂时无法完成回答") { + t.Fatalf("friendly markdown = %q", reply.lastText) + } + if strings.Contains(reply.lastText, "weknora") || strings.Contains(reply.lastText, "secret") { + t.Fatalf("markdown leaks internal error: %q", reply.lastText) + } +} + +func TestHandleStreamingFinalUpdateAlwaysFiresEvenWithoutIntermediate(t *testing.T) { + // No intermediate chunks (observer never called with non-empty content), + // but final update must still fire with the answer. + card := &fakeStreamingCard{startID: "track-noint"} + qa := &fakeStreamingQA{ + chunks: []string{}, // no intermediate chunks + result: core.QAResult{Answer: "direct answer"}, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + err := h.Handle(context.Background(), directTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + if !qa.streamCalled { + t.Fatal("AskStream must be called") + } + + // Must have exactly one update: final + if len(card.updates) != 1 { + t.Fatalf("expected 1 update (final only), got %d: %+v", len(card.updates), card.updates) + } + u := card.updates[0] + if !u.isFinalize || u.isError { + t.Fatal("only update must be finalize, not error") + } + if u.content != "direct answer" { + t.Fatalf("content = %q, want direct answer", u.content) + } + if reply.called { + t.Fatal("SendMarkdown must not be called") + } +} + +func TestHandleStreamingGroupWithCard(t *testing.T) { + card := &fakeStreamingCard{startID: "track-group-ok"} + qa := &fakeStreamingQA{ + chunks: []string{"group", " reply"}, + result: core.QAResult{Answer: "group reply"}, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + + err := h.Handle(context.Background(), groupTextCallback()) + if err != nil { + t.Fatalf("Handle: %v", err) + } + + if !card.startCalled { + t.Fatal("StartCard was not called") + } + if card.startReq.ConversationType != core.ConversationGroup { + t.Fatalf("StartCard ConversationType = %q, want group", card.startReq.ConversationType) + } + if card.startReq.ExternalChatID != "cid-group-1" { + t.Fatalf("StartCard ExternalChatID = %q, want cid-group-1", card.startReq.ExternalChatID) + } + if !qa.streamCalled { + t.Fatal("AskStream was not called") + } + last := card.updates[len(card.updates)-1] + if !last.isFinalize || last.isError { + t.Fatal("last update must be finalize, not error") + } + if last.content != "group reply" { + t.Fatalf("final content = %q, want group reply", last.content) + } + if reply.called { + t.Fatal("SendMarkdown must not be called") + } +} + +// --- A3.3: safe progress events + asynchronous card coalescing --- + +type fakeEventQA struct { + fakeStreamingQA + events []weknora.StreamEvent + eventCalled bool +} + +func (f *fakeEventQA) AskEvents(_ context.Context, req core.QARequest, observer weknora.StreamObserver) (core.QAResult, error) { + f.eventCalled = true + f.lastReq = req + for _, event := range f.events { + if observer != nil { + observer(event) + } + } + return f.result, f.err +} + +func TestRenderProgressEventUsesOnlySafeFixedText(t *testing.T) { + tests := []struct { + name string + event weknora.StreamEvent + want string + }{ + {"understanding", weknora.StreamEvent{ResponseType: "tool_call", ToolName: "query_understand"}, "正在理解问题…"}, + {"understood", weknora.StreamEvent{ResponseType: "tool_result", ToolName: "query_understand"}, "问题理解完成\n\n正在检索知识库…"}, + {"searching", weknora.StreamEvent{ResponseType: "tool_call", ToolName: "knowledge_search"}, "正在检索知识库…"}, + {"searched", weknora.StreamEvent{ResponseType: "tool_result", ToolName: "knowledge_search"}, "知识库检索完成\n\n正在生成答案…"}, + {"references", weknora.StreamEvent{ResponseType: "references", ReferenceCount: 7}, "检索到 7 条相关内容\n\n正在生成答案…"}, + {"thinking hidden", weknora.StreamEvent{ResponseType: "thinking"}, ""}, + {"unknown tool hidden", weknora.StreamEvent{ResponseType: "tool_call", ToolName: "secret_tool"}, ""}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := renderProgressEvent(tt.event); got != tt.want { + t.Fatalf("renderProgressEvent=%q want %q", got, tt.want) + } + }) + } +} + +func TestHandleEventStreamingFinalizesLatestAnswerWithoutMarkdown(t *testing.T) { + card := &fakeStreamingCard{startID: "track-events"} + qa := &fakeEventQA{ + fakeStreamingQA: fakeStreamingQA{result: core.QAResult{Answer: "完整答案"}}, + events: []weknora.StreamEvent{ + {ResponseType: "tool_call", ToolName: "query_understand"}, + {ResponseType: "tool_call", ToolName: "knowledge_search"}, + {ResponseType: "references", ReferenceCount: 3}, + {ResponseType: "answer", FullAnswer: "部分"}, + {ResponseType: "answer", FullAnswer: "完整答案", Done: true}, + }, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + h.cardUpdateInterval = time.Hour + if err := h.Handle(context.Background(), directTextCallback()); err != nil { + t.Fatalf("Handle: %v", err) + } + if !qa.eventCalled || qa.streamCalled { + t.Fatalf("eventCalled=%v streamCalled=%v", qa.eventCalled, qa.streamCalled) + } + if card.startReq.Content != streamingPlaceholder { + t.Fatalf("placeholder=%q", card.startReq.Content) + } + if len(card.updates) != 1 { + t.Fatalf("stale async updates must be dropped before final: %+v", card.updates) + } + last := card.updates[0] + if last.content != "完整答案" || !last.isFinalize || last.isError { + t.Fatalf("final update=%+v", last) + } + if reply.called { + t.Fatal("SendMarkdown must not be called") + } +} + +func TestHandleEventStreamingErrorConvergesCard(t *testing.T) { + card := &fakeStreamingCard{startID: "track-event-error"} + qa := &fakeEventQA{ + fakeStreamingQA: fakeStreamingQA{err: errors.New("private upstream failure")}, + events: []weknora.StreamEvent{{ResponseType: "tool_call", ToolName: "knowledge_search"}, {ResponseType: "error", Done: true}}, + } + reply := &fakeReply{} + h := newTestHandlerWithStreaming(t, qa, reply, card) + h.cardUpdateInterval = time.Hour + if err := h.Handle(context.Background(), directTextCallback()); err != nil { + t.Fatalf("Handle: %v", err) + } + last := card.updates[len(card.updates)-1] + if last.content != qaErrorReply || !last.isFinalize || !last.isError { + t.Fatalf("error final=%+v", last) + } + if strings.Contains(last.content, "private") || reply.called { + t.Fatalf("error leaked or markdown duplicated: content=%q markdown=%v", last.content, reply.called) + } +} + +type deadlineFinalCard struct{} + +func (deadlineFinalCard) SendFinalCard(context.Context, CardRequest) (string, error) { + return "track-deadline", nil +} + +func (deadlineFinalCard) StartCard(context.Context, CardRequest) (string, error) { + return "track-deadline", nil +} + +func (deadlineFinalCard) UpdateCard(ctx context.Context, _ string, _ string, isFinalize, _ bool) error { + if !isFinalize { + return nil + } + <-ctx.Done() + return ctx.Err() +} + +type contextCheckingReply struct { + called bool + contextErr error +} + +func (r *contextCheckingReply) SendMarkdown(ctx context.Context, _, _, _ string) error { + r.called = true + r.contextErr = ctx.Err() + return r.contextErr +} + +func TestHandleEventStreamingFinalTimeoutUsesFreshMarkdownContext(t *testing.T) { + qa := &fakeEventQA{ + fakeStreamingQA: fakeStreamingQA{result: core.QAResult{Answer: "完整答案"}}, + events: []weknora.StreamEvent{{ResponseType: "answer", FullAnswer: "完整答案", Done: true}}, + } + reply := &contextCheckingReply{} + h, err := NewHandlerWithOptions( + TenantConfig{TenantKey: "tenant-a", Channel: "dingtalk"}, + qa, + reply, + HandlerOptions{CardSender: deadlineFinalCard{}}, + ) + if err != nil { + t.Fatalf("NewHandlerWithOptions: %v", err) + } + h.cardUpdateInterval = time.Hour + h.finalDeliveryTimeout = 5 * time.Millisecond + + if err := h.Handle(context.Background(), directTextCallback()); err != nil { + t.Fatalf("Markdown fallback must receive a fresh context: %v", err) + } + if !reply.called { + t.Fatal("Markdown fallback was not called") + } + if reply.contextErr != nil { + t.Fatalf("Markdown fallback received expired context: %v", reply.contextErr) + } +} diff --git a/internal/qa/ask_events_test.go b/internal/qa/ask_events_test.go new file mode 100644 index 0000000..04cdf6b --- /dev/null +++ b/internal/qa/ask_events_test.go @@ -0,0 +1,254 @@ +package qa + +import ( + "context" + "errors" + "testing" + + "gitea.zheromiku.top/Weknora/dobotai-platform/internal/core" + "gitea.zheromiku.top/Weknora/dobotai-platform/internal/session" + "gitea.zheromiku.top/Weknora/dobotai-platform/internal/weknora" +) + +type fakeEventStreamingWeKnora struct { + *fakeWeKnora + events []weknora.StreamEvent + streamResult weknora.ChatResult + streamErr error + streamCalls int +} + +func (f *fakeEventStreamingWeKnora) AgentChatEvents(_ context.Context, _ string, request weknora.AgentChatRequest, observer weknora.StreamObserver) (weknora.ChatResult, error) { + f.streamCalls++ + f.mu.Lock() + f.queries = append(f.queries, request.Query) + f.requests = append(f.requests, request) + f.mu.Unlock() + for _, e := range f.events { + if observer != nil { + observer(e) + } + } + return f.streamResult, f.streamErr +} + +func TestAskEventsStreamFakeSequencePassesThroughAndSuccess(t *testing.T) { + repo := newMemoryRepository() + client := &fakeEventStreamingWeKnora{ + fakeWeKnora: &fakeWeKnora{}, + events: []weknora.StreamEvent{ + {ResponseType: "thinking"}, + {ResponseType: "tool_call", ToolName: "query_understand"}, + {ResponseType: "tool_result", ToolName: "query_understand"}, + {ResponseType: "tool_call", ToolName: "knowledge_search"}, + {ResponseType: "references", ReferenceCount: 3}, + {ResponseType: "answer", FullAnswer: "hello ", Done: false}, + {ResponseType: "answer", FullAnswer: "hello world", Done: true}, + }, + streamResult: weknora.ChatResult{RequestID: "request-1", Answer: "hello world", References: []core.Reference{{KnowledgeID: "kb-1"}}}, + } + service, err := New(repo, fixedResolver{}, client, session.GroupShared) + if err != nil { + t.Fatal(err) + } + var observed []weknora.StreamEvent + req := streamQARequest("message-events") + result, err := service.AskEvents(context.Background(), req, func(e weknora.StreamEvent) { + observed = append(observed, e) + }) + if err != nil { + t.Fatalf("AskEvents: %v", err) + } + if result.Replayed { + t.Fatal("should not be replay") + } + if result.Answer != "hello world" { + t.Fatalf("expected 'hello world', got %q", result.Answer) + } + if client.streamCalls != 1 { + t.Fatalf("expected 1 stream call, got %d", client.streamCalls) + } + if len(observed) != 7 { + t.Fatalf("expected 7 events, got %d: %+v", len(observed), observed) + } + // Verify sequence + expectedTypes := []string{"thinking", "tool_call", "tool_result", "tool_call", "references", "answer", "answer"} + for i, want := range expectedTypes { + if observed[i].ResponseType != want { + t.Fatalf("event[%d] ResponseType: want %q, got %q", i, want, observed[i].ResponseType) + } + } + // Verify turn persisted + repo.mu.Lock() + stored := repo.turns["tenant:dingtalk:message-events"] + repo.mu.Unlock() + if stored.Status != "succeeded" || stored.Answer != "hello world" { + t.Fatalf("stored=%+v", stored) + } +} + +func TestAskEventsEventStreamErrorTurnFailed(t *testing.T) { + repo := newMemoryRepository() + client := &fakeEventStreamingWeKnora{ + fakeWeKnora: &fakeWeKnora{}, + events: []weknora.StreamEvent{ + {ResponseType: "answer", FullAnswer: "partial"}, + {ResponseType: "error", Done: true}, + }, + streamErr: errors.New("stream failed"), + } + service, err := New(repo, fixedResolver{}, client, session.GroupShared) + if err != nil { + t.Fatal(err) + } + var observed []weknora.StreamEvent + _, err = service.AskEvents(context.Background(), streamQARequest("message-events-error"), func(e weknora.StreamEvent) { + observed = append(observed, e) + }) + if err == nil { + t.Fatal("expected error") + } + if len(observed) != 2 { + t.Fatalf("expected 2 events before error, got %d: %+v", len(observed), observed) + } + // Turn must be failed + repo.mu.Lock() + stored := repo.turns["tenant:dingtalk:message-events-error"] + repo.mu.Unlock() + if stored.Status != "failed" || stored.Answer != "" { + t.Fatalf("expected failed turn without answer, got %+v", stored) + } +} + +func TestAskEventsLegacyFallbackSingleAnswerEvent(t *testing.T) { + repo := newMemoryRepository() + // fakeWeKnora only implements AgentChat (no AgentChatStream, no AgentChatEvents) + client := &fakeWeKnora{} + service, err := New(repo, fixedResolver{}, client, session.GroupShared) + if err != nil { + t.Fatal(err) + } + var observed []weknora.StreamEvent + req := streamQARequest("message-legacy-events") + result, err := service.AskEvents(context.Background(), req, func(e weknora.StreamEvent) { + observed = append(observed, e) + }) + if err != nil { + t.Fatalf("AskEvents legacy: %v", err) + } + if result.Answer != "answer" { + t.Fatalf("expected 'answer', got %q", result.Answer) + } + // Legacy fallback: single final answer event + if len(observed) != 1 { + t.Fatalf("expected 1 legacy event, got %d: %+v", len(observed), observed) + } + if observed[0].ResponseType != "answer" || observed[0].FullAnswer != "answer" || !observed[0].Done { + t.Fatalf("legacy event should be answer done: %+v", observed[0]) + } +} + +func TestAskEventsDuplicateReplayZeroEvents(t *testing.T) { + repo := newMemoryRepository() + client := &fakeEventStreamingWeKnora{ + fakeWeKnora: &fakeWeKnora{}, + events: []weknora.StreamEvent{ + {ResponseType: "answer", FullAnswer: "answer", Done: true}, + }, + streamResult: weknora.ChatResult{RequestID: "request-1", Answer: "answer"}, + } + service, err := New(repo, fixedResolver{}, client, session.GroupShared) + if err != nil { + t.Fatal(err) + } + req := streamQARequest("message-events-replay") + // First call + firstEvents := 0 + if _, err := service.AskEvents(context.Background(), req, func(weknora.StreamEvent) { firstEvents++ }); err != nil { + t.Fatalf("first AskEvents: %v", err) + } + // Second call — replay + secondEvents := 0 + result, err := service.AskEvents(context.Background(), req, func(weknora.StreamEvent) { secondEvents++ }) + if err != nil { + t.Fatalf("replay AskEvents: %v", err) + } + if !result.Replayed { + t.Fatal("expected replay") + } + if secondEvents != 0 { + t.Fatalf("replay must not notify events, got %d", secondEvents) + } + if firstEvents != 1 { + t.Fatalf("first call expected 1 event, got %d", firstEvents) + } + if client.streamCalls != 1 { + t.Fatalf("expected 1 weknora call, got %d", client.streamCalls) + } +} + +func TestAskEventsStreamingFallbackFromAgentChatStream(t *testing.T) { + repo := newMemoryRepository() + // Client has AgentChatStream but not AgentChatEvents + client := &fakeStreamingWeKnora{ + fakeWeKnora: &fakeWeKnora{}, + updates: []string{"hello ", "hello world"}, + streamResult: weknora.ChatResult{RequestID: "request-1", Answer: "hello world", References: []core.Reference{{KnowledgeID: "kb-1"}}}, + } + service, err := New(repo, fixedResolver{}, client, session.GroupShared) + if err != nil { + t.Fatal(err) + } + var observed []weknora.StreamEvent + req := streamQARequest("message-stream-fallback") + result, err := service.AskEvents(context.Background(), req, func(e weknora.StreamEvent) { + observed = append(observed, e) + }) + if err != nil { + t.Fatalf("AskEvents stream fallback: %v", err) + } + if result.Answer != "hello world" { + t.Fatalf("expected 'hello world', got %q", result.Answer) + } + // Each answer observer callback becomes a StreamEvent with FullAnswer + if len(observed) != 2 { + t.Fatalf("expected 2 events from stream fallback, got %d: %+v", len(observed), observed) + } + if observed[0].ResponseType != "answer" || observed[0].FullAnswer != "hello " || observed[0].Done { + t.Fatalf("event[0]: %+v", observed[0]) + } + if observed[1].ResponseType != "answer" || observed[1].FullAnswer != "hello world" || observed[1].Done { + t.Fatalf("event[1]: %+v", observed[1]) + } + // Turn persisted + repo.mu.Lock() + stored := repo.turns["tenant:dingtalk:message-stream-fallback"] + repo.mu.Unlock() + if stored.Status != "succeeded" || stored.Answer != "hello world" { + t.Fatalf("stored=%+v", stored) + } +} + +// TestAskStreamOldRegression verifies the old AskStream still works after refactoring. +func TestAskStreamOldRegression(t *testing.T) { + repo := newMemoryRepository() + client := &fakeStreamingWeKnora{ + fakeWeKnora: &fakeWeKnora{}, updates: []string{"hello ", "hello world"}, + streamResult: weknora.ChatResult{RequestID: "request-stream", Answer: "hello world", References: []core.Reference{{KnowledgeID: "kb-1"}}}, + } + service, err := New(repo, fixedResolver{}, client, session.GroupShared) + if err != nil { + t.Fatal(err) + } + var observed []string + result, err := service.AskStream(context.Background(), streamQARequest("message-stream-regression"), func(full string) { observed = append(observed, full) }) + if err != nil { + t.Fatalf("AskStream: %v", err) + } + if len(observed) != 2 || observed[0] != "hello " || observed[1] != "hello world" { + t.Fatalf("observed=%v", observed) + } + if result.Answer != "hello world" || result.WeKnoraRequestID != "request-stream" || client.streamCalls != 1 { + t.Fatalf("result=%+v streamCalls=%d", result, client.streamCalls) + } +} diff --git a/internal/qa/service.go b/internal/qa/service.go index fd61fd8..706b18f 100644 --- a/internal/qa/service.go +++ b/internal/qa/service.go @@ -22,6 +22,14 @@ type WeKnora interface { AgentChat(ctx context.Context, sessionID string, request weknora.AgentChatRequest) (weknora.ChatResult, error) } +type streamingWeKnora interface { + AgentChatStream(ctx context.Context, sessionID string, request weknora.AgentChatRequest, observer weknora.AnswerObserver) (weknora.ChatResult, error) +} + +type eventStreamingWeKnora interface { + AgentChatEvents(ctx context.Context, sessionID string, request weknora.AgentChatRequest, observer weknora.StreamObserver) (weknora.ChatResult, error) +} + type Service struct { repository core.Repository agents AgentResolver @@ -40,6 +48,18 @@ func New(repository core.Repository, agents AgentResolver, client WeKnora, group } func (s *Service) Ask(ctx context.Context, request core.QARequest) (core.QAResult, error) { + return s.ask(ctx, request, nil, nil) +} + +func (s *Service) AskStream(ctx context.Context, request core.QARequest, observer weknora.AnswerObserver) (core.QAResult, error) { + return s.ask(ctx, request, observer, nil) +} + +func (s *Service) AskEvents(ctx context.Context, request core.QARequest, observer weknora.StreamObserver) (core.QAResult, error) { + return s.ask(ctx, request, nil, observer) +} + +func (s *Service) ask(ctx context.Context, request core.QARequest, answerObserver weknora.AnswerObserver, eventObserver weknora.StreamObserver) (core.QAResult, error) { if err := validateRequest(request); err != nil { return core.QAResult{}, err } @@ -102,10 +122,54 @@ func (s *Service) Ask(ctx context.Context, request core.QARequest) (core.QAResul for _, image := range request.Images { images = append(images, weknora.Image{Data: image.DataURI}) } - chat, err := s.weknora.AgentChat(ctx, sessionID, weknora.AgentChatRequest{ + chatRequest := weknora.AgentChatRequest{ Query: query, AgentID: agentID, AgentEnabled: true, Channel: "im", EnableMemory: true, Images: images, - }) + } + var chat weknora.ChatResult + if eventObserver != nil { + // Prefer AgentChatEvents; fallback to AgentChatStream adaptation; then AgentChat. + if eventStream, ok := s.weknora.(eventStreamingWeKnora); ok { + chat, err = eventStream.AgentChatEvents(ctx, sessionID, chatRequest, eventObserver) + } else if streaming, ok := s.weknora.(streamingWeKnora); ok { + // Adapt AgentChatStream answer chunks to StreamEvent + chat, err = streaming.AgentChatStream(ctx, sessionID, chatRequest, func(full string) { + if answerObserver != nil { + answerObserver(full) + } + eventObserver(weknora.StreamEvent{ + ResponseType: "answer", + FullAnswer: full, + }) + }) + } else { + chat, err = s.weknora.AgentChat(ctx, sessionID, chatRequest) + if err == nil && strings.TrimSpace(chat.Answer) != "" { + if answerObserver != nil { + answerObserver(chat.Answer) + } + eventObserver(weknora.StreamEvent{ + ResponseType: "answer", + FullAnswer: chat.Answer, + Done: true, + }) + } + } + } else if answerObserver != nil { + if streaming, ok := s.weknora.(streamingWeKnora); ok { + chat, err = streaming.AgentChatStream(ctx, sessionID, chatRequest, answerObserver) + } else { + chat, err = s.weknora.AgentChat(ctx, sessionID, chatRequest) + if err == nil && strings.TrimSpace(chat.Answer) != "" { + answerObserver(chat.Answer) + } + } + } else { + chat, err = s.weknora.AgentChat(ctx, sessionID, chatRequest) + } + if err == nil && strings.TrimSpace(chat.Answer) == "" { + err = weknora.ErrEmptyAnswer + } if err != nil { turn.Status, turn.ErrorMessage = "failed", err.Error() _ = s.repository.FinishTurn(ctx, turn) diff --git a/internal/qa/service_test.go b/internal/qa/service_test.go index b4c162d..e53ff79 100644 --- a/internal/qa/service_test.go +++ b/internal/qa/service_test.go @@ -2,6 +2,7 @@ package qa import ( "context" + "errors" "sync" "testing" @@ -80,6 +81,28 @@ func (f *fakeWeKnora) AgentChat(_ context.Context, sessionID string, request wek return weknora.ChatResult{RequestID: "request-1", Answer: "answer", References: []core.Reference{{KnowledgeID: "kb-1"}}}, nil } +type fakeStreamingWeKnora struct { + *fakeWeKnora + updates []string + streamResult weknora.ChatResult + streamErr error + streamCalls int +} + +func (f *fakeStreamingWeKnora) AgentChatStream(_ context.Context, _ string, request weknora.AgentChatRequest, observer weknora.AnswerObserver) (weknora.ChatResult, error) { + f.streamCalls++ + f.mu.Lock() + f.queries = append(f.queries, request.Query) + f.requests = append(f.requests, request) + f.mu.Unlock() + for _, update := range f.updates { + if observer != nil { + observer(update) + } + } + return f.streamResult, f.streamErr +} + func TestAskUsesSharedGroupSessionAndReplaysDuplicate(t *testing.T) { repo := newMemoryRepository() client := &fakeWeKnora{} @@ -238,3 +261,103 @@ func TestAskDuplicateReplayDoesNotCallWeKnoraAgain(t *testing.T) { t.Fatalf("replay must preserve Turn.Media: %+v", stored.Media) } } + +func streamQARequest(messageID string) core.QARequest { + return core.QARequest{ + TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationDirect, + ExternalUserID: "user-1", ExternalMessageID: messageID, Query: "question", + } +} + +func TestAskStreamUsesStreamingObserverAndPersistsFinal(t *testing.T) { + repo := newMemoryRepository() + client := &fakeStreamingWeKnora{ + fakeWeKnora: &fakeWeKnora{}, updates: []string{"hello ", "hello world"}, + streamResult: weknora.ChatResult{RequestID: "request-stream", Answer: "hello world", References: []core.Reference{{KnowledgeID: "kb-1"}}}, + } + service, err := New(repo, fixedResolver{}, client, session.GroupShared) + if err != nil { + t.Fatal(err) + } + var observed []string + result, err := service.AskStream(context.Background(), streamQARequest("message-stream"), func(full string) { observed = append(observed, full) }) + if err != nil { + t.Fatalf("AskStream: %v", err) + } + if len(observed) != 2 || observed[0] != "hello " || observed[1] != "hello world" { + t.Fatalf("observed=%v", observed) + } + if result.Answer != "hello world" || result.WeKnoraRequestID != "request-stream" || client.streamCalls != 1 { + t.Fatalf("result=%+v streamCalls=%d", result, client.streamCalls) + } + repo.mu.Lock() + stored := repo.turns["tenant:dingtalk:message-stream"] + repo.mu.Unlock() + if stored.Status != "succeeded" || stored.Answer != "hello world" { + t.Fatalf("stored=%+v", stored) + } +} + +func TestAskStreamFailurePersistsFailedWithoutPartialAnswer(t *testing.T) { + repo := newMemoryRepository() + client := &fakeStreamingWeKnora{fakeWeKnora: &fakeWeKnora{}, updates: []string{"partial"}, streamErr: errors.New("stream failed")} + service, err := New(repo, fixedResolver{}, client, session.GroupShared) + if err != nil { + t.Fatal(err) + } + var observed []string + _, err = service.AskStream(context.Background(), streamQARequest("message-stream-error"), func(full string) { observed = append(observed, full) }) + if err == nil { + t.Fatal("expected stream error") + } + if len(observed) != 1 || observed[0] != "partial" { + t.Fatalf("observed=%v", observed) + } + repo.mu.Lock() + stored := repo.turns["tenant:dingtalk:message-stream-error"] + repo.mu.Unlock() + if stored.Status != "failed" || stored.Answer != "" { + t.Fatalf("partial answer must not be persisted as success: %+v", stored) + } +} + +func TestAskStreamFallsBackToFinalObserverForLegacyClient(t *testing.T) { + repo := newMemoryRepository() + client := &fakeWeKnora{} + service, err := New(repo, fixedResolver{}, client, session.GroupShared) + if err != nil { + t.Fatal(err) + } + var observed []string + result, err := service.AskStream(context.Background(), streamQARequest("message-legacy"), func(full string) { observed = append(observed, full) }) + if err != nil { + t.Fatalf("AskStream: %v", err) + } + if result.Answer != "answer" || len(observed) != 1 || observed[0] != "answer" { + t.Fatalf("result=%+v observed=%v", result, observed) + } +} + +func TestAskStreamDuplicateReplayDoesNotNotifyAgain(t *testing.T) { + repo := newMemoryRepository() + client := &fakeStreamingWeKnora{ + fakeWeKnora: &fakeWeKnora{}, updates: []string{"answer"}, + streamResult: weknora.ChatResult{RequestID: "request-stream", Answer: "answer"}, + } + service, err := New(repo, fixedResolver{}, client, session.GroupShared) + if err != nil { + t.Fatal(err) + } + req := streamQARequest("message-stream-replay") + if _, err = service.AskStream(context.Background(), req, func(string) {}); err != nil { + t.Fatalf("first AskStream: %v", err) + } + secondCalls := 0 + result, err := service.AskStream(context.Background(), req, func(string) { secondCalls++ }) + if err != nil { + t.Fatalf("replay AskStream: %v", err) + } + if !result.Replayed || secondCalls != 0 || client.streamCalls != 1 { + t.Fatalf("result=%+v secondCalls=%d streamCalls=%d", result, secondCalls, client.streamCalls) + } +} diff --git a/internal/weknora/client.go b/internal/weknora/client.go index 975bc24..6173a1b 100644 --- a/internal/weknora/client.go +++ b/internal/weknora/client.go @@ -17,6 +17,25 @@ import ( ) var ErrIncompleteStream = errors.New("weknora stream ended without a terminal event") +var ErrEmptyAnswer = errors.New("weknora stream completed with an empty answer") + +// AnswerObserver is called with the accumulated full answer content after each +// answer chunk. The observer is purely a notification; its return is ignored. +type AnswerObserver func(fullContent string) + +// StreamEvent is a safe, structured representation of a WeKnora streaming event. +// It deliberately does not expose raw Content, Data, or Reference content to +// prevent leaking internal thinking/tool details to external channels. +type StreamEvent struct { + ResponseType string + Done bool + FullAnswer string + ReferenceCount int + ToolName string +} + +// StreamObserver is called with a safe StreamEvent for each SSE event. +type StreamObserver func(StreamEvent) type Client struct { baseURL string @@ -78,6 +97,18 @@ func (c *Client) CreateSession(ctx context.Context, title, description string) ( } func (c *Client) AgentChat(ctx context.Context, sessionID string, request AgentChatRequest) (ChatResult, error) { + return c.AgentChatStream(ctx, sessionID, request, nil) +} + +func (c *Client) AgentChatStream(ctx context.Context, sessionID string, request AgentChatRequest, observer AnswerObserver) (ChatResult, error) { + return c.agentChat(ctx, sessionID, request, observer, nil) +} + +func (c *Client) AgentChatEvents(ctx context.Context, sessionID string, request AgentChatRequest, observer StreamObserver) (ChatResult, error) { + return c.agentChat(ctx, sessionID, request, nil, observer) +} + +func (c *Client) agentChat(ctx context.Context, sessionID string, request AgentChatRequest, answerObserver AnswerObserver, eventObserver StreamObserver) (ChatResult, error) { if strings.TrimSpace(sessionID) == "" || strings.TrimSpace(request.AgentID) == "" || strings.TrimSpace(request.Query) == "" { return ChatResult{}, errors.New("session id, agent id and query are required") } @@ -102,7 +133,7 @@ func (c *Client) AgentChat(ctx context.Context, sessionID string, request AgentC message, _ := io.ReadAll(io.LimitReader(resp.Body, 32<<10)) return ChatResult{}, fmt.Errorf("weknora agent chat returned HTTP %d: %s", resp.StatusCode, strings.TrimSpace(string(message))) } - return parseSSE(resp.Body) + return parseSSEWithEventObserver(resp.Body, answerObserver, eventObserver) } func (c *Client) doJSON(ctx context.Context, method, path string, input, output any) error { @@ -132,12 +163,26 @@ func (c *Client) doJSON(ctx context.Context, method, path string, input, output } func parseSSE(reader io.Reader) (ChatResult, error) { + return parseSSEWithEventObserver(reader, nil, nil) +} + +func parseSSEWithObserver(reader io.Reader, observer AnswerObserver) (ChatResult, error) { + return parseSSEWithEventObserver(reader, observer, nil) +} + +func parseSSEWithEventObserver(reader io.Reader, answerObserver AnswerObserver, eventObserver StreamObserver) (ChatResult, error) { scanner := bufio.NewScanner(reader) scanner.Buffer(make([]byte, 64<<10), 2<<20) var result ChatResult var dataLines []string terminal := false + notify := func(e StreamEvent) { + if eventObserver != nil { + eventObserver(e) + } + } + flush := func() error { if len(dataLines) == 0 { return nil @@ -150,6 +195,7 @@ func parseSSE(reader io.Reader) (ChatResult, error) { Content string `json:"content"` Done bool `json:"done"` KnowledgeReferences []core.Reference `json:"knowledge_references"` + Data json.RawMessage `json:"data"` } if err := json.Unmarshal([]byte(raw), &event); err != nil { return fmt.Errorf("decode weknora SSE event: %w", err) @@ -160,8 +206,21 @@ func parseSSE(reader io.Reader) (ChatResult, error) { switch event.ResponseType { case "references": result.References = append([]core.Reference(nil), event.KnowledgeReferences...) + notify(StreamEvent{ + ResponseType: "references", + ReferenceCount: len(event.KnowledgeReferences), + }) case "answer": + hasContent := strings.TrimSpace(event.Content) != "" result.Answer += event.Content + if hasContent && answerObserver != nil { + answerObserver(result.Answer) + } + notify(StreamEvent{ + ResponseType: "answer", + Done: event.Done, + FullAnswer: result.Answer, + }) if event.Done { terminal = true } @@ -169,11 +228,37 @@ func parseSSE(reader io.Reader) (ChatResult, error) { if event.Content == "" { event.Content = "weknora returned an unspecified error" } + // Notify with error type but no content, then return the error + notify(StreamEvent{ + ResponseType: "error", + Done: true, + }) return errors.New(event.Content) + case "thinking", "reflection": + notify(StreamEvent{ + ResponseType: event.ResponseType, + Done: event.Done, + }) + case "tool_call", "tool_result": + toolName := extractToolName(event.Data) + notify(StreamEvent{ + ResponseType: event.ResponseType, + Done: event.Done, + ToolName: toolName, + }) case "complete": if event.Done { terminal = true } + notify(StreamEvent{ + ResponseType: "complete", + Done: event.Done, + }) + default: + notify(StreamEvent{ + ResponseType: event.ResponseType, + Done: event.Done, + }) } return nil } @@ -199,5 +284,30 @@ func parseSSE(reader io.Reader) (ChatResult, error) { if !terminal { return ChatResult{}, ErrIncompleteStream } + if strings.TrimSpace(result.Answer) == "" { + return ChatResult{}, ErrEmptyAnswer + } return result, nil } + +// extractToolName extracts the tool_name string from a JSON Data field. +// The Data may be any JSON shape; we look for the "tool_name" key and return +// its string value. Returns empty string if not found or not a string. +func extractToolName(data json.RawMessage) string { + if len(data) == 0 { + return "" + } + var m map[string]json.RawMessage + if err := json.Unmarshal(data, &m); err != nil { + return "" + } + v, ok := m["tool_name"] + if !ok { + return "" + } + var s string + if err := json.Unmarshal(v, &s); err != nil { + return "" + } + return s +} diff --git a/internal/weknora/client_test.go b/internal/weknora/client_test.go index 07c32ee..234fd9b 100644 --- a/internal/weknora/client_test.go +++ b/internal/weknora/client_test.go @@ -84,6 +84,140 @@ func TestAgentChatRequestJSONSerializesImages(t *testing.T) { } } +func TestParseSSEWithObserverAnswerChunks(t *testing.T) { + stream := "data: {\"response_type\":\"answer\",\"content\":\"hello \",\"done\":false}\n\n" + + "data: {\"response_type\":\"answer\",\"content\":\"world\",\"done\":true}\n\n" + var observed []string + result, err := parseSSEWithObserver(strings.NewReader(stream), func(full string) { + observed = append(observed, full) + }) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if result.Answer != "hello world" { + t.Fatalf("expected 'hello world', got %q", result.Answer) + } + if len(observed) != 2 || observed[0] != "hello " || observed[1] != "hello world" { + t.Fatalf("unexpected observed: %v", observed) + } +} + +func TestParseSSEWithObserverReferencesDoesNotTrigger(t *testing.T) { + stream := "data: {\"response_type\":\"references\",\"knowledge_references\":[{\"knowledge_id\":\"kb-1\",\"content\":\"ref\"}]}\n\n" + + "data: {\"response_type\":\"answer\",\"content\":\"x\",\"done\":true}\n\n" + var observed []string + _, err := parseSSEWithObserver(strings.NewReader(stream), func(full string) { + observed = append(observed, full) + }) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if len(observed) != 1 || observed[0] != "x" { + t.Fatalf("references should not trigger observer, got %v", observed) + } +} + +func TestParseSSEWithObserverDoneEmptyChunk(t *testing.T) { + // done=true but content empty — should mark terminal but not trigger observer + stream := "data: {\"response_type\":\"answer\",\"content\":\"hello\",\"done\":false}\n\n" + + "data: {\"response_type\":\"answer\",\"content\":\"\",\"done\":true}\n\n" + var observed []string + result, err := parseSSEWithObserver(strings.NewReader(stream), func(full string) { + observed = append(observed, full) + }) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if result.Answer != "hello" { + t.Fatalf("expected 'hello', got %q", result.Answer) + } + if len(observed) != 1 || observed[0] != "hello" { + t.Fatalf("done empty chunk should not trigger observer, got %v", observed) + } +} + +func TestParseSSEWithObserverTerminalEmptyAnswer(t *testing.T) { + stream := "data: {\"response_type\":\"answer\",\"content\":\"\",\"done\":true}\n\n" + var observed []string + _, err := parseSSEWithObserver(strings.NewReader(stream), func(full string) { + observed = append(observed, full) + }) + if !errors.Is(err, ErrEmptyAnswer) { + t.Fatalf("expected ErrEmptyAnswer, got %v", err) + } + if len(observed) != 0 { + t.Fatalf("empty answer should not trigger observer, got %v", observed) + } +} + +func TestParseSSEWithObserverErrorDominatesPartial(t *testing.T) { + stream := "data: {\"response_type\":\"answer\",\"content\":\"partial\",\"done\":false}\n\n" + + "data: {\"response_type\":\"error\",\"content\":\"boom\",\"done\":true}\n\n" + var observed []string + _, err := parseSSEWithObserver(strings.NewReader(stream), func(full string) { + observed = append(observed, full) + }) + if err == nil || !strings.Contains(err.Error(), "boom") { + t.Fatalf("expected error containing 'boom', got %v", err) + } + // observer should have been called once with "partial" before the error + if len(observed) != 1 || observed[0] != "partial" { + t.Fatalf("expected observer called with 'partial', got %v", observed) + } +} + +func TestAgentChatStreamCallsObserver(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("/api/v1/agent-chat/session-1", func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/event-stream") + _, _ = w.Write([]byte("data: {\"response_type\":\"answer\",\"content\":\"hello \",\"done\":false}\n\n")) + _, _ = w.Write([]byte("data: {\"response_type\":\"answer\",\"content\":\"world\",\"done\":true}\n\n")) + }) + server := httptest.NewServer(mux) + defer server.Close() + + client, err := NewClient(server.URL, "test-key", 5*time.Second) + if err != nil { + t.Fatalf("NewClient: %v", err) + } + var observed []string + result, err := client.AgentChatStream(context.Background(), "session-1", + AgentChatRequest{Query: "q", AgentID: "agent-1", Channel: "im"}, + func(full string) { observed = append(observed, full) }) + if err != nil { + t.Fatalf("AgentChatStream: %v", err) + } + if result.Answer != "hello world" { + t.Fatalf("expected 'hello world', got %q", result.Answer) + } + if len(observed) != 2 || observed[0] != "hello " || observed[1] != "hello world" { + t.Fatalf("unexpected observed: %v", observed) + } +} + +func TestAgentChatStreamNilObserver(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("/api/v1/agent-chat/session-1", func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/event-stream") + _, _ = w.Write([]byte("data: {\"response_type\":\"answer\",\"content\":\"hello\",\"done\":true}\n\n")) + }) + server := httptest.NewServer(mux) + defer server.Close() + + client, err := NewClient(server.URL, "test-key", 5*time.Second) + if err != nil { + t.Fatalf("NewClient: %v", err) + } + result, err := client.AgentChatStream(context.Background(), "session-1", + AgentChatRequest{Query: "q", AgentID: "agent-1", Channel: "im"}, nil) + if err != nil { + t.Fatalf("AgentChatStream with nil observer: %v", err) + } + if result.Answer != "hello" { + t.Fatalf("expected 'hello', got %q", result.Answer) + } +} + func TestAgentChatRequestJSONOmitsEmptyImages(t *testing.T) { req := AgentChatRequest{ Query: "hello", diff --git a/internal/weknora/stream_event_test.go b/internal/weknora/stream_event_test.go new file mode 100644 index 0000000..331805a --- /dev/null +++ b/internal/weknora/stream_event_test.go @@ -0,0 +1,269 @@ +package weknora + +import ( + "context" + "errors" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" +) + +// TestStreamEventSequence verifies the full event sequence: +// thinking → tool_call(query_understand) → tool_result → tool_call(knowledge_search) → +// references(count=3) → answer cumulative → answer done. +// It also asserts that no thinking/tool content leaks into StreamEvent (type has no Content field). +func TestStreamEventSequence(t *testing.T) { + stream := "data: {\"response_type\":\"thinking\",\"content\":\"inner monologue\",\"done\":false}\n\n" + + "data: {\"response_type\":\"tool_call\",\"data\":{\"tool_name\":\"query_understand\",\"arguments\":{\"query\":\"test\"}},\"done\":false}\n\n" + + "data: {\"response_type\":\"tool_result\",\"data\":{\"tool_name\":\"query_understand\",\"result\":\"understood\"},\"done\":false}\n\n" + + "data: {\"response_type\":\"tool_call\",\"data\":{\"tool_name\":\"knowledge_search\",\"arguments\":{\"query\":\"test\"}},\"done\":false}\n\n" + + "data: {\"response_type\":\"references\",\"knowledge_references\":[{\"knowledge_id\":\"kb-1\",\"content\":\"ref1\"},{\"knowledge_id\":\"kb-2\",\"content\":\"ref2\"},{\"knowledge_id\":\"kb-3\",\"content\":\"ref3\"}]}\n\n" + + "data: {\"response_type\":\"answer\",\"content\":\"hello \",\"done\":false}\n\n" + + "data: {\"response_type\":\"answer\",\"content\":\"world\",\"done\":true}\n\n" + + var events []StreamEvent + result, err := parseSSEWithEventObserver(strings.NewReader(stream), nil, func(e StreamEvent) { + events = append(events, e) + }) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if result.Answer != "hello world" { + t.Fatalf("expected 'hello world', got %q", result.Answer) + } + if len(result.References) != 3 { + t.Fatalf("expected 3 references, got %d", len(result.References)) + } + + // Expected sequence: thinking, tool_call(query_understand), tool_result, tool_call(knowledge_search), references, answer(hello ), answer(hello world) + expectedTypes := []string{"thinking", "tool_call", "tool_result", "tool_call", "references", "answer", "answer"} + if len(events) != len(expectedTypes) { + t.Fatalf("expected %d events, got %d: %+v", len(expectedTypes), len(events), events) + } + for i, want := range expectedTypes { + if events[i].ResponseType != want { + t.Fatalf("event[%d] ResponseType: want %q, got %q", i, want, events[i].ResponseType) + } + } + + // thinking: must not carry Content + if events[0].ToolName != "" || events[0].FullAnswer != "" || events[0].ReferenceCount != 0 { + t.Fatalf("thinking event must not leak content: %+v", events[0]) + } + + // tool_call(query_understand): ToolName must be "query_understand" + if events[1].ToolName != "query_understand" { + t.Fatalf("tool_call expected ToolName 'query_understand', got %q", events[1].ToolName) + } + if events[1].FullAnswer != "" || events[1].ReferenceCount != 0 { + t.Fatalf("tool_call must not leak other fields: %+v", events[1]) + } + + // tool_result: ToolName must be "query_understand" + if events[2].ToolName != "query_understand" { + t.Fatalf("tool_result expected ToolName 'query_understand', got %q", events[2].ToolName) + } + + // tool_call(knowledge_search): ToolName must be "knowledge_search" + if events[3].ToolName != "knowledge_search" { + t.Fatalf("tool_call expected ToolName 'knowledge_search', got %q", events[3].ToolName) + } + + // references: ReferenceCount must be 3 + if events[4].ReferenceCount != 3 { + t.Fatalf("references expected ReferenceCount=3, got %d", events[4].ReferenceCount) + } + + // answer(hello): Done=false, FullAnswer="hello " + if events[5].FullAnswer != "hello " || events[5].Done { + t.Fatalf("answer chunk 1: expected FullAnswer='hello ' Done=false, got %+v", events[5]) + } + + // answer(hello world): Done=true, FullAnswer="hello world" + if events[6].FullAnswer != "hello world" || !events[6].Done { + t.Fatalf("answer chunk 2: expected FullAnswer='hello world' Done=true, got %+v", events[6]) + } + + // Verify no event has any raw content field (StreamEvent struct has no Content/Data field) + // This is a compile-time guarantee — if StreamEvent had Content, we'd have a compilation error. + // Runtime: ensure events don't leak thinking content or tool Data content. + for i, e := range events { + if e.ResponseType == "thinking" && e.FullAnswer != "" { + t.Fatalf("event[%d]: thinking must not leak content", i) + } + } +} + +// TestStreamEventErrorDoesNotLeakContent verifies error events notify but do not expose error content. +func TestStreamEventErrorDoesNotLeakContent(t *testing.T) { + stream := "data: {\"response_type\":\"answer\",\"content\":\"partial\",\"done\":false}\n\n" + + "data: {\"response_type\":\"error\",\"content\":\"secret internal error details\",\"done\":true}\n\n" + + var events []StreamEvent + _, err := parseSSEWithEventObserver(strings.NewReader(stream), nil, func(e StreamEvent) { + events = append(events, e) + }) + if err == nil { + t.Fatal("expected error from error event") + } + // The error event notification should have been sent before the error returned. + // It should only have ResponseType="error" and Done=true, no Content. + if len(events) < 2 { + t.Fatalf("expected at least 2 events (answer + error notification), got %d: %+v", len(events), events) + } + last := events[len(events)-1] + if last.ResponseType != "error" { + t.Fatalf("expected last event to be error, got %+v", last) + } + if !last.Done { + t.Fatal("error event should have Done=true") + } + // Error content must NOT leak into the event + if last.FullAnswer != "" || last.ToolName != "" || last.ReferenceCount != 0 { + t.Fatalf("error event must not leak content: %+v", last) + } +} + +// TestStreamEventAnswerObserverRegression verifies the old AnswerObserver still works correctly. +func TestStreamEventAnswerObserverRegression(t *testing.T) { + stream := "data: {\"response_type\":\"answer\",\"content\":\"hello \",\"done\":false}\n\n" + + "data: {\"response_type\":\"answer\",\"content\":\"world\",\"done\":true}\n\n" + + var observed []string + result, err := parseSSEWithEventObserver(strings.NewReader(stream), func(full string) { + observed = append(observed, full) + }, nil) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if result.Answer != "hello world" { + t.Fatalf("expected 'hello world', got %q", result.Answer) + } + if len(observed) != 2 || observed[0] != "hello " || observed[1] != "hello world" { + t.Fatalf("unexpected observed: %v", observed) + } +} + +// TestStreamEventAnswerObserverDoneEmptyChunk verifies done empty chunk +// notifies StreamEvent but does NOT trigger old AnswerObserver. +func TestStreamEventAnswerObserverDoneEmptyChunk(t *testing.T) { + stream := "data: {\"response_type\":\"answer\",\"content\":\"hello\",\"done\":false}\n\n" + + "data: {\"response_type\":\"answer\",\"content\":\"\",\"done\":true}\n\n" + + var observed []string + var events []StreamEvent + result, err := parseSSEWithEventObserver(strings.NewReader(stream), func(full string) { + observed = append(observed, full) + }, func(e StreamEvent) { + events = append(events, e) + }) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if result.Answer != "hello" { + t.Fatalf("expected 'hello', got %q", result.Answer) + } + // Old AnswerObserver: only called for non-empty content chunks + if len(observed) != 1 || observed[0] != "hello" { + t.Fatalf("old observer should only see non-empty chunks, got %v", observed) + } + // StreamEvent: should include the done empty chunk (FullAnswer is accumulated) + if len(events) < 2 { + t.Fatalf("expected at least 2 stream events, got %d: %+v", len(events), events) + } + last := events[len(events)-1] + if !last.Done || last.FullAnswer != "hello" { + t.Fatalf("last event should have Done=true FullAnswer='hello', got %+v", last) + } +} + +// TestAgentChatEventsRunner verifies the AgentChatEvents HTTP method reuses HTTP logic. +func TestAgentChatEventsRunner(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("/api/v1/agent-chat/session-1", func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/event-stream") + _, _ = w.Write([]byte("data: {\"response_type\":\"thinking\",\"content\":\"think\",\"done\":false}\n\n")) + _, _ = w.Write([]byte("data: {\"response_type\":\"tool_call\",\"data\":{\"tool_name\":\"knowledge_search\"},\"done\":false}\n\n")) + _, _ = w.Write([]byte("data: {\"response_type\":\"references\",\"knowledge_references\":[{\"knowledge_id\":\"kb-1\",\"content\":\"ref\"}]}\n\n")) + _, _ = w.Write([]byte("data: {\"response_type\":\"answer\",\"content\":\"hello\",\"done\":true}\n\n")) + }) + server := httptest.NewServer(mux) + defer server.Close() + + client, err := NewClient(server.URL, "test-key", 5*time.Second) + if err != nil { + t.Fatalf("NewClient: %v", err) + } + var events []StreamEvent + result, err := client.AgentChatEvents(context.Background(), "session-1", + AgentChatRequest{Query: "q", AgentID: "agent-1", Channel: "im"}, + func(e StreamEvent) { events = append(events, e) }) + if err != nil { + t.Fatalf("AgentChatEvents: %v", err) + } + if result.Answer != "hello" { + t.Fatalf("expected 'hello', got %q", result.Answer) + } + if len(events) != 4 { + t.Fatalf("expected 4 events, got %d: %+v", len(events), events) + } +} + +// TestAgentChatEventsNilObserver verifies nil observer is safe. +func TestAgentChatEventsNilObserver(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("/api/v1/agent-chat/session-1", func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/event-stream") + _, _ = w.Write([]byte("data: {\"response_type\":\"answer\",\"content\":\"ok\",\"done\":true}\n\n")) + }) + server := httptest.NewServer(mux) + defer server.Close() + + client, err := NewClient(server.URL, "test-key", 5*time.Second) + if err != nil { + t.Fatalf("NewClient: %v", err) + } + result, err := client.AgentChatEvents(context.Background(), "session-1", + AgentChatRequest{Query: "q", AgentID: "agent-1", Channel: "im"}, nil) + if err != nil { + t.Fatalf("AgentChatEvents with nil observer: %v", err) + } + if result.Answer != "ok" { + t.Fatalf("expected 'ok', got %q", result.Answer) + } +} + +// TestAgentChatEventsErrorTurn verifies error event returns error but notifies first. +func TestAgentChatEventsErrorTurn(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("/api/v1/agent-chat/session-1", func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/event-stream") + _, _ = w.Write([]byte("data: {\"response_type\":\"error\",\"content\":\"boom\",\"done\":true}\n\n")) + }) + server := httptest.NewServer(mux) + defer server.Close() + + client, err := NewClient(server.URL, "test-key", 5*time.Second) + if err != nil { + t.Fatalf("NewClient: %v", err) + } + var events []StreamEvent + _, err = client.AgentChatEvents(context.Background(), "session-1", + AgentChatRequest{Query: "q", AgentID: "agent-1", Channel: "im"}, + func(e StreamEvent) { events = append(events, e) }) + if err == nil { + t.Fatal("expected error") + } + if !errors.Is(err, errors.New("boom")) && !strings.Contains(err.Error(), "boom") { + t.Fatalf("expected error containing 'boom', got %v", err) + } + // error event should have notified with type="error", done=true, no content + if len(events) != 1 { + t.Fatalf("expected 1 error notification event, got %d: %+v", len(events), events) + } + if events[0].ResponseType != "error" || !events[0].Done { + t.Fatalf("expected error done event, got %+v", events[0]) + } +}