diff --git a/frontend/src/api/agent/index.ts b/frontend/src/api/agent/index.ts index 2f2d10d8..8fde0654 100644 --- a/frontend/src/api/agent/index.ts +++ b/frontend/src/api/agent/index.ts @@ -182,7 +182,7 @@ export interface IMChannel { id: string; tenant_id?: number; agent_id: string; - platform: 'wecom' | 'feishu' | 'slack' | 'telegram'; + platform: 'wecom' | 'feishu' | 'slack' | 'telegram' | 'dingtalk'; name: string; enabled: boolean; mode: 'webhook' | 'websocket'; diff --git a/frontend/src/components/IMChannelPanel.vue b/frontend/src/components/IMChannelPanel.vue index 9e124cd4..ce822243 100644 --- a/frontend/src/components/IMChannelPanel.vue +++ b/frontend/src/components/IMChannelPanel.vue @@ -90,6 +90,7 @@ {{ $t('agentEditor.im.feishu') }} {{ $t('agentEditor.im.slack') }} {{ $t('agentEditor.im.telegram') }} + {{ $t('agentEditor.im.dingtalk') }} @@ -259,6 +260,24 @@ + + + + + + {{ $t('agentEditor.im.dingtalkConsole') }} + + {{ $t('agentEditor.im.consoleTip') }} + + + Client ID (AppKey) + + + + Client Secret (AppSecret) + + + @@ -289,7 +308,7 @@ const knowledgeBases = ref<{ id: string; name: string }[]>([]); const defaultCredentials = (): Record => ({}); const formData = ref({ - platform: 'wecom' as 'wecom' | 'feishu' | 'slack' | 'telegram', + platform: 'wecom' as 'wecom' | 'feishu' | 'slack' | 'telegram' | 'dingtalk', name: '', mode: 'websocket' as 'webhook' | 'websocket', output_mode: 'stream' as 'stream' | 'full', @@ -544,6 +563,10 @@ onMounted(() => { color: #26a6db; } + &.dingtalk { + background: rgba(23, 126, 251, 0.08); + color: #177efb; + } } .channel-name { diff --git a/frontend/src/i18n/locales/en-US.ts b/frontend/src/i18n/locales/en-US.ts index 438ce9e4..98fe05b9 100755 --- a/frontend/src/i18n/locales/en-US.ts +++ b/frontend/src/i18n/locales/en-US.ts @@ -3182,11 +3182,12 @@ export default { }, im: { title: 'IM Integration', - description: 'Connect agent to instant messaging platforms like WeCom, Feishu, Slack and Telegram', + description: 'Connect agent to instant messaging platforms like WeCom, Feishu, Slack, Telegram and DingTalk', wecom: 'WeCom', feishu: 'Feishu', slack: 'Slack', telegram: 'Telegram', + dingtalk: 'DingTalk', addChannel: 'Add Channel', editChannel: 'Edit Channel', deleteConfirm: 'Are you sure you want to delete this channel? This action cannot be undone.', @@ -3205,6 +3206,7 @@ export default { feishuConsole: 'Feishu Open Platform', slackConsole: 'Slack API Console', telegramConsole: 'Telegram BotFather', + dingtalkConsole: 'DingTalk Open Platform', modeHint: 'WebSocket is recommended for easier setup', consoleTip: 'to get credentials', fileKnowledgeBase: 'File Storage Knowledge Base', diff --git a/frontend/src/i18n/locales/ko-KR.ts b/frontend/src/i18n/locales/ko-KR.ts index 2f5b77c7..fb14a603 100755 --- a/frontend/src/i18n/locales/ko-KR.ts +++ b/frontend/src/i18n/locales/ko-KR.ts @@ -3212,11 +3212,12 @@ export default { }, im: { title: "IM 통합", - description: "에이전트를 WeCom, Feishu, Slack, Telegram 등 인스턴트 메시징 플랫폼에 연결", + description: "에이전트를 WeCom, Feishu, Slack, Telegram, DingTalk 등 인스턴트 메시징 플랫폼에 연결", wecom: "WeCom", feishu: "Feishu", slack: "Slack", telegram: "Telegram", + dingtalk: "DingTalk", addChannel: "채널 추가", editChannel: "채널 편집", deleteConfirm: "이 채널을 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.", @@ -3235,6 +3236,7 @@ export default { feishuConsole: "Feishu 개발 플랫폼", slackConsole: "Slack API 콘솔", telegramConsole: "Telegram BotFather", + dingtalkConsole: "DingTalk 개발 플랫폼", modeHint: "WebSocket 방식이 설정이 더 간편하여 권장됩니다", consoleTip: "자격 증명 정보를 가져오세요", fileKnowledgeBase: "파일 저장 지식 베이스", diff --git a/frontend/src/i18n/locales/ru-RU.ts b/frontend/src/i18n/locales/ru-RU.ts index 6c22ee7a..1b4cda9d 100755 --- a/frontend/src/i18n/locales/ru-RU.ts +++ b/frontend/src/i18n/locales/ru-RU.ts @@ -2845,11 +2845,12 @@ export default { }, im: { title: 'Интеграция IM', - description: 'Подключите агента к платформам мгновенных сообщений, таким как WeCom, Feishu, Slack и Telegram', + description: 'Подключите агента к платформам мгновенных сообщений, таким как WeCom, Feishu, Slack, Telegram и DingTalk', wecom: 'WeCom', feishu: 'Feishu', slack: 'Slack', telegram: 'Telegram', + dingtalk: 'DingTalk', addChannel: 'Добавить канал', editChannel: 'Редактировать канал', deleteConfirm: 'Вы уверены, что хотите удалить этот канал? Это действие не может быть отменено.', @@ -2868,6 +2869,7 @@ export default { feishuConsole: 'Платформа Feishu', slackConsole: 'Консоль Slack API', telegramConsole: 'Telegram BotFather', + dingtalkConsole: 'Платформа DingTalk', modeHint: 'Рекомендуется WebSocket — проще настроить', consoleTip: 'для получения учётных данных', fileKnowledgeBase: 'База знаний для файлов', diff --git a/frontend/src/i18n/locales/zh-CN.ts b/frontend/src/i18n/locales/zh-CN.ts index 3a235db3..6bbee333 100755 --- a/frontend/src/i18n/locales/zh-CN.ts +++ b/frontend/src/i18n/locales/zh-CN.ts @@ -3157,11 +3157,12 @@ export default { }, im: { title: "IM 集成", - description: "将智能体接入即时通讯平台,支持企业微信、飞书、Slack和Telegram", + description: "将智能体接入即时通讯平台,支持企业微信、飞书、Slack、Telegram和钉钉", wecom: "企业微信", feishu: "飞书", slack: "Slack", telegram: "Telegram", + dingtalk: "钉钉", addChannel: "添加渠道", editChannel: "编辑渠道", deleteConfirm: "确定删除该渠道?删除后无法恢复。", @@ -3180,6 +3181,7 @@ export default { feishuConsole: "飞书开放平台", slackConsole: "Slack API 控制台", telegramConsole: "Telegram BotFather", + dingtalkConsole: "钉钉开放平台", modeHint: "推荐使用 WebSocket 方式接入,配置更简单", consoleTip: "前往获取凭证信息", fileKnowledgeBase: "文件保存知识库", diff --git a/go.mod b/go.mod index a975bf12..a9a9f988 100644 --- a/go.mod +++ b/go.mod @@ -31,6 +31,7 @@ require ( github.com/minio/minio-go/v7 v7.0.91 github.com/neo4j/neo4j-go-driver/v6 v6.0.0-alpha.1 github.com/ollama/ollama v0.11.4 + github.com/open-dingtalk/dingtalk-stream-sdk-go v0.9.1 github.com/panjf2000/ants/v2 v2.11.3 github.com/parquet-go/parquet-go v0.25.0 github.com/pganalyze/pg_query_go/v6 v6.1.0 diff --git a/go.sum b/go.sum index 2890d2ed..810ada80 100644 --- a/go.sum +++ b/go.sum @@ -2211,6 +2211,8 @@ github.com/ollama/ollama v0.11.4/go.mod h1:9+1//yWPsDE2u+l1a5mpaKrYw4VdnSsRU3ioq github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.10.3/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= +github.com/open-dingtalk/dingtalk-stream-sdk-go v0.9.1 h1:Lb/Uzkiw2Ugt2Xf03J5wmv81PdkYOiWbI8CNBi1boC8= +github.com/open-dingtalk/dingtalk-stream-sdk-go v0.9.1/go.mod h1:ln3IqPYYocZbYvl9TAOrG/cxGR9xcn4pnZRLdCTEGEU= github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040= diff --git a/internal/container/container.go b/internal/container/container.go index 24fd66e9..688b207f 100644 --- a/internal/container/container.go +++ b/internal/container/container.go @@ -54,6 +54,7 @@ import ( "github.com/Tencent/WeKnora/internal/handler" "github.com/Tencent/WeKnora/internal/handler/session" imPkg "github.com/Tencent/WeKnora/internal/im" + "github.com/Tencent/WeKnora/internal/im/dingtalk" "github.com/Tencent/WeKnora/internal/im/feishu" "github.com/Tencent/WeKnora/internal/im/slack" "github.com/Tencent/WeKnora/internal/im/telegram" @@ -1133,6 +1134,44 @@ func registerIMAdapterFactories(imService *imPkg.Service) { } }) + // Register DingTalk adapter factory + imService.RegisterAdapterFactory("dingtalk", func(factoryCtx context.Context, channel *imPkg.IMChannel, msgHandler func(context.Context, *imPkg.IncomingMessage) error) (imPkg.Adapter, context.CancelFunc, error) { + creds, err := parseCredentials(channel.Credentials) + if err != nil { + return nil, nil, fmt.Errorf("parse dingtalk credentials: %w", err) + } + + clientID := getString(creds, "client_id") + clientSecret := getString(creds, "client_secret") + + mode := channel.Mode + if mode == "" { + mode = "websocket" + } + + switch mode { + case "webhook": + adapter := dingtalk.NewWebhookAdapter(clientID, clientSecret) + return adapter, nil, nil + + case "websocket": + client := dingtalk.NewLongConnClient(clientID, clientSecret, msgHandler) + + wsCtx, wsCancel := context.WithCancel(context.Background()) + go func() { + if err := client.Start(wsCtx); err != nil && wsCtx.Err() == nil { + logger.Errorf(context.Background(), "[IM] DingTalk stream stopped for channel %s: %v", channel.ID, err) + } + }() + + adapter := dingtalk.NewAdapter(client, clientID, clientSecret) + return adapter, wsCancel, nil + + default: + return nil, nil, fmt.Errorf("unsupported dingtalk mode: %s", mode) + } + }) + // Load and start all enabled channels from database if err := imService.LoadAndStartChannels(); err != nil { logger.Warnf(ctx, "[IM] Failed to load channels from database: %v", err) diff --git a/internal/handler/im.go b/internal/handler/im.go index 8d15ef0d..bae73da3 100644 --- a/internal/handler/im.go +++ b/internal/handler/im.go @@ -12,7 +12,7 @@ import ( ) // validIMPlatforms is the set of supported IM platforms. -var validIMPlatforms = map[string]bool{"wecom": true, "feishu": true, "slack": true, "telegram": true} +var validIMPlatforms = map[string]bool{"wecom": true, "feishu": true, "slack": true, "telegram": true, "dingtalk": true} // IMHandler handles IM platform callback requests and channel CRUD. type IMHandler struct { @@ -57,7 +57,7 @@ func (h *IMHandler) CreateIMChannel(c *gin.Context) { } if !validIMPlatforms[req.Platform] { - c.JSON(http.StatusBadRequest, gin.H{"error": "platform must be 'wecom', 'feishu', 'slack' or 'telegram'"}) + c.JSON(http.StatusBadRequest, gin.H{"error": "platform must be 'wecom', 'feishu', 'slack', 'telegram' or 'dingtalk'"}) return } diff --git a/internal/im/adapter.go b/internal/im/adapter.go index 6fb16e04..b8925ac4 100644 --- a/internal/im/adapter.go +++ b/internal/im/adapter.go @@ -15,6 +15,7 @@ const ( PlatformFeishu Platform = "feishu" PlatformSlack Platform = "slack" PlatformTelegram Platform = "telegram" + PlatformDingtalk Platform = "dingtalk" ) // MessageType identifies the kind of IM message. diff --git a/internal/im/dingtalk/adapter.go b/internal/im/dingtalk/adapter.go new file mode 100644 index 00000000..b3e2b487 --- /dev/null +++ b/internal/im/dingtalk/adapter.go @@ -0,0 +1,422 @@ +package dingtalk + +import ( + "bytes" + "context" + "crypto/hmac" + "crypto/sha256" + "encoding/base64" + "encoding/json" + "fmt" + "io" + "net/http" + "strconv" + "strings" + "sync" + "time" + + "github.com/gin-gonic/gin" + + "github.com/Tencent/WeKnora/internal/im" + "github.com/Tencent/WeKnora/internal/logger" +) + +// httpClient is a shared HTTP client with a reasonable timeout for DingTalk API calls. +var httpClient = &http.Client{Timeout: 15 * time.Second} + +// Compile-time checks. +var ( + _ im.Adapter = (*Adapter)(nil) + _ im.StreamSender = (*Adapter)(nil) +) + +// Adapter implements im.Adapter for DingTalk. +type Adapter struct { + clientID string + clientSecret string + client *LongConnClient // nil for webhook mode + + // accessToken cache + tokenMu sync.RWMutex + token string + tokenExpAt time.Time +} + +// NewWebhookAdapter creates a DingTalk adapter for HTTP callback mode. +func NewWebhookAdapter(clientID, clientSecret string) *Adapter { + return &Adapter{ + clientID: clientID, + clientSecret: clientSecret, + } +} + +// NewAdapter creates a DingTalk adapter backed by a stream client. +func NewAdapter(client *LongConnClient, clientID, clientSecret string) *Adapter { + return &Adapter{ + clientID: clientID, + clientSecret: clientSecret, + client: client, + } +} + +func (a *Adapter) Platform() im.Platform { + return im.PlatformDingtalk +} + +func (a *Adapter) HandleURLVerification(c *gin.Context) bool { + return false // DingTalk does not use URL verification challenges. +} + +// VerifyCallback verifies the DingTalk webhook signature (HmacSHA256). +func (a *Adapter) VerifyCallback(c *gin.Context) error { + if a.clientSecret == "" { + return nil + } + + timestamp := c.GetHeader("Timestamp") + sign := c.GetHeader("Sign") + if timestamp == "" || sign == "" { + return fmt.Errorf("missing timestamp or sign header") + } + + // Check timestamp is within 1 hour + ts, err := strconv.ParseInt(timestamp, 10, 64) + if err != nil { + return fmt.Errorf("invalid timestamp: %w", err) + } + diff := time.Now().UnixMilli() - ts + if diff > 3600*1000 || diff < -3600*1000 { + return fmt.Errorf("timestamp expired") + } + + // Verify HMAC-SHA256 signature + stringToSign := timestamp + "\n" + a.clientSecret + h := hmac.New(sha256.New, []byte(a.clientSecret)) + h.Write([]byte(stringToSign)) + expectedSign := base64.StdEncoding.EncodeToString(h.Sum(nil)) + + if !hmac.Equal([]byte(sign), []byte(expectedSign)) { + return fmt.Errorf("invalid signature") + } + + return nil +} + +// DingTalk callback message structure. +type callbackMessage struct { + ConversationID string `json:"conversationId"` + ConversationType string `json:"conversationType"` // "1" = single, "2" = group + MsgID string `json:"msgId"` + Msgtype string `json:"msgtype"` // "text", "picture", "richText", "file" + Text *textContent `json:"text"` + SenderNick string `json:"senderNick"` + SenderStaffId string `json:"senderStaffId"` + SenderID string `json:"senderId"` + SessionWebhook string `json:"sessionWebhook"` + RobotCode string `json:"robotCode"` + AtUsers []atUser `json:"atUsers"` + IsInAtList bool `json:"isInAtList"` + ChatbotCorpId string `json:"chatbotCorpId"` +} + +type textContent struct { + Content string `json:"content"` +} + +type atUser struct { + DingtalkID string `json:"dingtalkId"` + StaffID string `json:"staffId"` +} + +func (a *Adapter) ParseCallback(c *gin.Context) (*im.IncomingMessage, error) { + bodyBytes, err := io.ReadAll(c.Request.Body) + if err != nil { + return nil, fmt.Errorf("read body: %w", err) + } + c.Request.Body = io.NopCloser(bytes.NewReader(bodyBytes)) + + var msg callbackMessage + if err := json.Unmarshal(bodyBytes, &msg); err != nil { + return nil, fmt.Errorf("parse callback: %w", err) + } + + return parseCallbackMessage(&msg), nil +} + +func parseCallbackMessage(msg *callbackMessage) *im.IncomingMessage { + chatType := im.ChatTypeDirect + chatID := "" + if msg.ConversationType == "2" { + chatType = im.ChatTypeGroup + chatID = msg.ConversationID + } + + userID := msg.SenderStaffId + if userID == "" { + userID = msg.SenderID + } + + content := "" + if msg.Text != nil { + content = strings.TrimSpace(msg.Text.Content) + } + + incoming := &im.IncomingMessage{ + Platform: im.PlatformDingtalk, + UserID: userID, + UserName: msg.SenderNick, + ChatID: chatID, + ChatType: chatType, + MessageID: msg.MsgID, + MessageType: im.MessageTypeText, + Content: content, + Extra: map[string]string{ + "session_webhook": msg.SessionWebhook, + }, + } + + return incoming +} + +// ── Send reply ── + +func (a *Adapter) SendReply(ctx context.Context, incoming *im.IncomingMessage, reply *im.ReplyMessage) error { + // Prefer sessionWebhook for simplicity + sessionWebhook := "" + if incoming.Extra != nil { + sessionWebhook = incoming.Extra["session_webhook"] + } + + if sessionWebhook != "" { + return a.replyViaSessionWebhook(ctx, sessionWebhook, reply.Content) + } + + // Fallback to OpenAPI + return a.replyViaOpenAPI(ctx, incoming, reply.Content) +} + +func (a *Adapter) replyViaSessionWebhook(ctx context.Context, webhookURL, content string) error { + body := map[string]interface{}{ + "msgtype": "markdown", + "markdown": map[string]string{ + "title": "Reply", + "text": content, + }, + } + + jsonBody, err := json.Marshal(body) + if err != nil { + return fmt.Errorf("marshal reply: %w", err) + } + + req, err := http.NewRequestWithContext(ctx, http.MethodPost, webhookURL, bytes.NewReader(jsonBody)) + if err != nil { + return fmt.Errorf("create request: %w", err) + } + req.Header.Set("Content-Type", "application/json") + + resp, err := httpClient.Do(req) + if err != nil { + return fmt.Errorf("send reply: %w", err) + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + respBody, _ := io.ReadAll(resp.Body) + return fmt.Errorf("dingtalk sessionWebhook returned %d: %s", resp.StatusCode, string(respBody)) + } + return nil +} + +func (a *Adapter) replyViaOpenAPI(ctx context.Context, incoming *im.IncomingMessage, content string) error { + token, err := a.getAccessToken(ctx) + if err != nil { + return fmt.Errorf("get access token: %w", err) + } + + msgParam, err := json.Marshal(map[string]string{"title": "Reply", "text": content}) + if err != nil { + return fmt.Errorf("marshal msgParam: %w", err) + } + + var apiURL string + body := map[string]interface{}{ + "robotCode": a.clientID, + "msgKey": "sampleMarkdown", + "msgParam": string(msgParam), + } + + if incoming.ChatType == im.ChatTypeGroup { + apiURL = "https://api.dingtalk.com/v1.0/robot/groupMessages/send" + body["openConversationId"] = incoming.ChatID + } else { + apiURL = "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend" + body["userIds"] = []string{incoming.UserID} + } + + jsonBody, err := json.Marshal(body) + if err != nil { + return fmt.Errorf("marshal body: %w", err) + } + + req, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, bytes.NewReader(jsonBody)) + if err != nil { + return fmt.Errorf("create request: %w", err) + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("x-acs-dingtalk-access-token", token) + + resp, err := httpClient.Do(req) + if err != nil { + return fmt.Errorf("send reply: %w", err) + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + respBody, _ := io.ReadAll(resp.Body) + return fmt.Errorf("dingtalk OpenAPI returned %d: %s", resp.StatusCode, string(respBody)) + } + return nil +} + +// getAccessToken returns a cached or fresh DingTalk access token. +func (a *Adapter) getAccessToken(ctx context.Context) (string, error) { + a.tokenMu.RLock() + if a.token != "" && time.Now().Before(a.tokenExpAt) { + token := a.token + a.tokenMu.RUnlock() + return token, nil + } + a.tokenMu.RUnlock() + + a.tokenMu.Lock() + defer a.tokenMu.Unlock() + + // Double check after acquiring write lock + if a.token != "" && time.Now().Before(a.tokenExpAt) { + return a.token, nil + } + + body := map[string]string{ + "appKey": a.clientID, + "appSecret": a.clientSecret, + } + jsonBody, _ := json.Marshal(body) + + req, err := http.NewRequestWithContext(ctx, http.MethodPost, + "https://api.dingtalk.com/v1.0/oauth2/accessToken", + bytes.NewReader(jsonBody)) + if err != nil { + return "", err + } + req.Header.Set("Content-Type", "application/json") + + resp, err := httpClient.Do(req) + if err != nil { + return "", err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + respBody, _ := io.ReadAll(resp.Body) + return "", fmt.Errorf("dingtalk accessToken returned %d: %s", resp.StatusCode, string(respBody)) + } + + var result struct { + AccessToken string `json:"accessToken"` + ExpireIn int64 `json:"expireIn"` + } + if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { + return "", fmt.Errorf("decode token response: %w", err) + } + if result.AccessToken == "" { + return "", fmt.Errorf("empty access token from dingtalk") + } + + a.token = result.AccessToken + // Refresh 5 minutes before expiry + a.tokenExpAt = time.Now().Add(time.Duration(result.ExpireIn)*time.Second - 5*time.Minute) + + return a.token, nil +} + +// ── StreamSender implementation ── +// DingTalk does not support editing messages in place. We accumulate content +// and send the full reply at EndStream via sessionWebhook. + +type streamState struct { + mu sync.Mutex + content strings.Builder + sessionWebhook string +} + +var ( + streamsMu sync.Mutex + dStreams = map[string]*streamState{} +) + +func (a *Adapter) StartStream(ctx context.Context, incoming *im.IncomingMessage) (string, error) { + sessionWebhook := "" + if incoming.Extra != nil { + sessionWebhook = incoming.Extra["session_webhook"] + } + + streamID := fmt.Sprintf("dt:%s:%s", incoming.UserID, incoming.MessageID) + + streamsMu.Lock() + dStreams[streamID] = &streamState{ + sessionWebhook: sessionWebhook, + } + streamsMu.Unlock() + + logger.Infof(ctx, "[DingTalk] Streaming started: stream_id=%s", streamID) + return streamID, nil +} + +func (a *Adapter) SendStreamChunk(ctx context.Context, incoming *im.IncomingMessage, streamID string, content string) error { + if content == "" { + return nil + } + + streamsMu.Lock() + state, ok := dStreams[streamID] + streamsMu.Unlock() + if !ok { + return fmt.Errorf("unknown stream ID: %s", streamID) + } + + state.mu.Lock() + state.content.WriteString(content) + state.mu.Unlock() + + return nil +} + +func (a *Adapter) EndStream(ctx context.Context, incoming *im.IncomingMessage, streamID string) error { + streamsMu.Lock() + state, ok := dStreams[streamID] + delete(dStreams, streamID) + streamsMu.Unlock() + + if !ok { + return nil + } + + state.mu.Lock() + fullContent := state.content.String() + state.mu.Unlock() + + if state.sessionWebhook != "" { + if err := a.replyViaSessionWebhook(ctx, state.sessionWebhook, fullContent); err != nil { + logger.Warnf(ctx, "[DingTalk] Failed to end stream: %v", err) + } + } else { + // Fallback to OpenAPI + if err := a.replyViaOpenAPI(ctx, incoming, fullContent); err != nil { + logger.Warnf(ctx, "[DingTalk] Failed to end stream via OpenAPI: %v", err) + } + } + + logger.Infof(ctx, "[DingTalk] Streaming ended: stream_id=%s", streamID) + return nil +} diff --git a/internal/im/dingtalk/longconn.go b/internal/im/dingtalk/longconn.go new file mode 100644 index 00000000..d331ed7d --- /dev/null +++ b/internal/im/dingtalk/longconn.go @@ -0,0 +1,97 @@ +package dingtalk + +import ( + "context" + "strings" + + dtsdk "github.com/open-dingtalk/dingtalk-stream-sdk-go/client" + "github.com/open-dingtalk/dingtalk-stream-sdk-go/chatbot" + + "github.com/Tencent/WeKnora/internal/im" + "github.com/Tencent/WeKnora/internal/logger" +) + +// MessageHandler is called when an IM message is received via stream connection. +type MessageHandler func(ctx context.Context, msg *im.IncomingMessage) error + +// LongConnClient manages a DingTalk Stream mode connection. +type LongConnClient struct { + clientID string + clientSecret string + handler MessageHandler + streamClient *dtsdk.StreamClient +} + +// NewLongConnClient creates a DingTalk stream client. +func NewLongConnClient(clientID, clientSecret string, handler MessageHandler) *LongConnClient { + cli := dtsdk.NewStreamClient( + dtsdk.WithAppCredential(&dtsdk.AppCredentialConfig{ + ClientId: clientID, + ClientSecret: clientSecret, + }), + ) + + c := &LongConnClient{ + clientID: clientID, + clientSecret: clientSecret, + handler: handler, + streamClient: cli, + } + + cli.RegisterChatBotCallbackRouter(c.onChatBotMessage) + + return c +} + +// Start begins the stream connection. It blocks until ctx is cancelled. +func (c *LongConnClient) Start(ctx context.Context) error { + logger.Infof(ctx, "[IM] DingTalk Stream connecting...") + + errCh := make(chan error, 1) + go func() { + errCh <- c.streamClient.Start(ctx) + }() + + select { + case <-ctx.Done(): + return ctx.Err() + case err := <-errCh: + return err + } +} + +func (c *LongConnClient) onChatBotMessage(ctx context.Context, data *chatbot.BotCallbackDataModel) ([]byte, error) { + chatType := im.ChatTypeDirect + chatID := "" + if data.ConversationType == "2" { + chatType = im.ChatTypeGroup + chatID = data.ConversationId + } + + userID := data.SenderStaffId + if userID == "" { + userID = data.SenderId + } + + content := strings.TrimSpace(data.Text.Content) + + incoming := &im.IncomingMessage{ + Platform: im.PlatformDingtalk, + UserID: userID, + UserName: data.SenderNick, + ChatID: chatID, + ChatType: chatType, + MessageID: data.MsgId, + MessageType: im.MessageTypeText, + Content: content, + Extra: map[string]string{ + "session_webhook": data.SessionWebhook, + }, + } + + if err := c.handler(ctx, incoming); err != nil { + logger.Errorf(ctx, "[DingTalk] Handle message error: %v", err) + } + + return nil, nil +} diff --git a/internal/im/types.go b/internal/im/types.go index 2f64829b..7674f915 100644 --- a/internal/im/types.go +++ b/internal/im/types.go @@ -100,6 +100,10 @@ func (ch *IMChannel) computeBotIdentity() string { } return "telegram:" + botToken } + case "dingtalk": + if clientID := str("client_id"); clientID != "" { + return "dingtalk:" + clientID + } } return "" }