feat(c-core): 内核编解码层 C 化第一刀 —— L1 纯函数层落地并打通构建链

第一刀只做三个纯函数（窗口推断 / token 估算 / token 截断），价值不在功能（Go 版没问题），而在打通「Go → cgo → C」全链路并建立可复现的对照范式，后面每扩一个函数都复用它。 ## 为什么是这三个按「无状态 → 有状态」分层，L1 协议编解码最安全：纯 string in → struct out，不碰网络、不碰 Lua、不碰 goroutine。三个函数更是同一组纯算术，最小可验证切片。 ## 关键设计：包内符号链接，不链接静态库、不 include 包外源三种做法都实测过，只有一种同时满足「可构建 + 可交叉编译 + 缓存可跟踪」： 1. ❌ 链接 `csrc/build/libha_codec.a`（原方案） - .a 是构建产物、不入库（.gitignore 的 build/ 命中 csrc/build/），而发布脚本原先并不产出它 ⇒「不入库 + 不生成」两头空，实测报 `cannot find .../libha_codec.a` - 交叉编译 linux/arm64（homed 真实发布目标）时，宿主 x86-64 的 .a 被链进目标产物，实测报 `file in wrong format` 2. ❌ `#include "../../../csrc/src/ha_codec.c"`（包外相对包含） ★ Go 构建缓存**不跟踪包外被 #include 的 C 文件**。实测：包外源把返回值 7→8，`go test` 依然通过（缓存命中、静默沿用旧代码）；同样改动落在包内文件时立即判红。对「逐步推进 C 化」这是致命的——改 C 源码不生效且无报错。（包内 shim `#include` 包外源同样漏跟踪，已实测排除。） 3. ✅ 包内符号链接 `internal/agent/api/ha_codec.{c,h}` → `csrc/` 文件在包目录内 ⇒ 缓存按内容正确跟踪；只有一份权威源 ⇒ 无副本漂移，也不需要「同步 C 源」的 make 目标。 ## 不需要额外 build tag ha_codec 是零依赖纯 C99 源码内联编译，不需要外部库或工具链前提；而 homed 本就强制 cgo（sqlite3 + gojieba），故 C 路径自然生效。只用 `cgo` / `!cgo` 一组约束（对比 onnxruntime：那个需运行期 .so，故必须显式 tag）。 ## 顺带修掉的既有缺陷（非 C 化引入，但一直缺覆盖） - Makefile 的 arm64 目标缺 CC/CXX：cgo 回退到宿主 g++，报 `gcc_arm64.S: no such instruction: 'stp x29,x30,[sp,'` （deploy/packaging/build.sh:49 一直是对的，Makefile 漏了） - Makefile 的 arm64 目标缺 .syso 隔离：cmd/{homed,waiter}/*.syso 是 Windows COFF 资源对象，Go 会把同目录 .syso 无条件链进任何目标，交叉到非 Windows 平台报 `file format not recognized`（build.sh 有 hide_syso_for_target） ## 验证（每条可复现） - `make build-linux-arm64` → ELF 64-bit LSB executable, ARM aarch64（82MB） - `bash deploy/packaging/build.sh linux/arm64 homed` → ELF aarch64（79MB） - 移走 csrc/build/ 后 homed（cgo）与 waiter（CGO=0）均能构建 - 变异 C 源（131072→777）后**同一缓存**下 go test 立即 FAIL（改前：仍报 ok） - `make check-codec-paths` 两条路径 OK；`make csrc-test` C 契约测试 100% - 黄金对照：手写用例 + 2000 次随机对拍，C 与纯 Go 逐值相等 - 全量 `go test -count=1 ./...` → 57 包：38 ok + 19 无测试 + 0 FAIL 新增 `make check-codec-paths` 防回归：只测一条路径时，另一条的破坏不会被发现。 ## 文档 - `docs/zh/c-core/llm-orchestration-c.md` 同步为「已落地」，并更正因「Windows 原生已放弃」而过时的 §2.3（回退路径的理由需重述） - plan.md 的 P0-1 标记为已修复，附实测证据
2026-09-27 04:43:11 +00:00 · 2026-09-25 14:45:08 +08:00
parent b6027f3ff8
commit 7351c6ca2e
16 changed files with 1480 additions and 301 deletions
--- a/internal/agent/api/codec.go
+++ b/internal/agent/api/codec.go
@ -0,0 +1,43 @@
+package api
+
+// codec.go —— 编解码层的**统一出口**（无论 CGO 开关如何，调用方只认这里）。
+//
+// 分层：
+//   codec_pure.go  —— 纯 Go 实现，永远参与编译（回退 + 黄金对照基准）
+//   codec_cgo.go   —— CGO_ENABLED=1：真正调 C 库
+//   codec_nocgo.go —— CGO_ENABLED=0：把 C 符号转发到纯 Go
+//   codec.go       —— 本文件：对外的稳定 API，含兜底与日志
+//
+// 这样调用方（provider.go / core）不需要写任何 build tag 分支。
+
+import (
+	"log"
+	"strings"
+)
+
+// ModelContextWindow 返回模型的最大上下文窗口（token 数）。
+//
+// 推断不出时（如 model="AUTO"）记一行日志并回退 defaultInferredContextWindow：
+// 窗口被低估必须可见，部署方用 per-source
+// core.llm.sources.<name>.context_window 显式声明真实值即可覆盖。
+//
+// 标称窗口 ≠ 有效窗口：接近满时注意力涣散，调用方应取 70-80% 为目标利用率。
+func ModelContextWindow(model string) int {
+	if w := modelContextWindowC(model); w != contextWindowUnknown {
+		return w
+	}
+	log.Printf("[provider] 模型 %q 无法推断上下文窗口，回退 %d；"+
+		"若真实窗口更大，请设置 core.llm.sources.<name>.context_window",
+		strings.ToLower(model), defaultInferredContextWindow)
+	return defaultInferredContextWindow
+}
+
+// EstimateTokens 粗略估算 token 数。
+//
+// 注意：这是**高频热路径**（上下文裁剪对每个事件都调）。走 C 的跨语言开销
+// 对短文本未必划算 —— 是否该留在 C 侧由 codec_bench_test.go 的实测数据决定，
+// 不要凭直觉断言（见 docs/zh/c-core/llm-orchestration-c.md §七 未决问题 3）。
+func EstimateTokens(text string) int { return estimateTokensC(text) }
+
+// TruncateByTokens 截断字符串至不超过 maxTokens 估计值。
+func TruncateByTokens(s string, maxTokens int) string { return truncateByTokensC(s, maxTokens) }
--- a/internal/agent/api/codec_cgo.go
+++ b/internal/agent/api/codec_cgo.go
@ -0,0 +1,97 @@
+//go:build cgo
+
+package api
+
+// codec_cgo.go —— 编解码层的 C 实现绑定（CGO_ENABLED=1 时参与编译）。
+//
+// ============================ 架构：包内符号链接 ============================
+// C 源是 `ha_codec.c` / `ha_codec.h`，它们是**指向 csrc/ 的符号链接**
+// （`ln -s ../../../csrc/src/ha_codec.c`）：
+//
+//	internal/agent/api/ha_codec.c -> ../../../csrc/src/ha_codec.c
+//	internal/agent/api/ha_codec.h -> ../../../csrc/include/ha_codec.h
+//
+// 权威源只有一份（csrc/），Go 侧看到的是包目录内的链接。
+//
+// ============================ 为什么不用另外两种做法 ============================
+//
+// **不能链接预构建静态库**（`LDFLAGS: .../csrc/build/libha_codec.a`）：
+//   - .a 是构建产物、不入库（.gitignore 的 build/ 命中 csrc/build/），
+//     而发布脚本原先并不产出它 ⇒「不入库 + 不生成」两头空，链接必然失败
+//     （实测：cannot find csrc/build/libha_codec.a）
+//   - 交叉编译 linux/arm64（homed 的真实发布目标）时，宿主 x86-64 的 .a
+//     被链进目标产物，报 `file in wrong format`（实测）。
+//
+// **不能用 `#include "../../../csrc/src/ha_codec.c"`（包外相对包含）**：
+//   ★ Go 构建缓存**不跟踪包外被 #include 的 C 文件**。实测：在包外源里把
+//   返回值从 7 改成 8，`go test` 依然通过（缓存命中，静默沿用旧代码）；
+//   而同样改动落在包内文件时立刻判红。这对「逐步推进 C 化」是致命的——
+//   改 C 源码却不生效，且无任何报错。
+//   （包内 shim `#include` 包外源同样漏跟踪，已实测排除。）
+//
+// 包内符号链接同时满足两点：文件在包目录内 ⇒ 缓存按内容正确跟踪；
+// 只有一份权威源 ⇒ 无副本漂移，也不需要「同步 C 源」的 make 目标。
+//
+// ============================ 为什么不需要额外 build tag ============================
+// 与 onnxruntime（internal/nlp/onnx.go，需运行期 libonnxruntime.so）不同：
+// ha_codec 是**零依赖纯 C99 源码内联编译**，不需要任何外部库或工具链前提。
+// 而 homed 本就强制 cgo（mattn/go-sqlite3 + gojieba），故 C 路径自然生效。
+// 因此只用 `cgo` / `!cgo` 一组约束，不引入 hacodec tag。
+//
+// ============================ C 侧契约 ============================
+// `#include "ha_codec.h"` 只声明原型；实现在同包的 ha_codec.c，由 cgo 自动编译。
+// 只含 libc 头，不引入第三方符号。
+//
+// 语义必须与 codec_pure.go 逐值等价，由 codec_golden_test.go 钉死。
+
+/*
+#cgo CFLAGS: -std=c99
+#include <stdlib.h>
+#include "ha_codec.h"
+*/
+import "C"
+
+import "unsafe"
+
+// modelContextWindowC 经 C 实现推断上下文窗口。
+func modelContextWindowC(model string) int {
+	cModel := C.CString(model)
+	defer C.free(unsafe.Pointer(cModel))
+	return int(C.ha_codec_model_context_window(cModel))
+}
+
+// estimateTokensC 经 C 实现估算 token 数。
+func estimateTokensC(text string) int {
+	cText := C.CString(text)
+	defer C.free(unsafe.Pointer(cText))
+	return int(C.ha_codec_estimate_tokens(cText))
+}
+
+// truncateByTokensC 经 C 实现按 token 截断。
+//
+// 缓冲区策略：按 rune 数上界分配（每个 rune 最多 4 字节）+ 1 字节 NUL，
+// 保证 C 侧不会因容量不足而截短——否则 C 与 Go 的逐值对照会假失败。
+// 若字符串无 rune（纯 ASCII 也至少 len 字节），取 len(text)+1 兜底。
+func truncateByTokensC(s string, maxTokens int) string {
+	if maxTokens <= 0 || s == "" {
+		return ""
+	}
+	// []rune 的长度即 rune 数；每个 rune 最坏 4 字节，+1 给 NUL。
+	runeCount := len([]rune(s))
+	bufSize := runeCount*4 + 1
+	if bufSize < len(s)+1 {
+		bufSize = len(s) + 1
+	}
+	buf := (*C.char)(C.malloc(C.size_t(bufSize)))
+	if buf == nil {
+		// 分配失败：回退纯 Go 实现，不让整个调用失败。
+		return truncateByTokensPure(s, maxTokens)
+	}
+	defer C.free(unsafe.Pointer(buf))
+
+	cText := C.CString(s)
+	defer C.free(unsafe.Pointer(cText))
+
+	n := C.ha_codec_truncate_by_tokens(cText, C.int(maxTokens), buf, C.size_t(bufSize))
+	return C.GoStringN(buf, C.int(n))
+}
--- a/internal/agent/api/codec_golden_test.go
+++ b/internal/agent/api/codec_golden_test.go
@ -0,0 +1,115 @@
+package api
+
+// codec_golden_test.go —— 黄金对照测试：C 实现与纯 Go 实现必须逐值等价。
+//
+// 这是本轮 C 化**最重要的验收**（见 docs/zh/c-core/llm-orchestration-c.md §五）。
+// 没有它，「C 化没坏」就只是感觉，不是证据。
+//
+// 两条约束：
+//   1. CGO_ENABLED=1 时：真的对比 C 与纯 Go 两条路径
+//   2. CGO_ENABLED=0 时：C 符号已转发到纯 Go，对照退化为自比（仍跑，防止
+//      测试文件因 build tag 被整文件跳过 —— 那会让 0 模式下失去这段覆盖）
+
+import (
+	"math/rand"
+	"strings"
+	"testing"
+)
+
+func TestGolden_ModelContextWindow(t *testing.T) {
+	cases := []string{
+		// 已覆盖的分支各取一个（含大小写、子公司前缀、带路径的模型名）
+		"deepseek/deepseek-v4.1-flash", "deepseek-v4-flash", "DEEPSEEK-V3", "deepseek-r1",
+		"deepseek-chat", "gpt-4-turbo", "gpt-4o-mini", "gpt-4-omni", "gpt-4", "gpt-4-0613",
+		"gpt-3.5-turbo", "claude-3.5-sonnet", "claude-3-opus", "claude-opus-5", "claude-2",
+		"gemini-1.5-pro", "gemini-2.0-flash", "gemini-pro", "qwen-max", "QWEN-MAX",
+		"glm-4", "chatglm3", "llama-3-70b", "llama-2-7b", "mistral-large", "mixtral-8x7b",
+		"yi-34b", "零一万物", "moonshot-v1-128k", "kimi-128k",
+		// 推断不出（哨兵路径）
+		"AUTO", "auto", "", "unknown-model", "some-local-model",
+	}
+	for _, model := range cases {
+		c := modelContextWindowC(model)
+		p := modelContextWindowPure(model)
+		if c != p {
+			t.Errorf("ModelContextWindow(%q): C=%d, pure=%d", model, c, p)
+		}
+	}
+}
+
+// TestGolden_EstimateTokens 覆盖 ASCII / 中文 / emoji / 空 / 长文本。
+func TestGolden_EstimateTokens(t *testing.T) {
+	cases := []string{
+		"", "a", "ab", "abc", "hello world",
+		"你好", "你好世界", "中文English混合", "a你b好c",
+		"😀", "😀😀", "👨‍👩‍👧‍👦", // 含 ZWJ 组合序列（多 rune）
+		strings.Repeat("x", 1000),
+		strings.Repeat("你", 1000),
+		"\n\t\r ", "{}[]()",
+	}
+	for _, s := range cases {
+		c := estimateTokensC(s)
+		p := estimateTokensPure(s)
+		if c != p {
+			t.Errorf("EstimateTokens(%q): C=%d, pure=%d", s, c, p)
+		}
+	}
+}
+
+// TestGolden_TruncateByTokens 覆盖边界：maxTokens 为 0/负/奇数/超限/恰好。
+func TestGolden_TruncateByTokens(t *testing.T) {
+	texts := []string{
+		"", "a", "abc", "abcdefghij",
+		"你好世界", "你好世界再见", "a你b好c世d界",
+		"😀😀😀😀", strings.Repeat("x", 100), strings.Repeat("你", 100),
+	}
+	maxTokensList := []int{-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 20, 100, 200, 201, 1000}
+	for _, s := range texts {
+		for _, mt := range maxTokensList {
+			c := truncateByTokensC(s, mt)
+			p := truncateByTokensPure(s, mt)
+			if c != p {
+				t.Errorf("TruncateByTokens(%q, %d): C=%q, pure=%q", s, mt, c, p)
+			}
+			// 额外不变量：结果必须是原串前缀，且不超过预算
+			if !strings.HasPrefix(s, c) && c != "" {
+				t.Errorf("TruncateByTokens(%q, %d)=%q 不是原串前缀", s, mt, c)
+			}
+		}
+	}
+}
+
+// TestGolden_Randomized 随机输入对拍：抓前面手写用例没想到的组合。
+// 固定 seed，失败可复现。
+func TestGolden_Randomized(t *testing.T) {
+	rng := rand.New(rand.NewSource(20260924))
+	alphabet := []rune("abcXYZ019 你好世界😀-_./")
+
+	for i := 0; i < 2000; i++ {
+		n := rng.Intn(40)
+		var sb strings.Builder
+		for j := 0; j < n; j++ {
+			sb.WriteRune(alphabet[rng.Intn(len(alphabet))])
+		}
+		s := sb.String()
+
+		if c, p := estimateTokensC(s), estimateTokensPure(s); c != p {
+			t.Fatalf("EstimateTokens(%q): C=%d, pure=%d", s, c, p)
+		}
+
+		mt := rng.Intn(60) - 5
+		if c, p := truncateByTokensC(s, mt), truncateByTokensPure(s, mt); c != p {
+			t.Fatalf("TruncateByTokens(%q, %d): C=%q, pure=%q", s, mt, c, p)
+		}
+
+		// 模型名：拼一段 ASCII 再随机插入已知子串
+		models := []string{"deepseek-v4", "gpt-4-turbo", "claude-3", "qwen", "llama-3", "kimi", "zzz"}
+		m := models[rng.Intn(len(models))]
+		if rng.Intn(2) == 0 {
+			m = strings.ToUpper(m)
+		}
+		if c, p := modelContextWindowC(m), modelContextWindowPure(m); c != p {
+			t.Fatalf("ModelContextWindow(%q): C=%d, pure=%d", m, c, p)
+		}
+	}
+}
--- a/internal/agent/api/codec_nocgo.go
+++ b/internal/agent/api/codec_nocgo.go
@ -0,0 +1,22 @@
+//go:build !cgo
+
+package api
+
+// codec_nocgo.go —— CGO_ENABLED=0 时把 C 路径的符号指向纯 Go 实现。
+//
+// 为什么需要这层转发而不是直接调 *Pure：让 codec.go 无论编译开关如何都能引用
+// 同一组符号名，避免调用方到处写 build tag 分支。
+//
+// 谁会走到这里（CGO_ENABLED=0）：
+//   - waiter 等刻意 CGO-free 的跨平台目标（Makefile build-cli）
+//   - 交叉编译到无 cgo 工具链的场景
+//
+// homed 不会走到这里——它强制 cgo（sqlite3 + gojieba）。
+// 两条路径的语义等价由 codec_golden_test.go 钉死，Makefile 的
+// check-codec-paths 目标同时跑两条。
+
+func modelContextWindowC(model string) int { return modelContextWindowPure(model) }
+
+func estimateTokensC(text string) int { return estimateTokensPure(text) }
+
+func truncateByTokensC(s string, maxTokens int) string { return truncateByTokensPure(s, maxTokens) }
--- a/internal/agent/api/codec_pure.go
+++ b/internal/agent/api/codec_pure.go
@ -0,0 +1,103 @@
+package api
+
+// codec_pure.go —— 编解码层的**纯 Go 实现**，永远参与编译。
+//
+// 它有两个身份：
+//   1. CGO_ENABLED=0 时的生产实现（Windows 包走这里，见
+//      deploy/packaging/package-windows.sh:69）
+//   2. CGO_ENABLED=1 时**黄金对照的基准**（codec_golden_test.go 用同一组输入
+//      对比它与 C 实现，逐值必须相等）
+//
+// 因此本文件**不带 build tag**——两条路径都要能见到它。
+
+import "strings"
+
+// defaultInferredContextWindow 是模型名无法推断窗口时的兜底。
+//
+// 32768 是个保守值，但它属于**静默降级**：模型名写 AUTO（网关自己选上游）时
+// 匹配不到任何分支，内核就会拿着一份比真实小得多的窗口去算全部预算
+// （实测：deepseek-v4.1-flash 能吞 990,034 token，而预算按 32768 算）。
+// 兜底值本身不猜大：猜大会让请求直接撞上游 400。
+const defaultInferredContextWindow = 32768
+
+// contextWindowUnknown 是「模型名推断不出窗口」的哨兵值。
+//
+// 与 C 侧 HA_CODEC_CONTEXT_WINDOW_UNKNOWN 取值必须一致。
+// 用哨兵而非直接返回兜底值：调用方要能区分「真推断出了」与
+// 「推断不出、只能兜底」——后者必须记日志，让窗口被低估这件事可见。
+const contextWindowUnknown = -1
+
+// modelContextWindowPure 由模型名推断最大上下文窗口；推断不出返回哨兵。
+// 标称窗口 ≠ 有效窗口：接近满时注意力涣散，调用方应取 70-80% 为目标利用率。
+func modelContextWindowPure(model string) int {
+	model = strings.ToLower(model)
+	switch {
+	case strings.Contains(model, "deepseek-v4") || strings.Contains(model, "deepseek-v3"):
+		return 1048576
+	case strings.Contains(model, "deepseek-r1") || strings.Contains(model, "deepseek-chat"):
+		return 65536
+	case strings.Contains(model, "gpt-4") && (strings.Contains(model, "turbo") || strings.Contains(model, "mini") || strings.Contains(model, "omni")):
+		return 128000
+	case strings.Contains(model, "gpt-4"):
+		return 8192
+	case strings.Contains(model, "gpt-3.5"):
+		return 16384
+	case strings.Contains(model, "claude-3.5") || strings.Contains(model, "claude-3"):
+		return 200000
+	case strings.Contains(model, "claude"):
+		return 100000
+	case strings.Contains(model, "gemini-1.5") || strings.Contains(model, "gemini-2"):
+		return 1048576
+	case strings.Contains(model, "gemini"):
+		return 32768
+	case strings.Contains(model, "qwen"):
+		return 131072
+	case strings.Contains(model, "glm") || strings.Contains(model, "chatglm"):
+		return 131072
+	case strings.Contains(model, "llama-3"):
+		return 8192
+	case strings.Contains(model, "llama-2"):
+		return 4096
+	case strings.Contains(model, "mistral") || strings.Contains(model, "mixtral"):
+		return 32768
+	case strings.Contains(model, "yi-") || strings.Contains(model, "零一"):
+		return 200000
+	case strings.Contains(model, "moonshot") || strings.Contains(model, "kimi"):
+		return 131072
+	default:
+		return contextWindowUnknown
+	}
+}
+
+// estimateTokensPure 粗略估算 token 数。
+// 中文 ~1.5 token/字，英文 ~0.3 token/字符，保守估计取 max(1, runeCount * 2)。
+func estimateTokensPure(text string) int {
+	if text == "" {
+		return 0
+	}
+	runeCount := len([]rune(text))
+	if runeCount == 0 {
+		return 0
+	}
+	t := runeCount * 2
+	if t < 1 {
+		return 1
+	}
+	return t
+}
+
+// truncateByTokensPure 截断字符串至不超过 maxTokens 估计值。
+func truncateByTokensPure(s string, maxTokens int) string {
+	if maxTokens <= 0 || s == "" {
+		return ""
+	}
+	runes := []rune(s)
+	if len(runes)*2 <= maxTokens {
+		return s
+	}
+	keep := maxTokens / 2
+	if keep >= len(runes) {
+		return s
+	}
+	return string(runes[:keep])
+}
--- a/internal/agent/api/ha_codec.c
+++ b/internal/agent/api/ha_codec.c
@ -0,0 +1 @@
+../../../csrc/src/ha_codec.c
--- a/internal/agent/api/ha_codec.h
+++ b/internal/agent/api/ha_codec.h
@ -0,0 +1 @@
+../../../csrc/include/ha_codec.h
--- a/internal/agent/api/provider.go
+++ b/internal/agent/api/provider.go
@ -260,61 +260,9 @@ func ProviderSupportsAudio(p Provider) bool {
 	return false
 }

