diff --git a/cmd/dobotai/card_tables.go b/cmd/dobotai/card_tables.go
new file mode 100644
index 0000000..c875b5c
--- /dev/null
+++ b/cmd/dobotai/card_tables.go
@@ -0,0 +1,23 @@
+package main
+
+import (
+ "log"
+ "os"
+ "strings"
+)
+
+// cardWideTableGroupingDisabled reports whether the DingTalk final-frame
+// normalizer must stop rewriting over-wide answer tables into grouped lists.
+// Disabling it keeps real tables in the card, which is what the operator wants
+// now that the PC client renders wide-screen cards; clients that still cannot
+// lay out wide tables need the grouping, so the default stays enabled.
+// DINGTALK_CARD_WIDE_TABLE_GROUP=off disables it.
+func cardWideTableGroupingDisabled() bool {
+ switch strings.ToLower(strings.TrimSpace(os.Getenv("DINGTALK_CARD_WIDE_TABLE_GROUP"))) {
+ case "off", "0", "false", "no":
+ log.Printf("DingTalk wide-table grouping disabled by configuration")
+ return true
+ default:
+ return false
+ }
+}
diff --git a/cmd/dobotai/main.go b/cmd/dobotai/main.go
index 6ec818e..109e397 100644
--- a/cmd/dobotai/main.go
+++ b/cmd/dobotai/main.go
@@ -323,7 +323,8 @@ func main() {
ReasoningRouter: &dingTalkReasoningRouter{service: reasoningService},
LanguageResolver: settingsRuntime.repository,
- OutboundRewriteTimeout: outboundImages.rewriteTimeout,
+ OutboundRewriteTimeout: outboundImages.rewriteTimeout,
+ WideTableGroupingDisabled: cardWideTableGroupingDisabled(),
},
)
if err != nil {
diff --git a/cmd/dobotai/main_test.go b/cmd/dobotai/main_test.go
index 55ce4b4..02ee5d2 100644
--- a/cmd/dobotai/main_test.go
+++ b/cmd/dobotai/main_test.go
@@ -215,6 +215,21 @@ func TestOutboundImageBudgetAndCompressionDefaults(t *testing.T) {
}
}
+func TestCardWideTableGroupingDisabledToggle(t *testing.T) {
+ t.Setenv("DINGTALK_CARD_WIDE_TABLE_GROUP", "")
+ if cardWideTableGroupingDisabled() {
+ t.Fatal("wide-table grouping must default to enabled")
+ }
+ t.Setenv("DINGTALK_CARD_WIDE_TABLE_GROUP", "off")
+ if !cardWideTableGroupingDisabled() {
+ t.Fatal("DINGTALK_CARD_WIDE_TABLE_GROUP=off must disable wide-table grouping")
+ }
+ t.Setenv("DINGTALK_CARD_WIDE_TABLE_GROUP", "ON")
+ if cardWideTableGroupingDisabled() {
+ t.Fatal("any value other than off must keep grouping enabled")
+ }
+}
+
func TestMainDoesNotExposeWebAdministrationOrSetupOnlyMode(t *testing.T) {
data, err := os.ReadFile("main.go")
if err != nil {
diff --git a/internal/channels/dingtalk/handler.go b/internal/channels/dingtalk/handler.go
index b942abb..75a0ccf 100644
--- a/internal/channels/dingtalk/handler.go
+++ b/internal/channels/dingtalk/handler.go
@@ -168,6 +168,10 @@ type HandlerOptions struct {
// delivery timeout, otherwise the remaining images are dropped. Zero keeps
// finalDeliveryTimeout.
OutboundRewriteTimeout time.Duration
+ // WideTableGroupingDisabled stops the final-frame normalizer from rewriting
+ // over-wide tables into grouped lists. Leave false on clients whose cards
+ // cannot lay out wide tables.
+ WideTableGroupingDisabled bool
}
type Handler struct {
@@ -189,6 +193,10 @@ type Handler struct {
// outboundRewriteTimeout applies to the image rewrite stage only; zero
// falls back to finalDeliveryTimeout.
outboundRewriteTimeout time.Duration
+ // wideTableGroupingDisabled keeps the final frame's tables as tables
+ // instead of rewriting over-wide ones into grouped lists. Used while the
+ // client renders wide tables itself (PC wide-screen cards).
+ wideTableGroupingDisabled bool
}
// NewHandler accepts at most one image downloader. A nil/omitted downloader
@@ -237,7 +245,8 @@ func NewHandlerWithOptions(cfg TenantConfig, qa QAAsker, reply MarkdownSender, o
cardUpdateInterval: 500 * time.Millisecond,
finalDeliveryTimeout: defaultHTTPTimeout,
- outboundRewriteTimeout: opts.OutboundRewriteTimeout,
+ outboundRewriteTimeout: opts.OutboundRewriteTimeout,
+ wideTableGroupingDisabled: opts.WideTableGroupingDisabled,
}, nil
}
@@ -660,8 +669,10 @@ func (h *Handler) finalizeCardOrMarkdown(ctx context.Context, webhookURL string,
}
func (h *Handler) rewriteOutboundContent(ctx context.Context, content string) string {
+ options := defaultTableNormalizeOptions()
+ options.groupWideTables = !h.wideTableGroupingDisabled
if h.outboundRewriter == nil {
- return normalizeWideMarkdownTables(sanitizeDisplayAnswer(content))
+ return normalizeMarkdownTables(sanitizeDisplayAnswer(content), options)
}
timeout := h.outboundRewriteTimeout
if timeout <= 0 {
@@ -672,7 +683,7 @@ func (h *Handler) rewriteOutboundContent(ctx context.Context, content string) st
}
rewriteCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), timeout)
defer cancel()
- return normalizeWideMarkdownTables(sanitizeDisplayAnswer(h.outboundRewriter.Rewrite(rewriteCtx, content)))
+ return normalizeMarkdownTables(sanitizeDisplayAnswer(h.outboundRewriter.Rewrite(rewriteCtx, content)), options)
}
func (h *Handler) sanitizeOutboundPartial(ctx context.Context, content string) string {
diff --git a/internal/channels/dingtalk/table_normalize.go b/internal/channels/dingtalk/table_normalize.go
index deb123e..724ff95 100644
--- a/internal/channels/dingtalk/table_normalize.go
+++ b/internal/channels/dingtalk/table_normalize.go
@@ -10,6 +10,19 @@ import (
// (one character per line) in the streaming card renderer.
const maxTableCellVisualWidth = 32
+// tableNormalizeOptions controls how a final answer is adapted to the card
+// renderer. The zero value keeps the historical behaviour.
+type tableNormalizeOptions struct {
+ // groupWideTables rewrites tables containing over-wide cells into grouped
+ // lists (bold row heading + "- header:value" lines). Disable it when the
+ // client lays out wide tables itself, so the answer keeps its real table.
+ groupWideTables bool
+}
+
+func defaultTableNormalizeOptions() tableNormalizeOptions {
+ return tableNormalizeOptions{groupWideTables: true}
+}
+
// normalizeWideMarkdownTables makes final answers render reliably on DingTalk
// cards without changing the knowledge itself. It (1) replaces
inside
// table cells with a full-width separator, and (2) rewrites any table that
@@ -17,6 +30,10 @@ const maxTableCellVisualWidth = 32
// followed by one "- header:value" line per column. Compact tables pass
// through unchanged. Tables inside code fences are never touched.
func normalizeWideMarkdownTables(content string) string {
+ return normalizeMarkdownTables(content, defaultTableNormalizeOptions())
+}
+
+func normalizeMarkdownTables(content string, options tableNormalizeOptions) string {
if !strings.Contains(content, "|") {
return content
}
@@ -36,7 +53,7 @@ func normalizeWideMarkdownTables(content string) string {
strings.HasPrefix(strings.TrimSpace(lines[end+1].text), "|") {
end++
}
- out = append(out, normalizeTableBlock(lines[i:end+1])...)
+ out = append(out, normalizeTableBlock(lines[i:end+1], options)...)
i = end + 1
continue
}
@@ -46,7 +63,7 @@ func normalizeWideMarkdownTables(content string) string {
return strings.Join(out, "\n")
}
-func normalizeTableBlock(rows []markdownStreamLine) []string {
+func normalizeTableBlock(rows []markdownStreamLine, options tableNormalizeOptions) []string {
cells := make([][]string, 0, len(rows))
for idx, row := range rows {
if idx == 1 { // delimiter row
@@ -63,9 +80,11 @@ func normalizeTableBlock(rows []markdownStreamLine) []string {
}
}
header := cells[0]
- if maxWidth <= maxTableCellVisualWidth {
+ if maxWidth <= maxTableCellVisualWidth || !options.groupWideTables {
// Compact tables keep their exact original bytes unless a cell carries
- //
, which the card renderer mishandles inside cells.
+ //
, which the card renderer mishandles inside cells. The same path
+ // serves over-wide tables when grouping is disabled: the table stays a
+ // table and only
is replaced.
if !blockHasBreak(rows) {
rebuilt := make([]string, len(rows))
for i, row := range rows {
diff --git a/internal/channels/dingtalk/table_normalize_test.go b/internal/channels/dingtalk/table_normalize_test.go
index 9b4e640..d8e4ccc 100644
--- a/internal/channels/dingtalk/table_normalize_test.go
+++ b/internal/channels/dingtalk/table_normalize_test.go
@@ -1,6 +1,7 @@
package dingtalk
import (
+ "context"
"strings"
"testing"
)
@@ -56,6 +57,66 @@ func TestNormalizeSkipsFencedTables(t *testing.T) {
}
}
+func TestNormalizeKeepsWideTableWhenGroupingDisabled(t *testing.T) {
+ longCell := "J1: 180°/s (CR3A/5A/7A), 150°/s (CR10A/12A/16A)
J2: 180°/s (CR3A/5A/7A)"
+ content := "差异如下:\n\n| 对比项 | CR 系列 | CRA 系列 |\n| :--- | :--- | :--- |\n| **关节最大速度** | " + longCell + " | J1: 180°/s (CR3A/5A/7A)
J2: 更多参数说明 |\n| 控制柜 | CC162 | CC262 |\n\n结论"
+ options := defaultTableNormalizeOptions()
+ options.groupWideTables = false
+ got := normalizeMarkdownTables(content, options)
+
+ if !strings.Contains(got, "| 对比项 | CR 系列 | CRA 系列 |") || !strings.Contains(got, "| **关节最大速度** |") {
+ t.Fatalf("wide table must stay a table when grouping is disabled, got %q", got)
+ }
+ if strings.Contains(got, "**关节最大速度**\n- CR 系列:") {
+ t.Fatalf("grouped list must not be produced when grouping is disabled, got %q", got)
+ }
+ if strings.Contains(got, "
") {
+ t.Fatalf("
must still be replaced inside cells, got %q", got)
+ }
+ if !strings.Contains(got, ";") {
+ t.Fatalf("cell line breaks must become the full-width separator, got %q", got)
+ }
+ if !strings.HasPrefix(got, "差异如下:\n\n") || !strings.HasSuffix(got, "\n\n结论") {
+ t.Fatalf("surrounding text must be preserved, got %q", got)
+ }
+}
+
+// TestRewriteOutboundContentWideTableGroupingToggle proves the handler wires
+// the switch through to the final frame, which is what the client sees.
+func TestRewriteOutboundContentWideTableGroupingToggle(t *testing.T) {
+ wide := "| 对比项 | CR 系列 | CRA 系列 |\n| :--- | :--- | :--- |\n| **关节最大速度** | " +
+ strings.Repeat("J1: 180°/s (CR3A/5A/7A) ", 6) + " | CC262 |"
+ cases := []struct {
+ name string
+ disabled bool
+ wantTable bool
+ wantDetail string
+ }{
+ {name: "grouping enabled rewrites wide table", disabled: false, wantTable: false, wantDetail: "**关节最大速度**"},
+ {name: "grouping disabled keeps wide table", disabled: true, wantTable: true, wantDetail: "| 对比项 |"},
+ }
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ h, err := NewHandlerWithOptions(
+ TenantConfig{TenantKey: "tenant-a", Channel: "dingtalk"},
+ &fakeQA{},
+ &fakeReply{},
+ HandlerOptions{WideTableGroupingDisabled: tc.disabled},
+ )
+ if err != nil {
+ t.Fatalf("NewHandlerWithOptions: %v", err)
+ }
+ got := h.rewriteOutboundContent(context.Background(), wide)
+ if strings.Contains(got, "| 对比项 |") != tc.wantTable {
+ t.Fatalf("table present = %v, want %v, got %q", strings.Contains(got, "| 对比项 |"), tc.wantTable, got)
+ }
+ if !strings.Contains(got, tc.wantDetail) {
+ t.Fatalf("missing %q in %q", tc.wantDetail, got)
+ }
+ })
+ }
+}
+
func TestNormalizeHandlesEscapedPipesAndEmptyHeaders(t *testing.T) {
long := strings.Repeat("x", 40)
content := "| 项 | | \n| --- | --- |\n| a\\|b | " + long + " |"