feat: integrate DingTalk multimodal streaming AI cards #2

Merged
zheromiku merged 16 commits from feature/dingtalk-image-ingress into main 2026-07-21 00:28:43 +08:00
36 changed files with 7356 additions and 16 deletions
+12
View File
@@ -8,5 +8,17 @@ DOBOTAI_AGENT_BINDINGS={"dingtalk:*":"replace-with-agent-id"}
WEKNORA_BASE_URL=http://127.0.0.1:8080
WEKNORA_API_KEY=replace-me
# DingTalk Stream mode (official SDK). Leave all three empty to disable the
# DingTalk channel; set all three to enable it. Never commit real values.
DINGTALK_CLIENT_ID=
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
+10
View File
@@ -15,6 +15,16 @@ Implemented:
- external-message idempotency;
- independent PostgreSQL session/turn storage;
- authenticated internal `POST /v1/qa` ingress endpoint.
- DingTalk Stream text ingress (official SDK) wired into `cmd/dobotai`.
## DingTalk channel (Stream, text only)
- Uses the official DingTalk Stream SDK (`dingtalk-stream-sdk-go`); no public webhook endpoint is exposed.
- Text messages only for now. Images, OpenAPI fallback, and card replies are not implemented yet.
- Group chats are handled only when the bot is @-mentioned; other group messages are ignored.
- Sessions: direct chats use one long-lived session per user; group chats share one session per group (default `shared` policy).
- Replies are sent via the callback's `sessionWebhook`, which is fail-closed: only `https` URLs on `*.dingtalk.com` (port 443, no redirects) are accepted.
- Required env vars to enable (all three or none): `DINGTALK_CLIENT_ID`, `DINGTALK_CLIENT_SECRET`, `DOBOTAI_TENANT_KEY`. Partial configuration is a fatal startup error.
## WeKnora baseline
+47
View File
@@ -12,6 +12,7 @@ import (
"time"
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/agentbinding"
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/channels/dingtalk"
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/httpapi"
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/qa"
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/session"
@@ -52,6 +53,52 @@ func main() {
if err != nil {
log.Fatal(err)
}
dingCfg := dingtalk.StreamConfig{
ClientID: os.Getenv("DINGTALK_CLIENT_ID"),
ClientSecret: os.Getenv("DINGTALK_CLIENT_SECRET"),
TenantKey: os.Getenv("DOBOTAI_TENANT_KEY"),
}
if err := dingCfg.Validate(); err != nil {
log.Fatal(err)
}
var streamClient *dingtalk.StreamClient
if dingCfg.Enabled() {
sender, err := dingtalk.NewWebhookSender(nil)
if err != nil {
log.Fatal(err)
}
downloader, err := dingtalk.NewImageDownloader(dingCfg.ClientID, dingCfg.ClientSecret, nil)
if err != nil {
log.Fatal(err)
}
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,
dingtalk.HandlerOptions{ImageDownloader: downloader, CardSender: cardSender},
)
if err != nil {
log.Fatal(err)
}
streamClient, err = dingtalk.NewStreamClient(dingCfg, handler)
if err != nil {
log.Fatal(err)
}
if err := streamClient.Start(ctx); err != nil {
log.Fatal(err)
}
defer streamClient.Close()
log.Printf("DingTalk Stream ingress started for tenant %s", dingCfg.TenantKey)
}
address := strings.TrimSpace(os.Getenv("DOBOTAI_LISTEN_ADDR"))
if address == "" {
address = "127.0.0.1:8090"
+6 -6
View File
@@ -1,4 +1,4 @@
CREATE TABLE session_mappings (
CREATE TABLE IF NOT EXISTS session_mappings (
session_key TEXT PRIMARY KEY,
tenant_key TEXT NOT NULL,
channel TEXT NOT NULL,
@@ -10,10 +10,10 @@ CREATE TABLE session_mappings (
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX idx_session_mappings_tenant_channel
CREATE INDEX IF NOT EXISTS idx_session_mappings_tenant_channel
ON session_mappings (tenant_key, channel, external_subject_id);
CREATE TABLE turns (
CREATE TABLE IF NOT EXISTS turns (
id TEXT PRIMARY KEY,
tenant_key TEXT NOT NULL,
channel TEXT NOT NULL,
@@ -23,7 +23,7 @@ CREATE TABLE turns (
weknora_request_id TEXT NOT NULL DEFAULT '',
question TEXT NOT NULL,
answer TEXT NOT NULL DEFAULT '',
references JSONB NOT NULL DEFAULT '[]'::JSONB,
references_json JSONB NOT NULL DEFAULT '[]'::JSONB,
status TEXT NOT NULL CHECK (status IN ('processing','succeeded','failed','cancelled')),
error_message TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
@@ -31,5 +31,5 @@ CREATE TABLE turns (
UNIQUE (tenant_key, channel, external_message_id)
);
CREATE INDEX idx_turns_tenant_created ON turns (tenant_key, created_at DESC);
CREATE INDEX idx_turns_session_created ON turns (session_key, created_at DESC);
CREATE INDEX IF NOT EXISTS idx_turns_tenant_created ON turns (tenant_key, created_at DESC);
CREATE INDEX IF NOT EXISTS idx_turns_session_created ON turns (session_key, created_at DESC);
@@ -0,0 +1,91 @@
// Package migrations_test contains source-level contract tests for the SQL
// migration files. They guard against the PostgreSQL 16 reserved-word
// failure (`references JSONB`) and guarantee the migration can be safely
// re-run from a half-applied state (session_mappings + its index created,
// turns not created). No real database connection is used.
package migrations_test
import (
"os"
"path/filepath"
"regexp"
"strings"
"testing"
)
func readUpMigration(t *testing.T) string {
t.Helper()
data, err := os.ReadFile(filepath.Join(".", "000001_core.up.sql"))
if err != nil {
t.Fatalf("read up migration: %v", err)
}
return string(data)
}
func readDownMigration(t *testing.T) string {
t.Helper()
data, err := os.ReadFile(filepath.Join(".", "000001_core.down.sql"))
if err != nil {
t.Fatalf("read down migration: %v", err)
}
return string(data)
}
// TestUpMigrationUsesIfNotExists enforces idempotency: every CREATE TABLE and
// CREATE INDEX must use IF NOT EXISTS so a half-applied migration (e.g.
// session_mappings already created, turns missing) can be re-run cleanly.
func TestUpMigrationUsesIfNotExists(t *testing.T) {
up := readUpMigration(t)
for _, stmt := range splitStatements(up) {
upper := strings.ToUpper(stmt)
if strings.Contains(upper, "CREATE TABLE") && !strings.Contains(upper, "CREATE TABLE IF NOT EXISTS") {
t.Errorf("CREATE TABLE without IF NOT EXISTS:\n%s", strings.TrimSpace(stmt))
}
if strings.Contains(upper, "CREATE INDEX") && !strings.Contains(upper, "CREATE INDEX IF NOT EXISTS") {
t.Errorf("CREATE INDEX without IF NOT EXISTS:\n%s", strings.TrimSpace(stmt))
}
}
if got := countMatches(up, `(?i)CREATE\s+TABLE\s+IF\s+NOT\s+EXISTS`); got != 2 {
t.Errorf("expected 2 CREATE TABLE IF NOT EXISTS statements, got %d", got)
}
if got := countMatches(up, `(?i)CREATE\s+INDEX\s+IF\s+NOT\s+EXISTS`); got != 3 {
t.Errorf("expected 3 CREATE INDEX IF NOT EXISTS statements, got %d", got)
}
}
// TestUpMigrationAvoidsReservedWordReferences ensures the turns table does
// not declare a bare `references JSONB` column. REFERENCES is a reserved word
// in PostgreSQL 16 and fails with "syntax error at or near references"
// unless quoted. The column must be named references_json.
func TestUpMigrationAvoidsReservedWordReferences(t *testing.T) {
up := readUpMigration(t)
if regexp.MustCompile(`(?im)^\s*references\s+JSONB`).MatchString(up) {
t.Error("up migration declares reserved-word column `references JSONB`; rename it to references_json")
}
if !regexp.MustCompile(`(?im)^\s*references_json\s+JSONB\s+NOT\s+NULL\s+DEFAULT\s+'\[\]'::JSONB`).MatchString(up) {
t.Error("up migration must declare column `references_json JSONB NOT NULL DEFAULT '[]'::JSONB`")
}
}
// TestDownMigrationDropsBothTables guards the rollback path stays droppable.
func TestDownMigrationDropsBothTables(t *testing.T) {
down := readDownMigration(t)
upper := strings.ToUpper(down)
if !strings.Contains(upper, "DROP TABLE IF EXISTS TURNS") {
t.Error("down migration must drop turns")
}
if !strings.Contains(upper, "DROP TABLE IF EXISTS SESSION_MAPPINGS") {
t.Error("down migration must drop session_mappings")
}
}
func splitStatements(sql string) []string {
return strings.Split(sql, ";")
}
func countMatches(haystack, pattern string) int {
return len(regexp.MustCompile(pattern).FindAllString(haystack, -1))
}
+2
View File
@@ -0,0 +1,2 @@
ALTER TABLE turns
DROP COLUMN IF EXISTS media_json;
+2
View File
@@ -0,0 +1,2 @@
ALTER TABLE turns
ADD COLUMN IF NOT EXISTS media_json JSONB NOT NULL DEFAULT '[]'::JSONB;
@@ -0,0 +1,80 @@
// Package migrations_test contains source-level contract tests for the
// 000002_turn_media migration. No real database connection is used.
package migrations_test
import (
"os"
"path/filepath"
"regexp"
"strings"
"testing"
)
func readMediaUpMigration(t *testing.T) string {
t.Helper()
data, err := os.ReadFile(filepath.Join(".", "000002_turn_media.up.sql"))
if err != nil {
t.Fatalf("read up migration: %v", err)
}
return string(data)
}
func readMediaDownMigration(t *testing.T) string {
t.Helper()
data, err := os.ReadFile(filepath.Join(".", "000002_turn_media.down.sql"))
if err != nil {
t.Fatalf("read down migration: %v", err)
}
return string(data)
}
// TestUpMediaMigrationAddsMediaJSONColumn enforces that the up migration
// adds a media_json JSONB column to the turns table with appropriate defaults.
func TestUpMediaMigrationAddsMediaJSONColumn(t *testing.T) {
up := readMediaUpMigration(t)
upper := strings.ToUpper(up)
if !strings.Contains(upper, "ADD COLUMN IF NOT EXISTS MEDIA_JSON") {
t.Error("up migration must use ADD COLUMN IF NOT EXISTS media_json")
}
if !strings.Contains(upper, "JSONB NOT NULL DEFAULT '[]'::JSONB") {
t.Error("up migration must declare media_json JSONB NOT NULL DEFAULT '[]'::JSONB")
}
}
// TestUpMediaMigrationIsIdempotent enforces that the up migration uses IF NOT
// EXISTS so it can be safely re-run.
func TestUpMediaMigrationIsIdempotent(t *testing.T) {
up := readMediaUpMigration(t)
upper := strings.ToUpper(up)
if !strings.Contains(upper, "IF NOT EXISTS") {
t.Error("up migration must use IF NOT EXISTS for idempotency")
}
}
// TestDownMediaMigrationDropsColumn enforces the down migration drops the
// media_json column with IF EXISTS.
func TestDownMediaMigrationDropsColumn(t *testing.T) {
down := readMediaDownMigration(t)
upper := strings.ToUpper(down)
if !strings.Contains(upper, "DROP COLUMN IF EXISTS MEDIA_JSON") {
t.Error("down migration must use DROP COLUMN IF EXISTS media_json")
}
}
// TestUpMigrationHasNoReservedWordMedia ensures the column is named media_json
// not a bare "media" which could be a reserved word in future PostgreSQL.
func TestUpMigrationHasNoReservedWordMedia(t *testing.T) {
up := readMediaUpMigration(t)
// The bare word "media" as a column name (not media_json) should be avoided
bare := regexp.MustCompile(`(?i)\bMEDIA\s+JSONB\b`)
if bare.MatchString(up) {
t.Error("up migration must not use bare 'media' column name; use media_json")
}
if !regexp.MustCompile(`(?i)\bMEDIA_JSON\s+JSONB\b`).MatchString(up) {
t.Error("up migration must use media_json column name")
}
}
+20
View File
@@ -0,0 +1,20 @@
[Unit]
Description=DobotAI external DingTalk and WeKnora gateway
Documentation=file:///home/zheromiku/dobotai-platform/README.md
[Service]
Type=simple
WorkingDirectory=/home/zheromiku/dobotai-platform
ExecStart=/usr/bin/python3 /home/zheromiku/dobotai-platform/scripts/run-local.py
Restart=on-failure
RestartSec=5s
TimeoutStopSec=20s
KillMode=control-group
NoNewPrivileges=true
PrivateTmp=true
UMask=0077
StandardOutput=journal
StandardError=journal
[Install]
WantedBy=default.target
+1
View File
@@ -56,6 +56,7 @@ No WeKnora source patch is allowed as a workaround.
- `internal/qa`: business orchestration and terminal-state ownership.
- `internal/session`: external-to-WeKnora session policy.
- `internal/store/postgres`: DobotAI business persistence only.
- `internal/channels/dingtalk`: DingTalk Stream ingress (official SDK), text-only robot callbacks, fail-closed session webhook replies (`https`, `*.dingtalk.com`, no redirects). Wired in `cmd/dobotai`; enabled only when `DINGTALK_CLIENT_ID`, `DINGTALK_CLIENT_SECRET`, and `DOBOTAI_TENANT_KEY` are all set. Group messages require an @-mention; direct chats map to one long-lived session per user, groups to one shared session per group. Images, OpenAPI fallback, and card replies are not implemented yet.
- future `channels/*`: platform callbacks and outbound replies.
- future `content-sync/*`: DingTalk KB, NAS, and CMS synchronization.
- model gateway: token accounting, routing, quotas, circuit breaking, and provider observability.
+6 -1
View File
@@ -2,9 +2,14 @@ module gitea.zheromiku.top/Weknora/dobotai-platform
go 1.25.0
require github.com/jackc/pgx/v5 v5.9.2
require (
github.com/jackc/pgx/v5 v5.9.2
github.com/open-dingtalk/dingtalk-stream-sdk-go v0.9.1
)
require (
github.com/google/uuid v1.3.0 // indirect
github.com/gorilla/websocket v1.5.0 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
+13
View File
@@ -1,4 +1,10 @@
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
@@ -7,13 +13,20 @@ github.com/jackc/pgx/v5 v5.9.2 h1:3ZhOzMWnR4yJ+RW1XImIPsD1aNSz4T4fyP7zlQb56hw=
github.com/jackc/pgx/v5 v5.9.2/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
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/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+351
View File
@@ -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 = &copyClient
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
}
+91
View File
@@ -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
}
@@ -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:
}
}
File diff suppressed because it is too large Load Diff
+435
View File
@@ -0,0 +1,435 @@
package dingtalk
import (
"context"
"errors"
"fmt"
"log"
"strings"
"time"
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/core"
"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
Msgtype string
MsgID string
SenderNick string
SenderStaffID string
SenderID string
IsInAtList bool
SessionWebhook string
Text string
DownloadCode string
}
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
}
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
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")
}
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,
card: opts.CardSender,
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")
}
req := core.QARequest{
TenantKey: h.cfg.TenantKey,
Channel: h.cfg.Channel,
ExternalUserID: externalUserID,
ExternalMessageID: strings.TrimSpace(cb.MsgID),
SenderName: cb.SenderNick,
}
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
}
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:
if strings.TrimSpace(cb.DownloadCode) == "" {
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)
}
image, err := h.downloader.Download(ctx, strings.TrimSpace(cb.DownloadCode))
if err != nil {
log.Printf("DingTalk image preparation failed: stage=%s", imageFailureStage(err))
return h.sendReply(ctx, webhookURL, imageErrorReply)
}
req.Query = strings.TrimSpace(cb.Text)
if req.Query == "" {
req.Query = imageQuery
}
req.Images = []core.ImageInput{image}
default:
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 {
return replyErr
}
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 {
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
}
File diff suppressed because it is too large Load Diff
+342
View File
@@ -0,0 +1,342 @@
package dingtalk
import (
"bytes"
"context"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"image"
_ "image/gif"
_ "image/jpeg"
_ "image/png"
"io"
"net"
"net/http"
"net/netip"
"net/url"
"strings"
"sync"
"time"
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/core"
)
const (
oauthTokenURL = "https://api.dingtalk.com/v1.0/oauth2/accessToken"
messageFileDownloadURL = "https://api.dingtalk.com/v1.0/robot/messageFiles/download"
maxAPIResponseBytes = 1 << 20
maxImageBytes = 8 << 20
maxImagePixels = 40_000_000
)
var blockedDownloadRanges = []netip.Prefix{
netip.MustParsePrefix("100.64.0.0/10"),
netip.MustParsePrefix("192.0.0.0/24"),
netip.MustParsePrefix("192.0.2.0/24"),
netip.MustParsePrefix("198.18.0.0/15"),
netip.MustParsePrefix("198.51.100.0/24"),
netip.MustParsePrefix("203.0.113.0/24"),
netip.MustParsePrefix("2001:db8::/32"),
}
type DingTalkImageDownloader struct {
clientID string
clientSecret string
tokenURL string
fileURL string
apiClient *http.Client
downloadHTTP *http.Client
allowTestURL bool
mu sync.Mutex
token string
tokenTill time.Time
}
func NewImageDownloader(clientID, clientSecret string, client *http.Client) (*DingTalkImageDownloader, error) {
return newImageDownloader(clientID, clientSecret, client, oauthTokenURL, messageFileDownloadURL, false)
}
func newImageDownloaderForTest(clientID, clientSecret string, client *http.Client, tokenURL, fileURL string) (*DingTalkImageDownloader, error) {
return newImageDownloader(clientID, clientSecret, client, tokenURL, fileURL, true)
}
func newImageDownloader(clientID, clientSecret string, client *http.Client, tokenURL, fileURL string, allowTest bool) (*DingTalkImageDownloader, error) {
clientID = strings.TrimSpace(clientID)
clientSecret = strings.TrimSpace(clientSecret)
if clientID == "" {
return nil, errors.New("dingtalk image downloader: clientID is required")
}
if clientSecret == "" {
return nil, errors.New("dingtalk image downloader: clientSecret is required")
}
base := &http.Client{Timeout: 30 * time.Second}
if client != nil {
copyClient := *client
base = &copyClient
if base.Timeout <= 0 {
base.Timeout = 30 * time.Second
}
}
apiClient := *base
apiClient.CheckRedirect = func(*http.Request, []*http.Request) error {
return errors.New("dingtalk API redirect refused")
}
downloadClient := *base
if !allowTest {
transport := http.DefaultTransport.(*http.Transport).Clone()
transport.Proxy = nil
transport.DialContext = safeDialContext
apiClient.Transport = transport
downloadClient.Transport = transport.Clone()
}
d := &DingTalkImageDownloader{
clientID: clientID, clientSecret: clientSecret,
tokenURL: tokenURL, fileURL: fileURL,
apiClient: &apiClient, downloadHTTP: &downloadClient, allowTestURL: allowTest,
}
d.downloadHTTP.CheckRedirect = func(req *http.Request, via []*http.Request) error {
if len(via) >= 3 {
return errors.New("dingtalk image redirect limit exceeded")
}
req.Header = make(http.Header)
if !d.allowTestURL {
if err := validateDownloadURL(req.URL); err != nil {
return err
}
}
return nil
}
return d, nil
}
func (d *DingTalkImageDownloader) Download(ctx context.Context, downloadCode string) (core.ImageInput, error) {
downloadCode = strings.TrimSpace(downloadCode)
if downloadCode == "" {
return core.ImageInput{}, errors.New("dingtalk image download: downloadCode is required")
}
token, err := d.accessToken(ctx)
if err != nil {
return core.ImageInput{}, err
}
payload, err := d.postJSON(ctx, d.fileURL, map[string]string{
"downloadCode": downloadCode,
"robotCode": d.clientID,
}, token)
if err != nil {
return core.ImageInput{}, err
}
var fileResponse struct {
DownloadURL string `json:"downloadUrl"`
}
if json.Unmarshal(payload, &fileResponse) != nil || strings.TrimSpace(fileResponse.DownloadURL) == "" {
return core.ImageInput{}, errors.New("dingtalk image download: invalid message file response")
}
downloadURL := strings.TrimSpace(fileResponse.DownloadURL)
if !d.allowTestURL {
downloadURL, err = normalizeInitialDownloadURL(downloadURL)
if err != nil {
return core.ImageInput{}, err
}
parsed, parseErr := url.Parse(downloadURL)
if parseErr != nil || validateDownloadURL(parsed) != nil {
return core.ImageInput{}, errors.New("dingtalk image download: unsafe download URL")
}
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
if err != nil {
return core.ImageInput{}, errors.New("dingtalk image download: invalid download request")
}
resp, err := d.downloadHTTP.Do(req)
if err != nil {
if ctx.Err() != nil {
return core.ImageInput{}, ctx.Err()
}
return core.ImageInput{}, errors.New("dingtalk image download: request failed")
}
defer resp.Body.Close()
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
return core.ImageInput{}, fmt.Errorf("dingtalk image download: HTTP %d", resp.StatusCode)
}
if resp.ContentLength > maxImageBytes {
return core.ImageInput{}, errors.New("dingtalk image download: image exceeds size limit")
}
data, err := io.ReadAll(io.LimitReader(resp.Body, maxImageBytes+1))
if err != nil {
return core.ImageInput{}, errors.New("dingtalk image download: read failed")
}
if len(data) > maxImageBytes {
return core.ImageInput{}, errors.New("dingtalk image download: image exceeds size limit")
}
return validateImageBytes(data)
}
func (d *DingTalkImageDownloader) accessToken(ctx context.Context) (string, error) {
d.mu.Lock()
defer d.mu.Unlock()
if d.token != "" && time.Now().Before(d.tokenTill) {
return d.token, nil
}
payload, err := d.postJSON(ctx, d.tokenURL, map[string]string{
"appKey": d.clientID, "appSecret": d.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 image download: 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
}
d.token = response.AccessToken
d.tokenTill = time.Now().Add(refreshAfter)
return d.token, nil
}
func (d *DingTalkImageDownloader) postJSON(ctx context.Context, endpoint string, value any, token string) ([]byte, error) {
body, err := json.Marshal(value)
if err != nil {
return nil, errors.New("dingtalk image download: encode API request failed")
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(body))
if err != nil {
return nil, errors.New("dingtalk image download: create API request failed")
}
req.Header.Set("Content-Type", "application/json")
if token != "" {
req.Header.Set("x-acs-dingtalk-access-token", token)
}
resp, err := d.apiClient.Do(req)
if err != nil {
if ctx.Err() != nil {
return nil, ctx.Err()
}
return nil, errors.New("dingtalk image download: API request failed")
}
defer resp.Body.Close()
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
return nil, fmt.Errorf("dingtalk image download: API HTTP %d", resp.StatusCode)
}
return readBoundedAPIResponse(resp)
}
func readBoundedAPIResponse(resp *http.Response) ([]byte, error) {
if resp.ContentLength > maxAPIResponseBytes {
return nil, errors.New("dingtalk image download: API response exceeds size limit")
}
payload, err := io.ReadAll(io.LimitReader(resp.Body, maxAPIResponseBytes+1))
if err != nil {
return nil, errors.New("dingtalk image download: API response read failed")
}
if len(payload) > maxAPIResponseBytes {
return nil, errors.New("dingtalk image download: API response exceeds size limit")
}
return payload, nil
}
func validateImageBytes(data []byte) (core.ImageInput, error) {
if len(data) == 0 || len(data) > maxImageBytes {
return core.ImageInput{}, errors.New("dingtalk image download: invalid image size")
}
mime := http.DetectContentType(data)
expectedFormat := map[string]string{
"image/png": "png", "image/jpeg": "jpeg", "image/gif": "gif",
}[mime]
if expectedFormat == "" {
return core.ImageInput{}, errors.New("dingtalk image download: unsupported image format")
}
config, format, err := image.DecodeConfig(bytes.NewReader(data))
if err != nil || format != expectedFormat || config.Width <= 0 || config.Height <= 0 {
return core.ImageInput{}, errors.New("dingtalk image download: invalid image data")
}
if int64(config.Width)*int64(config.Height) > maxImagePixels {
return core.ImageInput{}, errors.New("dingtalk image download: image dimensions exceed limit")
}
return core.ImageInput{
DataURI: "data:" + mime + ";base64," + base64.StdEncoding.EncodeToString(data),
MIMEType: mime, SizeBytes: int64(len(data)), Width: config.Width, Height: config.Height,
}, nil
}
func normalizeInitialDownloadURL(raw string) (string, error) {
parsed, err := url.Parse(strings.TrimSpace(raw))
if err != nil || parsed.Hostname() == "" || parsed.User != nil {
return "", errors.New("dingtalk image download: unsafe download URL")
}
switch parsed.Scheme {
case "http":
parsed.Scheme = "https"
case "https":
default:
return "", errors.New("dingtalk image download: unsafe download URL")
}
return parsed.String(), nil
}
func validateDownloadURL(parsed *url.URL) error {
if parsed == nil || parsed.Scheme != "https" || parsed.Hostname() == "" || parsed.User != nil {
return errors.New("dingtalk image download: unsafe download URL")
}
return nil
}
func safeDialContext(ctx context.Context, network, address string) (net.Conn, error) {
host, port, err := net.SplitHostPort(address)
if err != nil {
return nil, errors.New("dingtalk image download: invalid destination")
}
var ips []net.IP
if literal := net.ParseIP(host); literal != nil {
ips = []net.IP{literal}
} else {
resolved, resolveErr := net.DefaultResolver.LookupIPAddr(ctx, host)
if resolveErr != nil || len(resolved) == 0 {
return nil, errors.New("dingtalk image download: destination resolution failed")
}
for _, item := range resolved {
ips = append(ips, item.IP)
}
}
for _, ip := range ips {
if !isSafeDownloadIP(ip) {
return nil, errors.New("dingtalk image download: destination is not public")
}
}
dialer := &net.Dialer{Timeout: 15 * time.Second, KeepAlive: 30 * time.Second}
for _, ip := range ips {
conn, dialErr := dialer.DialContext(ctx, network, net.JoinHostPort(ip.String(), port))
if dialErr == nil {
return conn, nil
}
}
return nil, errors.New("dingtalk image download: destination connection failed")
}
func isSafeDownloadIP(ip net.IP) bool {
if ip == nil || !ip.IsGlobalUnicast() || ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() || ip.IsMulticast() || ip.IsUnspecified() {
return false
}
addr, ok := netip.AddrFromSlice(ip)
if !ok {
return false
}
addr = addr.Unmap()
for _, prefix := range blockedDownloadRanges {
if prefix.Contains(addr) {
return false
}
}
return true
}
+226
View File
@@ -0,0 +1,226 @@
package dingtalk
import (
"bytes"
"context"
"encoding/json"
"image"
"image/color"
"image/png"
"io"
"net"
"net/http"
"net/http/httptest"
"strings"
"testing"
)
func tinyPNG(t *testing.T) []byte {
t.Helper()
img := image.NewRGBA(image.Rect(0, 0, 2, 3))
for y := 0; y < 3; y++ {
for x := 0; x < 2; x++ {
img.Set(x, y, color.RGBA{R: 255, A: 255})
}
}
var out bytes.Buffer
if err := png.Encode(&out, img); err != nil {
t.Fatal(err)
}
return out.Bytes()
}
func TestNewImageDownloaderMissingCredentials(t *testing.T) {
for _, tc := range []struct{ id, secret string }{{"", "s"}, {"id", ""}, {" ", "s"}, {"id", " "}} {
if got, err := NewImageDownloader(tc.id, tc.secret, nil); err == nil || got != nil {
t.Fatalf("NewImageDownloader(%q,%q)=%v,%v", tc.id, tc.secret, got, err)
}
}
}
func TestDownloadEmptyCodeReturnsError(t *testing.T) {
d, err := NewImageDownloader("id", "secret", nil)
if err != nil {
t.Fatal(err)
}
for _, code := range []string{"", " "} {
if _, err := d.Download(context.Background(), code); err == nil {
t.Fatalf("Download(%q) should fail", code)
}
}
}
func TestImageDownloaderTwoHopAndTokenCache(t *testing.T) {
pngBytes := tinyPNG(t)
var tokenCalls, fileCalls int
var server *httptest.Server
server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path {
case "/token":
tokenCalls++
var body map[string]string
_ = json.NewDecoder(r.Body).Decode(&body)
if body["appKey"] != "client-id" || body["appSecret"] != "client-secret" {
t.Errorf("oauth body=%v", body)
}
if body["clientId"] != "" || body["clientSecret"] != "" {
t.Errorf("legacy OAuth field names must not be sent: %v", body)
}
_ = json.NewEncoder(w).Encode(map[string]any{"accessToken": "access-token", "expireIn": 3600})
case "/file":
fileCalls++
if r.Header.Get("x-acs-dingtalk-access-token") != "access-token" {
t.Errorf("token header missing")
}
var body map[string]string
_ = json.NewDecoder(r.Body).Decode(&body)
if body["downloadCode"] != "download-code" || body["robotCode"] != "client-id" {
t.Errorf("file body=%v", body)
}
_ = json.NewEncoder(w).Encode(map[string]string{"downloadUrl": server.URL + "/image?signature=secret"})
case "/image":
w.Header().Set("Content-Type", "text/plain") // deliberately untrusted
_, _ = w.Write(pngBytes)
default:
http.NotFound(w, r)
}
}))
defer server.Close()
d, err := newImageDownloaderForTest("client-id", "client-secret", server.Client(), server.URL+"/token", server.URL+"/file")
if err != nil {
t.Fatal(err)
}
for i := 0; i < 2; i++ {
got, err := d.Download(context.Background(), "download-code")
if err != nil {
t.Fatalf("Download: %v", err)
}
if got.MIMEType != "image/png" || got.Width != 2 || got.Height != 3 || got.SizeBytes != int64(len(pngBytes)) || !strings.HasPrefix(got.DataURI, "data:image/png;base64,") {
t.Fatalf("image=%+v", got)
}
}
if tokenCalls != 1 || fileCalls != 2 {
t.Fatalf("tokenCalls=%d fileCalls=%d", tokenCalls, fileCalls)
}
}
func TestImageDownloaderRejectsRedirectWithoutLeakingToken(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()
d, err := newImageDownloaderForTest("id", "secret", source.Client(), source.URL+"/token", source.URL+"/file")
if err != nil {
t.Fatal(err)
}
if _, err := d.Download(context.Background(), "code"); err == nil {
t.Fatal("API redirect should fail")
}
if leaked != "" {
t.Fatalf("token leaked across redirect: %q", leaked)
}
}
func TestImageDownloaderRejectsInvalidImageAndOversize(t *testing.T) {
tests := []struct {
name string
contentType string
body []byte
length int64
}{
{name: "html disguised", contentType: "image/png", body: []byte("<html>not image</html>")},
{name: "oversized content length", contentType: "image/png", body: []byte("x"), length: maxImageBytes + 1},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var server *httptest.Server
server = 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": "token", "expireIn": 3600})
case "/file":
_ = json.NewEncoder(w).Encode(map[string]string{"downloadUrl": server.URL + "/image?q=signed-secret"})
case "/image":
w.Header().Set("Content-Type", tt.contentType)
if tt.length > 0 {
w.Header().Set("Content-Length", "8388609")
}
_, _ = w.Write(tt.body)
}
}))
defer server.Close()
d, _ := newImageDownloaderForTest("id", "secret", server.Client(), server.URL+"/token", server.URL+"/file")
_, err := d.Download(context.Background(), "download-secret")
if err == nil {
t.Fatal("expected rejection")
}
for _, secret := range []string{"download-secret", "signed-secret", "token"} {
if strings.Contains(err.Error(), secret) {
t.Fatalf("error leaked %q: %v", secret, err)
}
}
})
}
}
func TestNormalizeInitialDownloadURL(t *testing.T) {
got, err := normalizeInitialDownloadURL("http://example.com/media/path?signature=secret")
if err != nil {
t.Fatalf("normalize: %v", err)
}
if got != "https://example.com/media/path?signature=secret" {
t.Fatalf("normalized=%q", got)
}
for _, raw := range []string{"ftp://example.com/a", "http://user:pass@example.com/a", "not-a-url"} {
if _, err := normalizeInitialDownloadURL(raw); err == nil {
t.Fatalf("%q should fail", raw)
}
}
}
func TestSafeDownloadIPRejectsNonPublicRanges(t *testing.T) {
for _, raw := range []string{"127.0.0.1", "10.0.0.1", "192.168.1.1", "169.254.1.1", "100.64.0.1", "192.0.2.1", "198.18.0.1", "203.0.113.1", "::1", "fc00::1", "2001:db8::1"} {
if isSafeDownloadIP(net.ParseIP(raw)) {
t.Errorf("%s must be rejected", raw)
}
}
for _, raw := range []string{"8.8.8.8", "1.1.1.1", "2606:4700:4700::1111"} {
if !isSafeDownloadIP(net.ParseIP(raw)) {
t.Errorf("%s should be public", raw)
}
}
}
func TestReadImageRejectsPixelLimit(t *testing.T) {
// A PNG only needs a valid signature+IHDR for DecodeConfig. Patch a valid
// tiny PNG's dimensions and let CRC become invalid: DecodeConfig must reject
// it or the pixel policy must reject it, either outcome is fail closed.
data := tinyPNG(t)
if len(data) < 24 {
t.Fatal("short png fixture")
}
copy(data[16:20], []byte{0, 0, 0x27, 0x10}) // 10000
copy(data[20:24], []byte{0, 0, 0x13, 0x88}) // 5000 = 50M
if _, err := validateImageBytes(data); err == nil {
t.Fatal("50M-pixel image must fail")
}
}
func TestBoundedAPIResponse(t *testing.T) {
resp := &http.Response{Body: io.NopCloser(io.LimitReader(strings.NewReader(strings.Repeat("x", maxAPIResponseBytes+1)), maxAPIResponseBytes+1))}
if _, err := readBoundedAPIResponse(resp); err == nil {
t.Fatal("oversized API response must fail")
}
}
+284
View File
@@ -0,0 +1,284 @@
package dingtalk
import (
"context"
"encoding/json"
"errors"
"fmt"
"strings"
"github.com/open-dingtalk/dingtalk-stream-sdk-go/chatbot"
dtsdk "github.com/open-dingtalk/dingtalk-stream-sdk-go/client"
)
// StreamConfig holds the DingTalk Stream mode credentials plus the tenant
// this ingress serves. An entirely empty config means the DingTalk channel
// is disabled; a partially filled config is a fatal misconfiguration.
type StreamConfig struct {
ClientID string
ClientSecret string
TenantKey string
}
// Enabled reports whether all three values are present. Callers must run
// Validate first: Enabled on a partially filled config returns false.
func (c StreamConfig) Enabled() bool {
return strings.TrimSpace(c.ClientID) != "" &&
strings.TrimSpace(c.ClientSecret) != "" &&
strings.TrimSpace(c.TenantKey) != ""
}
// Validate enforces the all-or-nothing rule: either every field is blank
// (channel disabled, no error) or every field is set (channel enabled).
// Any mix is an error so misconfigured deployments fail fast at startup.
func (c StreamConfig) Validate() error {
id := strings.TrimSpace(c.ClientID) != ""
secret := strings.TrimSpace(c.ClientSecret) != ""
tenant := strings.TrimSpace(c.TenantKey) != ""
if !id && !secret && !tenant {
return nil
}
if id && secret && tenant {
return nil
}
missing := make([]string, 0, 3)
if !id {
missing = append(missing, "client id")
}
if !secret {
missing = append(missing, "client secret")
}
if !tenant {
missing = append(missing, "tenant key")
}
return fmt.Errorf("dingtalk stream config is partial: missing %s", strings.Join(missing, ", "))
}
// BotCallbackFromSDK converts the official SDK callback model into the
// channel-internal BotCallback. Msgtype is normalized (trimmed, lowercased).
// For picture messages the downloadCode is extracted from the SDK Content
// field (json marshal/unmarshal round-trip); malformed or missing codes
// produce an empty DownloadCode but never downgrade the Msgtype.
// For richText messages the Content field is parsed for text+picture items;
// if a picture item is present Msgtype becomes "picture", otherwise text-only
// richText is promoted to "text". Malformed/empty richText keeps "richtext".
func BotCallbackFromSDK(data *chatbot.BotCallbackDataModel) (BotCallback, error) {
if data == nil {
return BotCallback{}, errors.New("dingtalk stream: callback data is nil")
}
msgtype := strings.ToLower(strings.TrimSpace(data.Msgtype))
cb := BotCallback{
ConversationType: data.ConversationType,
ConversationID: data.ConversationId,
Msgtype: msgtype,
MsgID: data.MsgId,
SenderNick: data.SenderNick,
SenderStaffID: data.SenderStaffId,
SenderID: data.SenderId,
IsInAtList: data.IsInAtList,
SessionWebhook: data.SessionWebhook,
Text: data.Text.Content,
}
if msgtype == "richtext" {
rtMsgtype, rtText, rtCode := parseRichText(data.Content)
cb.Msgtype = rtMsgtype
cb.Text = rtText
cb.DownloadCode = rtCode
return cb, nil
}
if msgtype == "picture" {
cb.DownloadCode = extractDownloadCode(data.Content)
}
return cb, nil
}
// parseRichText parses the SDK Content field for richText messages.
// It handles three content shapes:
// 1. Direct object: {"richText": [...]}
// 2. Bare richText array (compatibility)
// 3. Nested envelope: {"content":{"richText":[...]}}
//
// Picture items are identified by a "type" field (case-insensitive trimmed)
// equal to "picture". The first non-empty downloadCode is used; subsequent
// picture items are ignored. Text items are joined with newlines.
//
// Returns: (msgtype, text, downloadCode). Msgtype is "picture" if any picture
// item exists, "text" if only text items, "richtext" if malformed/empty.
func parseRichText(raw interface{}) (string, string, string) {
items := extractRichTextItems(raw)
if len(items) == 0 {
return "richtext", "", ""
}
var textParts []string
var downloadCode string
hasPicture := false
for _, item := range items {
itemType := strings.ToLower(strings.TrimSpace(item.Type))
if itemType == "picture" {
hasPicture = true
if downloadCode == "" {
code := strings.TrimSpace(item.DownloadCode)
if code != "" {
downloadCode = code
}
}
continue
}
txt := strings.TrimSpace(item.Text)
if txt != "" {
textParts = append(textParts, txt)
}
}
text := strings.Join(textParts, "\n")
if hasPicture {
return "picture", text, downloadCode
}
if text != "" {
return "text", text, ""
}
return "richtext", "", ""
}
// richTextItem is a single item in a richText array.
type richTextItem struct {
Type string `json:"type"`
DownloadCode string `json:"downloadCode"`
Text string `json:"text"`
}
// extractRichTextItems extracts the richText item array from the raw Content
// field. It handles direct object, bare-array, and nested-envelope shapes.
func extractRichTextItems(raw interface{}) []richTextItem {
if raw == nil {
return nil
}
b, err := json.Marshal(raw)
if err != nil {
return nil
}
// Real DingTalk SDK shape: Content is already {"richText": [...]}.
var object struct {
RichText []richTextItem `json:"richText"`
}
if json.Unmarshal(b, &object) == nil && len(object.RichText) > 0 {
return object.RichText
}
// Accept a bare array for transport compatibility.
var direct []richTextItem
if json.Unmarshal(b, &direct) == nil && len(direct) > 0 {
return direct
}
// Accept a preserved callback envelope: {"content":{"richText":[...]}}.
var nested struct {
Content struct {
RichText []richTextItem `json:"richText"`
} `json:"content"`
}
if json.Unmarshal(b, &nested) == nil && len(nested.Content.RichText) > 0 {
return nested.Content.RichText
}
return nil
}
// extractDownloadCode attempts to pull content.downloadCode from the SDK
// Content field (interface{}) via a json marshal/unmarshal round-trip. It
// never panics on malformed input and returns an empty string for any
// extraction failure.
func extractDownloadCode(raw interface{}) string {
if raw == nil {
return ""
}
b, err := json.Marshal(raw)
if err != nil {
return ""
}
var direct struct {
DownloadCode string `json:"downloadCode"`
}
if json.Unmarshal(b, &direct) == nil && strings.TrimSpace(direct.DownloadCode) != "" {
return strings.TrimSpace(direct.DownloadCode)
}
// Keep compatibility with transports that preserve the callback envelope.
var nested struct {
Content struct {
DownloadCode string `json:"downloadCode"`
} `json:"content"`
}
if err := json.Unmarshal(b, &nested); err != nil {
return ""
}
return strings.TrimSpace(nested.Content.DownloadCode)
}
// StreamClient wraps the official DingTalk Stream SDK client. It wires
// robot callbacks into the existing Handler synchronously (no goroutines,
// no queue). The SDK default auto-reconnect stays enabled while running;
// Close disables it so the connection stays closed.
type StreamClient struct {
inner *dtsdk.StreamClient
}
// NewStreamClient validates the config, builds the SDK client with the app
// credential and registers the chatbot callback router. The handler is
// invoked synchronously from the SDK callback; its return value only
// acknowledges the frame, replies always go through the session webhook.
func NewStreamClient(config StreamConfig, handler *Handler) (*StreamClient, error) {
if err := config.Validate(); err != nil {
return nil, err
}
if !config.Enabled() {
return nil, errors.New("dingtalk stream: config is empty, client not created")
}
if handler == nil {
return nil, errors.New("dingtalk stream: handler is required")
}
cred := dtsdk.NewAppCredentialConfig(strings.TrimSpace(config.ClientID), strings.TrimSpace(config.ClientSecret))
// Keep the SDK default AutoReconnect=true so runtime disconnects
// reconnect automatically; Close flips it off before closing.
inner := dtsdk.NewStreamClient(
dtsdk.WithAppCredential(cred),
)
inner.RegisterChatBotCallbackRouter(func(ctx context.Context, data *chatbot.BotCallbackDataModel) ([]byte, error) {
cb, err := BotCallbackFromSDK(data)
if err != nil {
return nil, err
}
if err := handler.Handle(ctx, cb); err != nil {
return nil, err
}
return nil, nil
})
return &StreamClient{inner: inner}, nil
}
// Start connects to DingTalk Stream and spawns the SDK read loop. Any
// connection or credential error is propagated to the caller.
func (c *StreamClient) Start(ctx context.Context) error {
if c == nil || c.inner == nil {
return errors.New("dingtalk stream: client is nil")
}
if err := c.inner.Start(ctx); err != nil {
return fmt.Errorf("dingtalk stream start: %w", err)
}
return nil
}
// Close tears down the websocket. Auto-reconnect is disabled before the
// underlying Close so the SDK processLoop cannot reconnect afterwards.
func (c *StreamClient) Close() {
if c == nil || c.inner == nil {
return
}
c.inner.AutoReconnect = false
c.inner.Close()
}
+588
View File
@@ -0,0 +1,588 @@
package dingtalk
import (
"strings"
"testing"
"github.com/open-dingtalk/dingtalk-stream-sdk-go/chatbot"
)
func TestStreamConfigValidate(t *testing.T) {
t.Parallel()
tests := []struct {
name string
cfg StreamConfig
wantErr bool
wantOn bool
errSubstr string
}{
{
name: "all empty is disabled without error",
cfg: StreamConfig{},
wantErr: false,
wantOn: false,
},
{
name: "whitespace only is disabled without error",
cfg: StreamConfig{ClientID: " ", ClientSecret: "\t", TenantKey: " "},
wantErr: false,
wantOn: false,
},
{
name: "client id only is an error",
cfg: StreamConfig{ClientID: "id"},
wantErr: true,
errSubstr: "client secret",
},
{
name: "client secret only is an error",
cfg: StreamConfig{ClientSecret: "secret"},
wantErr: true,
errSubstr: "client id",
},
{
name: "credentials without tenant key is an error",
cfg: StreamConfig{ClientID: "id", ClientSecret: "secret"},
wantErr: true,
errSubstr: "tenant key",
},
{
name: "tenant key without credentials is an error",
cfg: StreamConfig{TenantKey: "acme"},
wantErr: true,
errSubstr: "client id",
},
{
name: "all three present is enabled",
cfg: StreamConfig{ClientID: "id", ClientSecret: "secret", TenantKey: "acme"},
wantErr: false,
wantOn: true,
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
err := tt.cfg.Validate()
if tt.wantErr && err == nil {
t.Fatalf("Validate() = nil, want error containing %q", tt.errSubstr)
}
if !tt.wantErr && err != nil {
t.Fatalf("Validate() = %v, want nil", err)
}
if tt.wantErr && tt.errSubstr != "" && !strings.Contains(err.Error(), tt.errSubstr) {
t.Fatalf("Validate() error = %q, want substring %q", err.Error(), tt.errSubstr)
}
if got := tt.cfg.Enabled(); got != tt.wantOn {
t.Fatalf("Enabled() = %v, want %v", got, tt.wantOn)
}
})
}
}
func TestBotCallbackFromSDK(t *testing.T) {
t.Parallel()
t.Run("nil data returns error", func(t *testing.T) {
t.Parallel()
if _, err := BotCallbackFromSDK(nil); err == nil {
t.Fatal("BotCallbackFromSDK(nil) = nil error, want error")
}
})
t.Run("maps every field one to one", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "2",
ConversationId: "cid123",
Msgtype: "text",
MsgId: "msg-9",
SenderNick: "Alice",
SenderStaffId: "staff-1",
SenderId: "sender-1",
IsInAtList: true,
SessionWebhook: "https://oapi.dingtalk.com/robot/sendBySession?session=abc",
Text: chatbot.BotCallbackDataTextModel{Content: " 你好 "},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v, want nil", err)
}
want := BotCallback{
ConversationType: "2",
ConversationID: "cid123",
Msgtype: "text",
MsgID: "msg-9",
SenderNick: "Alice",
SenderStaffID: "staff-1",
SenderID: "sender-1",
IsInAtList: true,
SessionWebhook: "https://oapi.dingtalk.com/robot/sendBySession?session=abc",
Text: " 你好 ",
}
if cb != want {
t.Fatalf("BotCallbackFromSDK() = %+v, want %+v", cb, want)
}
})
t.Run("text content is not trimmed by conversion", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "text",
MsgId: "m",
Text: chatbot.BotCallbackDataTextModel{Content: ""},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Text != "" {
t.Fatalf("Text = %q, want empty", cb.Text)
}
})
}
func TestBotCallbackFromSDKPicture(t *testing.T) {
t.Parallel()
t.Run("extracts downloadCode from picture content", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "picture",
MsgId: "msg-pic-1",
Content: map[string]interface{}{
"downloadCode": " abc123 ",
},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "picture" {
t.Fatalf("Msgtype = %q, want picture", cb.Msgtype)
}
if cb.DownloadCode != "abc123" {
t.Fatalf("DownloadCode = %q, want trimmed abc123", cb.DownloadCode)
}
if cb.Text != "" {
t.Fatalf("Text = %q, want empty for picture", cb.Text)
}
})
t.Run("malformed content keeps picture with empty downloadCode", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "picture",
MsgId: "msg-pic-2",
Content: "not-a-map",
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "picture" {
t.Fatalf("Msgtype = %q, want picture (never downgrade)", cb.Msgtype)
}
if cb.DownloadCode != "" {
t.Fatalf("DownloadCode = %q, want empty", cb.DownloadCode)
}
})
t.Run("missing downloadCode keeps picture", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "picture",
MsgId: "msg-pic-3",
Content: map[string]interface{}{
"content": map[string]interface{}{},
},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "picture" {
t.Fatalf("Msgtype = %q, want picture", cb.Msgtype)
}
if cb.DownloadCode != "" {
t.Fatalf("DownloadCode = %q, want empty", cb.DownloadCode)
}
})
t.Run("text regression: Msgtype normalized", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: " TEXT ",
MsgId: "msg-t-1",
Text: chatbot.BotCallbackDataTextModel{Content: "hello"},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "text" {
t.Fatalf("Msgtype = %q, want normalized text", cb.Msgtype)
}
if cb.Text != "hello" {
t.Fatalf("Text = %q, want hello", cb.Text)
}
})
t.Run("nil content keeps picture", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "picture",
MsgId: "msg-pic-4",
Content: nil,
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "picture" {
t.Fatalf("Msgtype = %q, want picture", cb.Msgtype)
}
if cb.DownloadCode != "" {
t.Fatalf("DownloadCode = %q, want empty", cb.DownloadCode)
}
})
}
func mustTestHandler(t *testing.T) *Handler {
t.Helper()
return newTestHandler(t, &fakeQA{}, &fakeReply{})
}
func TestBotCallbackFromSDKRichText(t *testing.T) {
t.Parallel()
t.Run("direct Content richText text+picture", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "richText",
MsgId: "msg-rt-1",
Content: map[string]interface{}{
"richText": []interface{}{
map[string]interface{}{"text": " 问题描述 "},
map[string]interface{}{"type": "picture", "downloadCode": " code-abc "},
},
},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "picture" {
t.Fatalf("Msgtype = %q, want picture", cb.Msgtype)
}
if cb.DownloadCode != "code-abc" {
t.Fatalf("DownloadCode = %q, want code-abc", cb.DownloadCode)
}
if cb.Text != "问题描述" {
t.Fatalf("Text = %q, want 问题描述 (trimmed text segments joined)", cb.Text)
}
})
t.Run("nested content envelope richText", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "richText",
MsgId: "msg-rt-2",
Content: map[string]interface{}{
"content": map[string]interface{}{
"richText": []interface{}{
map[string]interface{}{"text": "描述"},
map[string]interface{}{"type": "picture", "downloadCode": "code-xyz"},
},
},
},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "picture" {
t.Fatalf("Msgtype = %q, want picture", cb.Msgtype)
}
if cb.DownloadCode != "code-xyz" {
t.Fatalf("DownloadCode = %q, want code-xyz", cb.DownloadCode)
}
if cb.Text != "描述" {
t.Fatalf("Text = %q, want 描述", cb.Text)
}
})
t.Run("multi text segments preserve order", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "richText",
MsgId: "msg-rt-3",
Content: []interface{}{
map[string]interface{}{"text": "第一段"},
map[string]interface{}{"text": " 第二段 "},
map[string]interface{}{"type": "picture", "downloadCode": "code-multi"},
},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "picture" {
t.Fatalf("Msgtype = %q, want picture", cb.Msgtype)
}
if cb.Text != "第一段\n第二段" {
t.Fatalf("Text = %q, want joined with newline", cb.Text)
}
})
t.Run("first non-empty downloadCode used, subsequent ignored", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "richText",
MsgId: "msg-rt-4",
Content: []interface{}{
map[string]interface{}{"type": "picture", "downloadCode": " code-first "},
map[string]interface{}{"type": "picture", "downloadCode": "code-second"},
},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.DownloadCode != "code-first" {
t.Fatalf("DownloadCode = %q, want first code-first", cb.DownloadCode)
}
})
t.Run("picture item missing downloadCode still picture", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "richText",
MsgId: "msg-rt-5",
Content: []interface{}{
map[string]interface{}{"text": "看看这张图"},
map[string]interface{}{"type": "picture"},
},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "picture" {
t.Fatalf("Msgtype = %q, want picture (never downgrade)", cb.Msgtype)
}
if cb.DownloadCode != "" {
t.Fatalf("DownloadCode = %q, want empty", cb.DownloadCode)
}
if cb.Text != "看看这张图" {
t.Fatalf("Text = %q, want 看看这张图", cb.Text)
}
})
t.Run("pure text richText becomes text", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "richText",
MsgId: "msg-rt-6",
Content: []interface{}{
map[string]interface{}{"text": "你好"},
map[string]interface{}{"text": " 世界 "},
},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "text" {
t.Fatalf("Msgtype = %q, want text", cb.Msgtype)
}
if cb.Text != "你好\n世界" {
t.Fatalf("Text = %q, want joined text", cb.Text)
}
if cb.DownloadCode != "" {
t.Fatalf("DownloadCode = %q, want empty", cb.DownloadCode)
}
})
t.Run("malformed richText keeps richtext", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "richText",
MsgId: "msg-rt-7",
Content: "not-a-list",
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "richtext" {
t.Fatalf("Msgtype = %q, want richtext (malformed, keep original)", cb.Msgtype)
}
})
t.Run("empty richText keeps richtext", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "richText",
MsgId: "msg-rt-8",
Content: []interface{}{},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "richtext" {
t.Fatalf("Msgtype = %q, want richtext (empty, keep original)", cb.Msgtype)
}
})
t.Run("richText with type case normalization", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: " RICHTEXT ",
MsgId: "msg-rt-9",
Content: []interface{}{
map[string]interface{}{"text": "hello"},
map[string]interface{}{"TYPE": " PICTURE ", "DOWNLOADCODE": "code-case"},
},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "picture" {
t.Fatalf("Msgtype = %q, want picture", cb.Msgtype)
}
if cb.DownloadCode != "code-case" {
t.Fatalf("DownloadCode = %q, want code-case", cb.DownloadCode)
}
if cb.Text != "hello" {
t.Fatalf("Text = %q, want hello", cb.Text)
}
})
t.Run("richText skips empty text segments", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "richText",
MsgId: "msg-rt-10",
Content: []interface{}{
map[string]interface{}{"text": " "},
map[string]interface{}{"text": "有效内容"},
map[string]interface{}{"text": ""},
},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "text" {
t.Fatalf("Msgtype = %q, want text", cb.Msgtype)
}
if cb.Text != "有效内容" {
t.Fatalf("Text = %q, want 有效内容 (empty segments skipped)", cb.Text)
}
})
t.Run("text regression still works", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "text",
MsgId: "msg-t-2",
Text: chatbot.BotCallbackDataTextModel{Content: "hello"},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "text" {
t.Fatalf("Msgtype = %q, want text", cb.Msgtype)
}
if cb.Text != "hello" {
t.Fatalf("Text = %q, want hello", cb.Text)
}
})
t.Run("picture regression still works", func(t *testing.T) {
t.Parallel()
data := &chatbot.BotCallbackDataModel{
ConversationType: "1",
Msgtype: "picture",
MsgId: "msg-p-2",
Content: map[string]interface{}{
"downloadCode": "regression-code",
},
}
cb, err := BotCallbackFromSDK(data)
if err != nil {
t.Fatalf("BotCallbackFromSDK() error = %v", err)
}
if cb.Msgtype != "picture" {
t.Fatalf("Msgtype = %q, want picture", cb.Msgtype)
}
if cb.DownloadCode != "regression-code" {
t.Fatalf("DownloadCode = %q, want regression-code", cb.DownloadCode)
}
})
}
func TestNewStreamClientValidation(t *testing.T) {
t.Parallel()
h := mustTestHandler(t)
t.Run("nil handler is an error", func(t *testing.T) {
t.Parallel()
cfg := StreamConfig{ClientID: "id", ClientSecret: "secret", TenantKey: "acme"}
if _, err := NewStreamClient(cfg, nil); err == nil {
t.Fatal("NewStreamClient with nil handler = nil error, want error")
}
})
t.Run("invalid config is an error", func(t *testing.T) {
t.Parallel()
if _, err := NewStreamClient(StreamConfig{}, h); err == nil {
t.Fatal("NewStreamClient with empty config = nil error, want error")
}
})
t.Run("valid config keeps SDK auto reconnect on until Close disables it", func(t *testing.T) {
t.Parallel()
cfg := StreamConfig{ClientID: "id", ClientSecret: "secret", TenantKey: "acme"}
sc, err := NewStreamClient(cfg, h)
if err != nil {
t.Fatalf("NewStreamClient() error = %v, want nil", err)
}
if sc == nil || sc.inner == nil {
t.Fatal("NewStreamClient() returned nil client")
}
// The SDK default is AutoReconnect=true; keep it so runtime
// disconnects reconnect automatically.
if !sc.inner.AutoReconnect {
t.Fatal("AutoReconnect = false after NewStreamClient, want true (SDK default must be kept)")
}
// Close must flip AutoReconnect off first so the SDK processLoop
// does not reconnect a closed connection.
sc.Close()
if sc.inner.AutoReconnect {
t.Fatal("AutoReconnect = true after Close, want false (Close must stay closed)")
}
// Closing again must remain a safe no-op.
sc.Close()
})
}
+174
View File
@@ -0,0 +1,174 @@
package dingtalk
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net"
"net/http"
"net/url"
"strings"
"time"
)
const (
// maxWebhookBodyBytes caps both the outgoing request body and the
// response body we are willing to read back from the session webhook.
maxWebhookBodyBytes = 1 << 20 // 1 MiB
defaultHTTPTimeout = 15 * time.Second
)
// WebhookSender posts replies to a DingTalk session webhook. It fails
// closed: only https URLs on port 443 without userinfo whose hostname is
// dingtalk.com or a subdomain are accepted, redirects are refused, and any
// non-2xx response is an error. This prevents answers from leaking to
// arbitrary public hosts (SSRF).
type WebhookSender struct {
client *http.Client
extraHosts map[string]bool // test-only additional allowed hostnames
validateURL func(string) error
}
// NewWebhookSender builds a sender. A nil client installs a hardened default
// (no redirects, sane timeout).
func NewWebhookSender(client *http.Client) (*WebhookSender, error) {
return newWebhookSender(client, nil)
}
func newWebhookSender(client *http.Client, extraHosts map[string]bool) (*WebhookSender, error) {
if client == nil {
client = &http.Client{Timeout: defaultHTTPTimeout}
}
wrapped := *client
wrapped.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return errors.New("dingtalk webhook redirects are not allowed")
}
sender := &WebhookSender{client: &wrapped, extraHosts: extraHosts}
sender.validateURL = func(raw string) error {
return sender.validate(raw)
}
return sender, nil
}
// newWebhookSenderForTest is used by tests to allow loopback TLS servers
// (any port) while exercising the exact same send/validation code path.
func newWebhookSenderForTest(client *http.Client, hosts ...string) (*WebhookSender, error) {
extra := make(map[string]bool, len(hosts))
for _, h := range hosts {
extra[strings.ToLower(h)] = true
}
sender, err := newWebhookSender(client, extra)
if err != nil {
return nil, err
}
base := sender.validateURL
sender.validateURL = func(raw string) error {
if err := base(raw); err == nil {
return nil
} else if !strings.Contains(err.Error(), "default port 443") {
return err
}
// Allow non-443 ports only for explicitly allow-listed test hosts.
u, parseErr := url.Parse(raw)
if parseErr != nil {
return parseErr
}
if u.Scheme != "https" || u.User != nil || !extra[strings.ToLower(u.Hostname())] {
return fmt.Errorf("dingtalk webhook URL must use default port 443, got %q", u.Port())
}
return nil
}
return sender, nil
}
// ValidateWebhookURL enforces the production webhook URL policy.
func ValidateWebhookURL(raw string) error {
return (&WebhookSender{}).validate(raw)
}
func (s *WebhookSender) validate(raw string) error {
if strings.TrimSpace(raw) == "" {
return errors.New("dingtalk webhook URL is empty")
}
u, err := url.Parse(raw)
if err != nil {
return fmt.Errorf("dingtalk webhook URL parse: %w", err)
}
if u.Scheme != "https" {
return fmt.Errorf("dingtalk webhook URL must be https, got %q", u.Scheme)
}
if u.User != nil {
return errors.New("dingtalk webhook URL must not contain userinfo")
}
host := u.Hostname()
if host == "" {
return errors.New("dingtalk webhook URL must include a host")
}
port := u.Port()
if port != "" && port != "443" {
return fmt.Errorf("dingtalk webhook URL must use default port 443, got %q", port)
}
if !s.hostAllowed(host) {
return fmt.Errorf("dingtalk webhook host %q is not allowed", host)
}
return nil
}
func (s *WebhookSender) hostAllowed(host string) bool {
host = strings.ToLower(host)
if ip := net.ParseIP(host); ip != nil {
return false
}
if host == "dingtalk.com" || strings.HasSuffix(host, ".dingtalk.com") {
return true
}
return s.extraHosts[host]
}
// SendMarkdown posts a markdown message to the session webhook.
func (s *WebhookSender) SendMarkdown(ctx context.Context, webhookURL, title, text string) error {
if err := s.validateURL(webhookURL); err != nil {
return err
}
if title == "" {
title = "DobotAI"
}
body, err := json.Marshal(map[string]any{
"msgtype": "markdown",
"markdown": map[string]string{
"title": title,
"text": text,
},
})
if err != nil {
return fmt.Errorf("marshal dingtalk webhook payload: %w", err)
}
if len(body) > maxWebhookBodyBytes {
return errors.New("dingtalk webhook payload exceeds 1MiB")
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, webhookURL, bytes.NewReader(body))
if err != nil {
return fmt.Errorf("build dingtalk webhook request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
resp, err := s.client.Do(req)
if err != nil {
return fmt.Errorf("send dingtalk webhook: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
_, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, maxWebhookBodyBytes))
return fmt.Errorf("dingtalk webhook returned status %d", resp.StatusCode)
}
n, err := io.Copy(io.Discard, io.LimitReader(resp.Body, maxWebhookBodyBytes+1))
if err != nil {
return fmt.Errorf("read dingtalk webhook response: %w", err)
}
if n > maxWebhookBodyBytes {
return fmt.Errorf("dingtalk webhook response exceeds %d bytes", maxWebhookBodyBytes)
}
return nil
}
+171
View File
@@ -0,0 +1,171 @@
package dingtalk
import (
"context"
"crypto/tls"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"testing"
)
func newTestSender(t *testing.T, client *http.Client) *WebhookSender {
t.Helper()
sender, err := NewWebhookSender(client)
if err != nil {
t.Fatalf("NewWebhookSender: %v", err)
}
return sender
}
func TestWebhookSenderRejectsInvalidURLs(t *testing.T) {
sender := newTestSender(t, http.DefaultClient)
cases := map[string]string{
"http not https": "http://oapi.dingtalk.com/robot/send?access_token=x",
"userinfo": "https://user:pass@oapi.dingtalk.com/robot/send?access_token=x",
"arbitrary public host": "https://evil.example.com/robot/send",
"non-default port": "https://oapi.dingtalk.com:8443/robot/send",
"empty url": "",
"no host": "https:///robot/send",
}
for name, raw := range cases {
t.Run(name, func(t *testing.T) {
if err := sender.SendMarkdown(context.Background(), raw, "t", "hello"); err == nil {
t.Fatalf("expected rejection for %q", raw)
}
})
}
}
func TestWebhookSenderRejectsRedirect(t *testing.T) {
var finalURL string
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
finalURL = r.URL.String()
w.WriteHeader(http.StatusOK)
}))
defer server.Close()
parsed, err := url.Parse(server.URL)
if err != nil {
t.Fatal(err)
}
redirector := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, parsed.String(), http.StatusFound)
}))
defer redirector.Close()
client := redirector.Client()
// TLS test servers run on 127.0.0.1, so allow the loopback host in this test only.
sender, err := newWebhookSenderForTest(client, "127.0.0.1")
if err != nil {
t.Fatalf("newWebhookSenderForTest: %v", err)
}
err = sender.SendMarkdown(context.Background(), redirector.URL+"/robot/send", "t", "hello")
if err == nil {
t.Fatalf("expected redirect to be rejected, final request reached %q", finalURL)
}
if !strings.Contains(err.Error(), "redirect") {
t.Fatalf("expected redirect error, got %v", err)
}
}
func TestWebhookSenderRejectsNon2xx(t *testing.T) {
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
}))
defer server.Close()
sender, err := newWebhookSenderForTest(server.Client(), "127.0.0.1")
if err != nil {
t.Fatalf("newWebhookSenderForTest: %v", err)
}
if err := sender.SendMarkdown(context.Background(), server.URL, "t", "hello"); err == nil {
t.Fatal("expected non-2xx error")
}
}
func TestWebhookSenderAcceptsHTTPSDingTalkAndSendsMarkdown(t *testing.T) {
var body []byte
server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.TLS == nil {
t.Error("request must use TLS")
}
var readErr error
body, readErr = io.ReadAll(r.Body)
if readErr != nil {
t.Errorf("read body: %v", readErr)
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"errcode":0}`))
}))
server.TLS = &tls.Config{}
server.StartTLS()
defer server.Close()
// Test-only variant that accepts the loopback host but keeps the same
// markdown payload code path as the production oapi.dingtalk.com sender.
sender, err := newWebhookSenderForTest(server.Client(), "127.0.0.1")
if err != nil {
t.Fatalf("newWebhookSenderForTest: %v", err)
}
if err := sender.SendMarkdown(context.Background(), server.URL+"/robot/send?access_token=x", "回答", "**你好**"); err != nil {
t.Fatalf("SendMarkdown: %v", err)
}
var payload struct {
Msgtype string `json:"msgtype"`
Markdown struct {
Title string `json:"title"`
Text string `json:"text"`
} `json:"markdown"`
}
if err := json.Unmarshal(body, &payload); err != nil {
t.Fatalf("payload is not JSON: %v", err)
}
if payload.Msgtype != "markdown" {
t.Fatalf("msgtype = %q, want markdown", payload.Msgtype)
}
if payload.Markdown.Text != "**你好**" || payload.Markdown.Title == "" {
t.Fatalf("unexpected markdown payload: %+v", payload.Markdown)
}
}
func TestWebhookSenderRejectsOversizedResponse(t *testing.T) {
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
// Stream more than 1MiB so the sender must fail rather than
// silently truncate.
chunk := make([]byte, 64*1024)
for i := 0; i < (maxWebhookBodyBytes/len(chunk))+1; i++ {
_, _ = w.Write(chunk)
}
}))
defer server.Close()
sender, err := newWebhookSenderForTest(server.Client(), "127.0.0.1")
if err != nil {
t.Fatalf("newWebhookSenderForTest: %v", err)
}
err = sender.SendMarkdown(context.Background(), server.URL, "t", "hello")
if err == nil {
t.Fatal("expected error for response body larger than 1MiB, got silent truncation")
}
if !strings.Contains(err.Error(), "exceeds") {
t.Fatalf("expected size-limit error, got %v", err)
}
}
// TestWebhookSenderValidateWebhookURLAcceptsDingTalkHosts asserts the pure
// URL policy accepts oapi.dingtalk.com and *.dingtalk.com over https/443.
func TestWebhookSenderValidateWebhookURLAcceptsDingTalkHosts(t *testing.T) {
for _, raw := range []string{
"https://oapi.dingtalk.com/robot/send?access_token=x",
"https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend",
} {
if err := ValidateWebhookURL(raw); err != nil {
t.Fatalf("ValidateWebhookURL(%q): %v", raw, err)
}
}
}
+23
View File
@@ -15,6 +15,27 @@ const (
var ErrTurnInProgress = errors.New("turn is already processing")
// ImageInput contains the image data for a QA request. The DataURI is a
// full data: URI (e.g. "data:image/png;base64,...") and must never be
// persisted to the audit log.
type ImageInput struct {
DataURI string
MIMEType string
SizeBytes int64
Width int
Height int
}
// MediaAudit records metadata about media in a turn for audit purposes.
// It must never contain DataURI, download codes, or URLs.
type MediaAudit struct {
Type string `json:"type"` // "image"
MIMEType string `json:"mime_type"`
SizeBytes int64 `json:"size_bytes"`
Width int `json:"width"`
Height int `json:"height"`
}
type QARequest struct {
TenantKey string
Channel string
@@ -24,6 +45,7 @@ type QARequest struct {
ExternalMessageID string
SenderName string
Query string
Images []ImageInput
}
type Reference struct {
@@ -65,6 +87,7 @@ type Turn struct {
Question string
Answer string
References []Reference
Media []MediaAudit
Status string
ErrorMessage string
}
+254
View File
@@ -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)
}
}
+79 -3
View File
@@ -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
}
@@ -56,9 +76,16 @@ func (s *Service) Ask(ctx context.Context, request core.QARequest) (core.QAResul
return core.QAResult{}, err
}
media := make([]core.MediaAudit, 0, len(request.Images))
for _, image := range request.Images {
media = append(media, core.MediaAudit{
Type: "image", MIMEType: image.MIMEType, SizeBytes: image.SizeBytes,
Width: image.Width, Height: image.Height,
})
}
turn := core.Turn{ID: newID(), TenantKey: request.TenantKey, Channel: request.Channel,
ExternalMessageID: request.ExternalMessageID, SessionKey: sessionKey,
Question: request.Query, Status: "processing"}
Question: request.Query, Media: media, Status: "processing"}
stored, created, err := s.repository.BeginTurn(ctx, turn)
if err != nil {
return core.QAResult{}, fmt.Errorf("begin turn: %w", err)
@@ -91,9 +118,58 @@ func (s *Service) Ask(ctx context.Context, request core.QARequest) (core.QAResul
if request.ConversationType == core.ConversationGroup && strings.TrimSpace(request.SenderName) != "" {
query = request.SenderName + ": " + request.Query
}
chat, err := s.weknora.AgentChat(ctx, sessionID, weknora.AgentChatRequest{
images := make([]weknora.Image, 0, len(request.Images))
for _, image := range request.Images {
images = append(images, weknora.Image{Data: image.DataURI})
}
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)
+258
View File
@@ -2,6 +2,7 @@ package qa
import (
"context"
"errors"
"sync"
"testing"
@@ -63,6 +64,7 @@ type fakeWeKnora struct {
mu sync.Mutex
sessions int
queries []string
requests []weknora.AgentChatRequest
}
func (f *fakeWeKnora) CreateSession(context.Context, string, string) (string, error) {
@@ -75,9 +77,32 @@ func (f *fakeWeKnora) AgentChat(_ context.Context, sessionID string, request wek
f.mu.Lock()
defer f.mu.Unlock()
f.queries = append(f.queries, request.Query)
f.requests = append(f.requests, request)
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{}
@@ -102,4 +127,237 @@ func TestAskUsesSharedGroupSessionAndReplaysDuplicate(t *testing.T) {
if client.sessions != 1 || len(client.queries) != 1 || client.queries[0] != "Alice: question" {
t.Fatalf("sessions=%d queries=%v", client.sessions, client.queries)
}
// sender prefix must not regress
if len(client.requests) != 1 {
t.Fatalf("expected 1 weknora request, got %d", len(client.requests))
}
if client.requests[0].Query != "Alice: question" {
t.Fatalf("sender prefix regression: got %q", client.requests[0].Query)
}
// Turn.Media must be empty for no-image request
repo.mu.Lock()
stored := repo.turns["tenant:dingtalk:message-1"]
repo.mu.Unlock()
if len(stored.Media) != 0 {
t.Fatalf("expected empty Media, got %+v", stored.Media)
}
}
func TestAskPropagatesImagesToWeKnora(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup,
ExternalChatID: "group-1", ExternalUserID: "user-1",
ExternalMessageID: "message-img", SenderName: "Alice", Query: "describe this",
Images: []core.ImageInput{
{DataURI: "data:image/png;base64,AAAA", MIMEType: "image/png", SizeBytes: 1024, Width: 640, Height: 480},
},
}
result, err := service.Ask(context.Background(), req)
if err != nil {
t.Fatalf("Ask: %v", err)
}
if result.Answer != "answer" {
t.Fatalf("unexpected answer: %s", result.Answer)
}
client.mu.Lock()
defer client.mu.Unlock()
if len(client.requests) != 1 {
t.Fatalf("expected 1 weknora request, got %d", len(client.requests))
}
chatReq := client.requests[0]
if len(chatReq.Images) != 1 {
t.Fatalf("expected 1 image in weknora request, got %d", len(chatReq.Images))
}
if chatReq.Images[0].Data != "data:image/png;base64,AAAA" {
t.Fatalf("image Data not propagated: %q", chatReq.Images[0].Data)
}
// sender prefix must still work
if chatReq.Query != "Alice: describe this" {
t.Fatalf("sender prefix regression: %q", chatReq.Query)
}
}
func TestAskDerivesTurnMediaFromImages(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup,
ExternalChatID: "group-1", ExternalUserID: "user-1",
ExternalMessageID: "message-media", SenderName: "Alice", Query: "q",
Images: []core.ImageInput{
{DataURI: "data:image/png;base64,AAAA", MIMEType: "image/png", SizeBytes: 2048, Width: 640, Height: 480},
},
}
_, err = service.Ask(context.Background(), req)
if err != nil {
t.Fatalf("Ask: %v", err)
}
repo.mu.Lock()
stored := repo.turns["tenant:dingtalk:message-media"]
repo.mu.Unlock()
if len(stored.Media) != 1 {
t.Fatalf("expected 1 MediaAudit, got %d", len(stored.Media))
}
m := stored.Media[0]
if m.Type != "image" || m.MIMEType != "image/png" || m.SizeBytes != 2048 || m.Width != 640 || m.Height != 480 {
t.Fatalf("MediaAudit metadata mismatch: %+v", m)
}
// DataURI must NOT be in Turn.Media
if m.Type == "data:image/png;base64,AAAA" {
t.Fatal("MediaAudit must not contain DataURI")
}
}
func TestAskDuplicateReplayDoesNotCallWeKnoraAgain(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup,
ExternalChatID: "group-1", ExternalUserID: "user-1",
ExternalMessageID: "message-replay", SenderName: "Alice", Query: "q",
Images: []core.ImageInput{
{DataURI: "data:image/png;base64,AAAA", MIMEType: "image/png", SizeBytes: 1024, Width: 640, Height: 480},
},
}
first, err := service.Ask(context.Background(), req)
if err != nil {
t.Fatalf("first Ask: %v", err)
}
second, err := service.Ask(context.Background(), req)
if err != nil {
t.Fatalf("replay Ask: %v", err)
}
if !second.Replayed {
t.Fatal("second should be replayed")
}
if first.Answer != second.Answer {
t.Fatal("replay must return same answer")
}
client.mu.Lock()
defer client.mu.Unlock()
// WeKnora must be called exactly once
if len(client.requests) != 1 {
t.Fatalf("duplicate must not call WeKnora again; got %d requests", len(client.requests))
}
// Turn.Media must be preserved on replay
repo.mu.Lock()
stored := repo.turns["tenant:dingtalk:message-replay"]
repo.mu.Unlock()
if len(stored.Media) != 1 {
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)
}
}
+27 -5
View File
@@ -35,10 +35,18 @@ func (s *Store) Close() {
}
func (s *Store) BeginTurn(ctx context.Context, turn core.Turn) (core.Turn, bool, error) {
media := turn.Media
if media == nil {
media = []core.MediaAudit{}
}
mediaJSON, err := json.Marshal(media)
if err != nil {
return core.Turn{}, false, err
}
command, err := s.pool.Exec(ctx, `INSERT INTO turns
(id, tenant_key, channel, external_message_id, session_key, question, status)
VALUES ($1,$2,$3,$4,$5,$6,'processing') ON CONFLICT DO NOTHING`,
turn.ID, turn.TenantKey, turn.Channel, turn.ExternalMessageID, turn.SessionKey, turn.Question)
(id, tenant_key, channel, external_message_id, session_key, question, status, media_json)
VALUES ($1,$2,$3,$4,$5,$6,'processing',$7) ON CONFLICT DO NOTHING`,
turn.ID, turn.TenantKey, turn.Channel, turn.ExternalMessageID, turn.SessionKey, turn.Question, mediaJSON)
if err != nil {
return core.Turn{}, false, err
}
@@ -84,14 +92,23 @@ func (s *Store) FinishTurn(ctx context.Context, turn core.Turn) error {
if err != nil {
return err
}
_, err = s.pool.Exec(ctx, `UPDATE turns SET weknora_session_id=$2,weknora_request_id=$3,answer=$4,references=$5,status=$6,error_message=$7,updated_at=NOW() WHERE id=$1`, turn.ID, turn.WeKnoraSessionID, turn.WeKnoraRequestID, turn.Answer, references, turn.Status, turn.ErrorMessage)
media := turn.Media
if media == nil {
media = []core.MediaAudit{}
}
mediaJSON, err := json.Marshal(media)
if err != nil {
return err
}
_, err = s.pool.Exec(ctx, `UPDATE turns SET weknora_session_id=$2,weknora_request_id=$3,answer=$4,references_json=$5,media_json=$6,status=$7,error_message=$8,updated_at=NOW() WHERE id=$1`, turn.ID, turn.WeKnoraSessionID, turn.WeKnoraRequestID, turn.Answer, references, mediaJSON, turn.Status, turn.ErrorMessage)
return err
}
func (s *Store) loadTurn(ctx context.Context, tenantKey, channel, messageID string) (core.Turn, error) {
var turn core.Turn
var references []byte
err := s.pool.QueryRow(ctx, `SELECT id,tenant_key,channel,external_message_id,session_key,weknora_session_id,weknora_request_id,question,answer,references,status,error_message FROM turns WHERE tenant_key=$1 AND channel=$2 AND external_message_id=$3`, tenantKey, channel, messageID).Scan(&turn.ID, &turn.TenantKey, &turn.Channel, &turn.ExternalMessageID, &turn.SessionKey, &turn.WeKnoraSessionID, &turn.WeKnoraRequestID, &turn.Question, &turn.Answer, &references, &turn.Status, &turn.ErrorMessage)
var mediaJSON []byte
err := s.pool.QueryRow(ctx, `SELECT id,tenant_key,channel,external_message_id,session_key,weknora_session_id,weknora_request_id,question,answer,references_json,media_json,status,error_message FROM turns WHERE tenant_key=$1 AND channel=$2 AND external_message_id=$3`, tenantKey, channel, messageID).Scan(&turn.ID, &turn.TenantKey, &turn.Channel, &turn.ExternalMessageID, &turn.SessionKey, &turn.WeKnoraSessionID, &turn.WeKnoraRequestID, &turn.Question, &turn.Answer, &references, &mediaJSON, &turn.Status, &turn.ErrorMessage)
if err != nil {
return core.Turn{}, err
}
@@ -100,5 +117,10 @@ func (s *Store) loadTurn(ctx context.Context, tenantKey, channel, messageID stri
return core.Turn{}, err
}
}
if len(mediaJSON) > 0 {
if err := json.Unmarshal(mediaJSON, &turn.Media); err != nil {
return core.Turn{}, err
}
}
return turn, nil
}
@@ -0,0 +1,91 @@
// Source-level contract tests: the store's SQL must use the renamed
// references_json column (the bare `references` identifier is a reserved
// word in PostgreSQL 16), while the Go domain field stays turn.References.
// No database connection is required.
package postgres
import (
"os"
"path/filepath"
"regexp"
"strings"
"testing"
)
func readStoreSource(t *testing.T) string {
t.Helper()
data, err := os.ReadFile(filepath.Join(".", "store.go"))
if err != nil {
t.Fatalf("read store.go: %v", err)
}
return string(data)
}
func extractSQLLiterals(src string) []string {
var sqls []string
re := regexp.MustCompile("`([^`]*)`")
for _, m := range re.FindAllStringSubmatch(src, -1) {
upper := strings.ToUpper(m[1])
if strings.Contains(upper, "SELECT") || strings.Contains(upper, "UPDATE") ||
strings.Contains(upper, "INSERT") || strings.Contains(upper, "DELETE") {
sqls = append(sqls, m[1])
}
}
return sqls
}
func TestStoreSQLUsesReferencesJSONColumn(t *testing.T) {
src := readStoreSource(t)
sqls := extractSQLLiterals(src)
if len(sqls) == 0 {
t.Fatal("no SQL literals found in store.go")
}
var update, selectTurns string
for _, sql := range sqls {
upper := strings.ToUpper(sql)
if strings.HasPrefix(strings.TrimSpace(upper), "UPDATE TURNS") {
update = sql
}
if strings.Contains(upper, "SELECT") && strings.Contains(upper, "FROM TURNS") {
selectTurns = sql
}
}
if update == "" {
t.Fatal("FinishTurn UPDATE turns statement not found")
}
if selectTurns == "" {
t.Fatal("loadTurn SELECT FROM turns statement not found")
}
if !strings.Contains(update, "references_json=$5") {
t.Error("FinishTurn UPDATE must write to references_json column")
}
if !strings.Contains(selectTurns, "answer,references_json,media_json,status") && !strings.Contains(selectTurns, "answer,references_json,status") {
t.Error("loadTurn SELECT must read references_json column")
}
}
func TestStoreSQLAvoidsBareReferencesIdentifier(t *testing.T) {
src := readStoreSource(t)
// Inside the actual SQL literals, the bare word `references` is a
// reserved word in PostgreSQL 16 and must not appear as a column
// identifier. The Go variable/field names are irrelevant here because
// we only inspect SQL string literals.
bare := regexp.MustCompile(`(?i)\breferences\b`)
for _, sql := range extractSQLLiterals(src) {
// references_json is fine; strip it before checking for the bare word.
scrubbed := regexp.MustCompile(`(?i)\breferences_json\b`).ReplaceAllString(sql, "")
if bare.MatchString(scrubbed) {
t.Errorf("SQL literal uses reserved word `references` as a column name; use references_json:\n%s", sql)
}
}
}
func TestStoreKeepsDomainFieldReferences(t *testing.T) {
src := readStoreSource(t)
if !regexp.MustCompile(`turn\.References`).MatchString(src) {
t.Error("store must keep using the domain field turn.References (API unchanged)")
}
}
@@ -0,0 +1,99 @@
package postgres
import (
"encoding/json"
"strings"
"testing"
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/core"
)
func TestStoreSQLUsesMediaJSONColumn(t *testing.T) {
src := readStoreSource(t)
sqls := extractSQLLiterals(src)
var insert, update, selectTurns string
for _, sql := range sqls {
upper := strings.ToUpper(sql)
if strings.Contains(upper, "INSERT") && strings.Contains(upper, "INTO TURNS") {
insert = sql
}
if strings.HasPrefix(strings.TrimSpace(upper), "UPDATE TURNS") {
update = sql
}
if strings.Contains(upper, "SELECT") && strings.Contains(upper, "FROM TURNS") {
selectTurns = sql
}
}
if insert == "" {
t.Fatal("BeginTurn INSERT INTO turns statement not found")
}
if update == "" {
t.Fatal("FinishTurn UPDATE turns statement not found")
}
if selectTurns == "" {
t.Fatal("loadTurn SELECT FROM turns statement not found")
}
if !strings.Contains(insert, "media_json") {
t.Error("BeginTurn INSERT must include media_json column")
}
if !strings.Contains(update, "media_json") {
t.Error("FinishTurn UPDATE must write to media_json column")
}
if !strings.Contains(selectTurns, "media_json") {
t.Error("loadTurn SELECT must read media_json column")
}
}
func TestMediaAuditJSONExcludesSecrets(t *testing.T) {
ma := core.MediaAudit{
Type: "image",
MIMEType: "image/png",
SizeBytes: 2048,
Width: 640,
Height: 480,
}
raw, err := json.Marshal(ma)
if err != nil {
t.Fatalf("marshal: %v", err)
}
s := string(raw)
for _, secret := range []string{"DataURI", "data_uri", "DownloadCode", "download_code", "URL", "url"} {
if strings.Contains(s, secret) {
t.Errorf("MediaAudit JSON must not contain secret field %q: %s", secret, s)
}
}
var fields map[string]any
if err := json.Unmarshal(raw, &fields); err != nil {
t.Fatalf("unmarshal fields: %v", err)
}
for _, key := range []string{"type", "mime_type", "size_bytes", "width", "height"} {
if _, ok := fields[key]; !ok {
t.Errorf("MediaAudit JSON missing %q field: %s", key, s)
}
}
}
func TestMediaAuditNilMarshalsToNull(t *testing.T) {
// Nil slice marshals to "null" — the store must guard against this
// because the media_json column is NOT NULL with DEFAULT '[]'.
var media []core.MediaAudit
raw, err := json.Marshal(media)
if err != nil {
t.Fatalf("marshal: %v", err)
}
if string(raw) != "null" {
t.Errorf("nil media slice marshals to %q (expected null); store must handle nil→[]", raw)
}
}
func TestStoreHasNilMediaGuard(t *testing.T) {
src := readStoreSource(t)
// The store must ensure nil media is persisted as [] not null.
// Check for a nil guard in BeginTurn (e.g. "if turn.Media == nil" or "media == nil").
if !strings.Contains(src, "edia == nil") && !strings.Contains(src, "edia != nil") && !strings.Contains(src, "len(turn.Media)") {
t.Error("store must guard against nil media slice (NOT NULL column)")
}
}
+111 -1
View File
@@ -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
}
+169
View File
@@ -2,6 +2,7 @@ package weknora
import (
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
@@ -63,3 +64,171 @@ func TestParseSSEErrorDominatesPartialAnswer(t *testing.T) {
t.Fatalf("expected terminal vision error, got %v", err)
}
}
func TestAgentChatRequestJSONSerializesImages(t *testing.T) {
req := AgentChatRequest{
Query: "请描述并分析这张图片。",
AgentEnabled: true,
AgentID: "agent-1",
Channel: "im",
Images: []Image{
{Data: "data:image/png;base64,iVBORw0KGgo="},
},
}
raw, err := json.Marshal(req)
if err != nil {
t.Fatalf("marshal: %v", err)
}
if !strings.Contains(string(raw), `"images":[{"data":"data:image/png;base64,iVBORw0KGgo="}]`) {
t.Fatalf("images not serialized correctly: %s", raw)
}
}
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",
AgentEnabled: true,
AgentID: "agent-1",
}
raw, err := json.Marshal(req)
if err != nil {
t.Fatalf("marshal: %v", err)
}
if strings.Contains(string(raw), `"images"`) {
t.Fatalf("empty images should be omitted: %s", raw)
}
}
+269
View File
@@ -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])
}
}
+39
View File
@@ -0,0 +1,39 @@
#!/usr/bin/env bash
set -euo pipefail
root="/home/zheromiku/dobotai-platform"
go_bin="${GO_BIN:-/home/zheromiku/.local/share/go1.26.5/bin/go}"
bin_dir="$root/bin"
current="$bin_dir/dobotai"
next="$bin_dir/dobotai.new"
previous="$bin_dir/dobotai.prev"
service="dobotai.service"
mkdir -p "$bin_dir"
cd "$root"
"$go_bin" build -trimpath -o "$next" ./cmd/dobotai
chmod 0755 "$next"
if [[ -f "$current" ]]; then
cp -p "$current" "$previous"
fi
mv -f "$next" "$current"
systemctl --user restart "$service"
for _ in $(seq 1 30); do
if curl --noproxy '*' --fail --silent --max-time 2 http://127.0.0.1:8090/healthz >/dev/null; then
echo "DOBOTAI_DEPLOY_OK"
exit 0
fi
sleep 1
done
echo "DobotAI health check failed; attempting binary rollback" >&2
if [[ -f "$previous" ]]; then
cp -p "$previous" "$current"
systemctl --user restart "$service"
fi
systemctl --user status "$service" --no-pager >&2 || true
exit 1
+42
View File
@@ -0,0 +1,42 @@
#!/usr/bin/env python3
"""Load DobotAI's local .env without shell evaluation, then exec the binary."""
import os
from pathlib import Path
ROOT = Path("/home/zheromiku/dobotai-platform")
ENV_FILE = ROOT / ".env"
BINARY = ROOT / "bin" / "dobotai"
def load_env(path: Path) -> dict[str, str]:
env = os.environ.copy()
for raw in path.read_text().splitlines():
line = raw.strip()
if not line or line.startswith("#") or "=" not in line:
continue
key, value = line.split("=", 1)
env[key.strip()] = value.strip()
# WeKnora is local and DingTalk is directly reachable in China. Do not make
# the service depend on a desktop proxy that may be absent during boot.
for key in (
"HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY",
"http_proxy", "https_proxy", "all_proxy",
):
env.pop(key, None)
env["NO_PROXY"] = "localhost,127.0.0.1"
env["no_proxy"] = env["NO_PROXY"]
return env
def main() -> None:
if not ENV_FILE.is_file():
raise SystemExit(f"missing environment file: {ENV_FILE}")
if not BINARY.is_file():
raise SystemExit(f"missing DobotAI binary: {BINARY}")
os.chdir(ROOT)
os.execve(BINARY, [str(BINARY)], load_env(ENV_FILE))
if __name__ == "__main__":
main()