-// defaultInferredContextWindow 是模型名无法推断窗口时的兜底。
-//
-// 32768 是个保守值，但它属于**静默降级**：模型名写 AUTO（网关自己选上游）时
-// ModelContextWindow 匹配不到任何分支，内核就会拿着一份比真实小得多的窗口
-// 去算全部预算（实测：deepseek-v4.1-flash 能吞 990,034 token，而预算按 32768 算）。
-// 因此推断不出来时留一条日志，并让部署方用 per-source context_window 显式声明。
-const defaultInferredContextWindow = 32768
-
-// ModelContextWindow 返回模型的最大上下文窗口（token 数）
-// 标称窗口 ≠ 有效窗口：接近满时注意力涣散，调用方应取 70-80% 为目标利用率
-func ModelContextWindow(model string) int {
-	model = strings.ToLower(model)
-	switch {
-	case strings.Contains(model, "deepseek-v4") || strings.Contains(model, "deepseek-v3"):
-		return 1048576
-	case strings.Contains(model, "deepseek-r1") || strings.Contains(model, "deepseek-chat"):
-		return 65536
-	case strings.Contains(model, "gpt-4") && (strings.Contains(model, "turbo") || strings.Contains(model, "mini") || strings.Contains(model, "omni")):
-		return 128000
-	case strings.Contains(model, "gpt-4"):
-		return 8192
-	case strings.Contains(model, "gpt-3.5"):
-		return 16384
-	case strings.Contains(model, "claude-3.5") || strings.Contains(model, "claude-3"):
-		return 200000
-	case strings.Contains(model, "claude"):
-		return 100000
-	case strings.Contains(model, "gemini-1.5") || strings.Contains(model, "gemini-2"):
-		return 1048576
-	case strings.Contains(model, "gemini"):
-		return 32768
-	case strings.Contains(model, "qwen"):
-		return 131072
-	case strings.Contains(model, "glm") || strings.Contains(model, "chatglm"):
-		return 131072
-	case strings.Contains(model, "llama-3"):
-		return 8192
-	case strings.Contains(model, "llama-2"):
-		return 4096
-	case strings.Contains(model, "mistral") || strings.Contains(model, "mixtral"):
-		return 32768
-	case strings.Contains(model, "yi-") || strings.Contains(model, "零一"):
-		return 200000
-	case strings.Contains(model, "moonshot") || strings.Contains(model, "kimi"):
-		return 131072
-	default:
-		// 模型名推断不出窗口（如 "AUTO"）：不要静静退回一个比真实小得多的值。
-		// 报一行日志，让“窗口被低估”这件事可见；部署方用 per-source
-		// core.llm.sources.<name>.context_window 声明真实值即可覆盖。
-		log.Printf("[provider] 模型 %q 无法推断上下文窗口，回退 %d；"+
-			"若真实窗口更大，请设置 core.llm.sources.<name>.context_window",
-			model, defaultInferredContextWindow)
-		return defaultInferredContextWindow
-	}
-}
+// defaultInferredContextWindow 与 ModelContextWindow 已移至 codec.go /
+// codec_pure.go（编解码层 C 化，见 docs/zh/c-core/llm-orchestration-c.md）。
+// 这里不再重复定义，避免两份实现漂移。

 type BaseConfig struct {
 	Model         string  `json:"model"`