827 lines
28 KiB
Go
827 lines
28 KiB
Go
package dingtalk
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"strings"
|
|
"time"
|
|
|
|
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/core"
|
|
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/directory"
|
|
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/reasoningmode"
|
|
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/weknora"
|
|
)
|
|
|
|
const (
|
|
msgTypeText = "text"
|
|
msgTypePicture = "picture"
|
|
conversationTypeDirect = "1"
|
|
conversationTypeGroup = "2"
|
|
replyTitle = "DobotAI"
|
|
|
|
unsupportedMessageReply = "当前版本暂仅支持文字消息。"
|
|
qaErrorReply = "抱歉,当前暂时无法完成回答,请稍后重试。"
|
|
imageErrorReply = "图片识别暂时不可用,请稍后重试或发送文字。"
|
|
imageQuery = "请描述并分析这张图片。"
|
|
streamingPlaceholder = "正在理解问题…"
|
|
)
|
|
|
|
type TenantConfig struct {
|
|
TenantKey string
|
|
Channel string
|
|
}
|
|
|
|
type BotCallback struct {
|
|
ConversationType string
|
|
ConversationID string
|
|
ConversationTitle string
|
|
Msgtype string
|
|
MsgID string
|
|
SenderNick string
|
|
SenderStaffID string
|
|
SenderID string
|
|
IsInAtList bool
|
|
SessionWebhook string
|
|
Text string
|
|
DownloadCode string
|
|
DownloadCodes []string
|
|
}
|
|
|
|
type QAAsker interface {
|
|
Ask(ctx context.Context, req core.QARequest) (core.QAResult, error)
|
|
}
|
|
|
|
type DeliveryRecorder interface {
|
|
RecordDelivery(ctx context.Context, update core.DeliveryUpdate) 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
|
|
}
|
|
|
|
type ImageDownloader interface {
|
|
Download(ctx context.Context, downloadCode string) (core.ImageInput, error)
|
|
}
|
|
|
|
// ImagePublisher publishes a downloaded image to object storage and returns a
|
|
// stable HTTPS URL. Implementation satisfies outboundimage.Publisher.
|
|
type ImagePublisher interface {
|
|
Publish(ctx context.Context, data []byte, contentType string) (string, error)
|
|
}
|
|
|
|
type UserDirectory interface {
|
|
ResolveUser(ctx context.Context, tenantKey, staffID, fallbackName string) (directory.Profile, error)
|
|
}
|
|
|
|
type OutboundContentRewriter interface {
|
|
Rewrite(ctx context.Context, content string) string
|
|
}
|
|
|
|
type OutboundPartialSanitizer interface {
|
|
SanitizePartial(content string) string
|
|
}
|
|
|
|
type SettingsMessage struct {
|
|
TenantKey string
|
|
Channel string
|
|
StaffID string
|
|
UnionID string
|
|
DisplayName string
|
|
Department string
|
|
Text string
|
|
ConversationType string
|
|
ConversationID string
|
|
ConversationTitle string
|
|
}
|
|
|
|
type SettingsRouter interface {
|
|
Handle(context.Context, SettingsMessage) (handled bool, reply string, err error)
|
|
}
|
|
|
|
type ReasoningMessage struct {
|
|
TenantKey string
|
|
Channel string
|
|
StaffID string
|
|
Text string
|
|
ConversationID string
|
|
}
|
|
|
|
type ReasoningDecision struct {
|
|
Handled bool
|
|
Reply string
|
|
Query string
|
|
AgentID string
|
|
Execution reasoningmode.ExecutionMode
|
|
Expired bool
|
|
}
|
|
|
|
type ReasoningRouter interface {
|
|
Prepare(context.Context, ReasoningMessage) (ReasoningDecision, error)
|
|
}
|
|
|
|
type LanguagePreferenceResolver interface {
|
|
GetPreference(context.Context, string, string, string) (string, 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
|
|
ImagePublisher ImagePublisher
|
|
CardSender FinalCardSender
|
|
Directory UserDirectory
|
|
OutboundRewriter OutboundContentRewriter
|
|
SettingsRouter SettingsRouter
|
|
ReasoningRouter ReasoningRouter
|
|
LanguageResolver LanguagePreferenceResolver
|
|
}
|
|
|
|
type Handler struct {
|
|
cfg TenantConfig
|
|
qa QAAsker
|
|
reply MarkdownSender
|
|
downloader ImageDownloader
|
|
imagePublisher ImagePublisher
|
|
card FinalCardSender
|
|
directory UserDirectory
|
|
outboundRewriter OutboundContentRewriter
|
|
settingsRouter SettingsRouter
|
|
reasoningRouter ReasoningRouter
|
|
languageResolver LanguagePreferenceResolver
|
|
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")
|
|
}
|
|
if strings.TrimSpace(cfg.Channel) == "" {
|
|
return nil, errors.New("dingtalk handler: channel is required")
|
|
}
|
|
if qa == nil {
|
|
return nil, errors.New("dingtalk handler: QA asker is required")
|
|
}
|
|
if reply == nil {
|
|
return nil, errors.New("dingtalk handler: markdown sender is required")
|
|
}
|
|
return &Handler{
|
|
cfg: cfg,
|
|
qa: qa,
|
|
reply: reply,
|
|
downloader: opts.ImageDownloader,
|
|
imagePublisher: opts.ImagePublisher,
|
|
card: opts.CardSender,
|
|
directory: opts.Directory,
|
|
outboundRewriter: opts.OutboundRewriter,
|
|
settingsRouter: opts.SettingsRouter,
|
|
reasoningRouter: opts.ReasoningRouter,
|
|
languageResolver: opts.LanguageResolver,
|
|
now: time.Now,
|
|
cardUpdateInterval: 500 * time.Millisecond,
|
|
finalDeliveryTimeout: defaultHTTPTimeout,
|
|
}, nil
|
|
}
|
|
|
|
func (h *Handler) Handle(ctx context.Context, cb BotCallback) error {
|
|
// Admission comes first: a group message without @ must have zero side effects.
|
|
if cb.ConversationType == conversationTypeGroup && !cb.IsInAtList {
|
|
return nil
|
|
}
|
|
|
|
// Validate the only reply destination before downloading media or spending a
|
|
// model call. Webhook errors never include its query string.
|
|
webhookURL := strings.TrimSpace(cb.SessionWebhook)
|
|
if webhookURL == "" {
|
|
return errors.New("dingtalk handler: sessionWebhook is required to reply")
|
|
}
|
|
if err := ValidateWebhookURL(webhookURL); err != nil {
|
|
return fmt.Errorf("dingtalk handler: invalid sessionWebhook: %w", err)
|
|
}
|
|
if strings.TrimSpace(cb.MsgID) == "" {
|
|
return errors.New("dingtalk handler: msgId is required")
|
|
}
|
|
|
|
externalUserID := strings.TrimSpace(cb.SenderStaffID)
|
|
if externalUserID == "" {
|
|
externalUserID = strings.TrimSpace(cb.SenderID)
|
|
}
|
|
if externalUserID == "" {
|
|
return errors.New("dingtalk handler: sender staffId/senderId is required")
|
|
}
|
|
|
|
triggerPerson := strings.TrimSpace(cb.SenderNick)
|
|
senderName := triggerPerson
|
|
department := ""
|
|
region := ""
|
|
actorUnionID := ""
|
|
if h.directory != nil {
|
|
profile, _ := h.directory.ResolveUser(ctx, h.cfg.TenantKey, externalUserID, senderName)
|
|
if name := strings.TrimSpace(profile.Name); name != "" {
|
|
senderName = name
|
|
department = strings.TrimSpace(profile.DepartmentName)
|
|
region = strings.TrimSpace(profile.Region)
|
|
}
|
|
actorUnionID = strings.TrimSpace(profile.UnionID)
|
|
}
|
|
// Trigger person snapshot falls back to official name when callback nick is blank.
|
|
if triggerPerson == "" {
|
|
triggerPerson = senderName
|
|
}
|
|
|
|
if h.settingsRouter != nil && strings.EqualFold(strings.TrimSpace(cb.Msgtype), msgTypeText) {
|
|
handled, settingsReply, err := h.settingsRouter.Handle(ctx, SettingsMessage{
|
|
TenantKey: h.cfg.TenantKey, Channel: h.cfg.Channel, StaffID: externalUserID,
|
|
UnionID: actorUnionID, DisplayName: senderName, Department: department, Text: strings.TrimSpace(cb.Text),
|
|
ConversationType: mapDingTalkConversationType(cb.ConversationType),
|
|
ConversationID: strings.TrimSpace(cb.ConversationID), ConversationTitle: strings.TrimSpace(cb.ConversationTitle),
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("dingtalk settings: %w", err)
|
|
}
|
|
if handled {
|
|
if strings.TrimSpace(settingsReply) == "" {
|
|
return nil
|
|
}
|
|
return h.sendReply(ctx, webhookURL, settingsReply)
|
|
}
|
|
}
|
|
|
|
req := core.QARequest{
|
|
TenantKey: h.cfg.TenantKey,
|
|
Channel: h.cfg.Channel,
|
|
ExternalUserID: externalUserID,
|
|
ExternalMessageID: strings.TrimSpace(cb.MsgID),
|
|
SenderName: senderName,
|
|
TriggerPersonSnapshot: triggerPerson,
|
|
ActorUnionIDSnapshot: actorUnionID,
|
|
Department: department,
|
|
Region: region,
|
|
MessageType: strings.ToLower(strings.TrimSpace(cb.Msgtype)),
|
|
ConversationTitle: strings.TrimSpace(cb.ConversationTitle),
|
|
}
|
|
if h.languageResolver != nil {
|
|
if locale, err := h.languageResolver.GetPreference(ctx, h.cfg.TenantKey, h.cfg.Channel, externalUserID); err == nil {
|
|
req.ResponseLocale = strings.TrimSpace(locale)
|
|
}
|
|
}
|
|
switch cb.ConversationType {
|
|
case conversationTypeGroup:
|
|
if strings.TrimSpace(cb.ConversationID) == "" {
|
|
return errors.New("dingtalk handler: conversationId is required for group messages")
|
|
}
|
|
req.ConversationType = core.ConversationGroup
|
|
req.ExternalChatID = strings.TrimSpace(cb.ConversationID)
|
|
default:
|
|
req.ConversationType = core.ConversationDirect
|
|
req.ConversationTitle = ""
|
|
}
|
|
|
|
switch strings.ToLower(strings.TrimSpace(cb.Msgtype)) {
|
|
case msgTypeText:
|
|
req.Query = strings.TrimSpace(cb.Text)
|
|
if req.Query == "" {
|
|
return errors.New("dingtalk handler: text message content is empty")
|
|
}
|
|
case msgTypePicture:
|
|
codes := effectiveDownloadCodes(cb)
|
|
if len(codes) == 0 {
|
|
log.Printf("DingTalk image preparation failed: stage=missing_download_code")
|
|
return h.sendReply(ctx, webhookURL, imageErrorReply)
|
|
}
|
|
if h.downloader == nil {
|
|
log.Printf("DingTalk image preparation failed: stage=downloader_unavailable")
|
|
return h.sendReply(ctx, webhookURL, imageErrorReply)
|
|
}
|
|
images := make([]core.ImageInput, 0, len(codes))
|
|
for _, code := range codes {
|
|
image, err := h.downloader.Download(ctx, code)
|
|
if err != nil {
|
|
log.Printf("DingTalk image preparation failed: stage=%s", imageFailureStage(err))
|
|
return h.sendReply(ctx, webhookURL, imageErrorReply)
|
|
}
|
|
if h.imagePublisher != nil {
|
|
if url := h.publishQuestionImage(ctx, image); url != "" {
|
|
image.PublishedURL = url
|
|
}
|
|
}
|
|
images = append(images, image)
|
|
}
|
|
req.Query = strings.TrimSpace(cb.Text)
|
|
if req.Query == "" {
|
|
req.Query = imageQuery
|
|
}
|
|
req.Images = images
|
|
default:
|
|
return h.sendReply(ctx, webhookURL, unsupportedMessageReply)
|
|
}
|
|
|
|
if h.reasoningRouter != nil {
|
|
decision, err := h.reasoningRouter.Prepare(ctx, ReasoningMessage{
|
|
TenantKey: h.cfg.TenantKey, Channel: h.cfg.Channel, StaffID: externalUserID,
|
|
Text: req.Query, ConversationID: req.ExternalChatID,
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("dingtalk reasoning mode: %w", err)
|
|
}
|
|
if decision.Handled {
|
|
if strings.TrimSpace(decision.Reply) == "" {
|
|
return nil
|
|
}
|
|
return h.sendReply(ctx, webhookURL, decision.Reply)
|
|
}
|
|
req.Query = strings.TrimSpace(decision.Query)
|
|
req.AgentIDOverride = strings.TrimSpace(decision.AgentID)
|
|
req.ReasoningExecution = string(decision.Execution)
|
|
req.ReasoningExpired = decision.Expired
|
|
}
|
|
|
|
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 mapDingTalkConversationType(value string) string {
|
|
if value == conversationTypeGroup {
|
|
return "group"
|
|
}
|
|
return "direct"
|
|
}
|
|
|
|
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 {
|
|
logQAFailure("non_streaming", err)
|
|
if replyErr := h.sendReply(ctx, webhookURL, qaErrorReply); replyErr != nil {
|
|
return replyErr
|
|
}
|
|
return nil
|
|
}
|
|
if result.Replayed && result.DeliveryStatus == core.DeliverySent {
|
|
return nil
|
|
}
|
|
content := h.rewriteOutboundContent(ctx, result.Answer)
|
|
|
|
if h.card != nil {
|
|
cardReq := CardRequest{
|
|
ConversationType: req.ConversationType,
|
|
ExternalUserID: req.ExternalUserID,
|
|
ExternalChatID: req.ExternalChatID,
|
|
Content: content,
|
|
}
|
|
if outTrackID, cardErr := h.card.SendFinalCard(ctx, cardReq); cardErr == nil {
|
|
h.recordDelivery(ctx, result, core.DeliverySent, core.DeliveryMethodCard, outTrackID, "")
|
|
return nil
|
|
}
|
|
log.Printf("DingTalk card delivery failed, falling back to markdown")
|
|
}
|
|
if err := h.sendReply(ctx, webhookURL, content); err != nil {
|
|
h.recordDelivery(ctx, result, core.DeliveryFailed, "", "", core.DeliveryFailureChannelDelivery)
|
|
return err
|
|
}
|
|
h.recordDelivery(ctx, result, core.DeliverySent, core.DeliveryMethodMarkdown, "", "")
|
|
return nil
|
|
}
|
|
|
|
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 {
|
|
logQAFailure("streaming_fallback", askErr)
|
|
if replyErr := h.sendReply(ctx, webhookURL, qaErrorReply); replyErr != nil {
|
|
return replyErr
|
|
}
|
|
return nil
|
|
}
|
|
if result.Replayed && result.DeliveryStatus == core.DeliverySent {
|
|
return nil
|
|
}
|
|
content := h.rewriteOutboundContent(ctx, result.Answer)
|
|
if replyErr := h.sendReply(ctx, webhookURL, content); replyErr != nil {
|
|
h.recordDelivery(ctx, result, core.DeliveryFailed, "", "", core.DeliveryFailureChannelDelivery)
|
|
return replyErr
|
|
}
|
|
h.recordDelivery(ctx, result, core.DeliverySent, core.DeliveryMethodMarkdown, "", "")
|
|
return nil
|
|
}
|
|
|
|
// Streaming observer with the configured update throttle (500ms by default).
|
|
var lastUpdate time.Time
|
|
var lastPartialContent string
|
|
observer := func(fullContent string) {
|
|
if strings.TrimSpace(fullContent) == "" {
|
|
return
|
|
}
|
|
fullContent = decorateReasoningPartial(fullContent, req.ReasoningExecution)
|
|
now := h.now()
|
|
if lastUpdate.IsZero() || now.Sub(lastUpdate) >= h.cardUpdateInterval {
|
|
partialContent := h.sanitizeOutboundPartial(fullContent)
|
|
if strings.TrimSpace(partialContent) == "" || partialContent == lastPartialContent {
|
|
return
|
|
}
|
|
// 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, partialContent, false, false); updateErr != nil {
|
|
log.Printf("DingTalk streaming card update failed, continuing")
|
|
return
|
|
}
|
|
lastPartialContent = partialContent
|
|
}
|
|
}
|
|
|
|
result, err := streamingQA.AskStream(ctx, req, observer)
|
|
if err != nil || strings.TrimSpace(result.Answer) == "" {
|
|
logQAFailure("streaming", errOrEmptyAnswer(err, result.Answer))
|
|
return h.finalizeCardOrMarkdown(ctx, webhookURL, streamingCard, outTrackID, core.QAResult{}, qaErrorReply, true)
|
|
}
|
|
return h.finalizeCardOrMarkdown(ctx, webhookURL, streamingCard, outTrackID, result, 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 {
|
|
logQAFailure("event_fallback", askErr)
|
|
return h.sendReply(ctx, webhookURL, qaErrorReply)
|
|
}
|
|
if result.Replayed && result.DeliveryStatus == core.DeliverySent {
|
|
return nil
|
|
}
|
|
content := h.rewriteOutboundContent(ctx, result.Answer)
|
|
if replyErr := h.sendReply(ctx, webhookURL, content); replyErr != nil {
|
|
h.recordDelivery(ctx, result, core.DeliveryFailed, "", "", core.DeliveryFailureChannelDelivery)
|
|
return replyErr
|
|
}
|
|
h.recordDelivery(ctx, result, core.DeliverySent, core.DeliveryMethodMarkdown, "", "")
|
|
return nil
|
|
}
|
|
|
|
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
|
|
visibleAnswer := decorateReasoningPartial(event.FullAnswer, req.ReasoningExecution)
|
|
if partialContent := h.sanitizeOutboundPartial(visibleAnswer); strings.TrimSpace(partialContent) != "" {
|
|
pump.Offer(partialContent)
|
|
}
|
|
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) == "" {
|
|
logQAFailure("event_streaming", errOrEmptyAnswer(err, result.Answer))
|
|
return h.finalizeCardOrMarkdown(ctx, webhookURL, streamingCard, outTrackID, core.QAResult{}, qaErrorReply, true)
|
|
}
|
|
return h.finalizeCardOrMarkdown(ctx, webhookURL, streamingCard, outTrackID, result, result.Answer, false)
|
|
}
|
|
|
|
func decorateReasoningPartial(content, execution string) string {
|
|
switch reasoningmode.ExecutionMode(strings.TrimSpace(execution)) {
|
|
case reasoningmode.ExecutionReasoning, reasoningmode.ExecutionReasoningSingle:
|
|
if !strings.HasPrefix(content, "【智能推理模式】") {
|
|
return "【智能推理模式】\n\n" + content
|
|
}
|
|
}
|
|
return content
|
|
}
|
|
|
|
func (h *Handler) finalizeCardOrMarkdown(ctx context.Context, webhookURL string, streamingCard StreamingCardSender, outTrackID string, result core.QAResult, content string, isError bool) error {
|
|
timeout := h.finalDeliveryTimeout
|
|
if timeout <= 0 {
|
|
timeout = defaultHTTPTimeout
|
|
}
|
|
|
|
if !isError {
|
|
content = h.rewriteOutboundContent(ctx, content)
|
|
}
|
|
|
|
// 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 {
|
|
if !isError {
|
|
h.recordDelivery(ctx, result, core.DeliverySent, core.DeliveryMethodCard, outTrackID, "")
|
|
}
|
|
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()
|
|
if err := h.sendReply(fallbackCtx, webhookURL, content); err != nil {
|
|
if !isError {
|
|
h.recordDelivery(ctx, result, core.DeliveryFailed, "", "", core.DeliveryFailureChannelDelivery)
|
|
}
|
|
return err
|
|
}
|
|
if !isError {
|
|
h.recordDelivery(ctx, result, core.DeliverySent, core.DeliveryMethodMarkdown, "", "")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (h *Handler) rewriteOutboundContent(ctx context.Context, content string) string {
|
|
if h.outboundRewriter == nil {
|
|
return sanitizeDisplayAnswer(content)
|
|
}
|
|
timeout := h.finalDeliveryTimeout
|
|
if timeout <= 0 {
|
|
timeout = defaultHTTPTimeout
|
|
}
|
|
rewriteCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), timeout)
|
|
defer cancel()
|
|
return sanitizeDisplayAnswer(h.outboundRewriter.Rewrite(rewriteCtx, content))
|
|
}
|
|
|
|
func (h *Handler) sanitizeOutboundPartial(content string) string {
|
|
sanitizer, ok := h.outboundRewriter.(OutboundPartialSanitizer)
|
|
if ok {
|
|
content = sanitizer.SanitizePartial(content)
|
|
}
|
|
return stableMarkdownPrefix(sanitizeDisplayAnswer(content))
|
|
}
|
|
|
|
func (h *Handler) recordDelivery(ctx context.Context, result core.QAResult, status, method, providerMessageID, failureCode string) {
|
|
if strings.TrimSpace(result.TurnID) == "" || strings.TrimSpace(result.AnswerMessageID) == "" {
|
|
return
|
|
}
|
|
recorder, ok := h.qa.(DeliveryRecorder)
|
|
if !ok {
|
|
return
|
|
}
|
|
timeout := h.finalDeliveryTimeout
|
|
if timeout <= 0 {
|
|
timeout = defaultHTTPTimeout
|
|
}
|
|
auditCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), timeout)
|
|
defer cancel()
|
|
err := recorder.RecordDelivery(auditCtx, core.DeliveryUpdate{
|
|
TenantKey: h.cfg.TenantKey,
|
|
Channel: h.cfg.Channel,
|
|
AnswerMessageID: result.AnswerMessageID,
|
|
CorrelationID: result.TurnID,
|
|
Status: status,
|
|
DeliveryMethod: method,
|
|
ProviderMessageID: providerMessageID,
|
|
FailureCode: failureCode,
|
|
})
|
|
if err != nil {
|
|
log.Printf("DingTalk delivery audit update failed: status=%s method=%s", status, method)
|
|
}
|
|
}
|
|
|
|
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 errOrEmptyAnswer(err error, answer string) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if strings.TrimSpace(answer) == "" {
|
|
return weknora.ErrEmptyAnswer
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func logQAFailure(mode string, err error) {
|
|
log.Printf("DingTalk QA failed: mode=%s stage=%s", mode, qaFailureStage(err))
|
|
}
|
|
|
|
func qaFailureStage(err error) string {
|
|
switch {
|
|
case err == nil:
|
|
return "unknown"
|
|
case errors.Is(err, context.Canceled):
|
|
return "context_canceled"
|
|
case errors.Is(err, context.DeadlineExceeded):
|
|
return "context_deadline"
|
|
case errors.Is(err, core.ErrTurnInProgress):
|
|
return "duplicate_or_in_progress"
|
|
case errors.Is(err, weknora.ErrEmptyAnswer):
|
|
return "empty_answer"
|
|
}
|
|
message := strings.ToLower(err.Error())
|
|
switch {
|
|
case strings.Contains(message, "begin turn"):
|
|
return "begin_turn"
|
|
case strings.Contains(message, "agent") && strings.Contains(message, "binding"):
|
|
return "agent_binding"
|
|
case strings.Contains(message, "session"):
|
|
return "session"
|
|
case strings.Contains(message, "weknora agent chat"):
|
|
return "agent_chat"
|
|
case strings.Contains(message, "required") || strings.Contains(message, "unsupported"):
|
|
return "validation"
|
|
default:
|
|
return "unknown"
|
|
}
|
|
}
|
|
|
|
func imageFailureStage(err error) string {
|
|
message := strings.ToLower(err.Error())
|
|
switch {
|
|
case strings.Contains(message, "oauth"):
|
|
return "oauth"
|
|
case strings.Contains(message, "api"):
|
|
return "file_api"
|
|
case strings.Contains(message, "unsafe") || strings.Contains(message, "destination"):
|
|
return "unsafe_url"
|
|
case strings.Contains(message, "format") || strings.Contains(message, "image data") || strings.Contains(message, "dimensions") || strings.Contains(message, "size limit"):
|
|
return "image_validation"
|
|
case strings.Contains(message, "request") || strings.Contains(message, "http") || strings.Contains(message, "read"):
|
|
return "image_fetch"
|
|
default:
|
|
return "unknown"
|
|
}
|
|
}
|
|
|
|
func (h *Handler) sendReply(ctx context.Context, webhookURL, text string) error {
|
|
if strings.TrimSpace(webhookURL) == "" {
|
|
return errors.New("dingtalk handler: sessionWebhook is required to reply")
|
|
}
|
|
if err := h.reply.SendMarkdown(ctx, webhookURL, replyTitle, text); err != nil {
|
|
return fmt.Errorf("dingtalk handler: send reply: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// publishQuestionImage best-effort publishes a downloaded image's bytes to
|
|
// object storage for traceability. It returns the stable HTTPS URL, or an
|
|
// empty string when publishing is unavailable or fails, so that an image
|
|
// question is never blocked by storage.
|
|
func (h *Handler) publishQuestionImage(ctx context.Context, image core.ImageInput) string {
|
|
if h.imagePublisher == nil {
|
|
return ""
|
|
}
|
|
data, err := decodeImageDataURI(image.DataURI)
|
|
if err != nil || len(data) == 0 {
|
|
log.Printf("DingTalk question image publish failed: stage=decode")
|
|
return ""
|
|
}
|
|
url, err := h.imagePublisher.Publish(ctx, data, image.MIMEType)
|
|
if err != nil || strings.TrimSpace(url) == "" {
|
|
log.Printf("DingTalk question image publish failed: stage=publish")
|
|
return ""
|
|
}
|
|
return strings.TrimSpace(url)
|
|
}
|
|
|
|
// decodeImageDataURI strips the "data:<mime>;base64," prefix and decodes the
|
|
// payload into raw bytes. It is used only to publish inbound images and never
|
|
// writes the data URI to storage.
|
|
func decodeImageDataURI(dataURI string) ([]byte, error) {
|
|
const prefix = "base64,"
|
|
index := strings.Index(dataURI, prefix)
|
|
if index < 0 {
|
|
return nil, errors.New("dingtalk image: data URI missing base64 payload")
|
|
}
|
|
return base64.StdEncoding.DecodeString(dataURI[index+len(prefix):])
|
|
}
|
|
|
|
// effectiveDownloadCodes returns the ordered, de-duplicated list of image
|
|
// download codes for a picture callback. DownloadCode equals the first code
|
|
// and DownloadCodes holds every code (richText with several pictures), so the
|
|
// single value is used to canonicalize the order without duplication.
|
|
func effectiveDownloadCodes(cb BotCallback) []string {
|
|
var codes []string
|
|
seen := make(map[string]struct{})
|
|
for _, code := range append([]string{cb.DownloadCode}, cb.DownloadCodes...) {
|
|
code = strings.TrimSpace(code)
|
|
if code == "" {
|
|
continue
|
|
}
|
|
if _, ok := seen[code]; ok {
|
|
continue
|
|
}
|
|
seen[code] = struct{}{}
|
|
codes = append(codes, code)
|
|
}
|
|
return codes
|
|
}
|