企业官网建设流程全解析

1. 从直播日志到 JSONL：DeepSWE 62 分调用链先拆字段

当你在终端里 tail 一场 Agentic RL 后训练直播留下的 JSONL，第一眼看到的往往不是某个分数，而是混在一起的字段：model、task、tool、reward、latency、cost、trace_id。社区底稿里提到，小米直播中对mimo-v2.6-pro和flash做 Agentic RL 后训练，DeepSWE 一项mimo-v2.6-pro是 62，另一个 flash 模型是 74.2，作者按直播窗口推算每秒约 10 美元。这些数字更适合当作“日志阅读背景”，而不是最终榜单结论。真正可复现的动作是：先把日志整理成可被jq稳定查询的 JSONL，再把模型调用接到 TaoToken 网关做对照。准备jq解析日志时，我会先到 TaoToken 官网 https://taotoken.net/?utm_source=taotoken_aicg_blog_end&utm_content=deepswe62_intro 获取 API Key，并把请求 Base URL 设为https://taotoken.net/api。这一步不是为了把训练日志换成另一个黑盒，而是为了给“模型调用”建立一条可追踪、可过滤、可复盘的请求侧关联键。

读 DeepSWE 62 分模型调用日志，最容易犯的错误是把所有行都当成同一种事件。Agentic RL 后训练日志通常至少有四层：

1. 训练事件层：rollout、reward、advantage、kl、clip、optimizer step。
2. 模型调用层：每次模型生成请求的模型名、prompt tokens、completion tokens、latency、request_id。
3. 工具调用层：Agent 执行 bash、python、文件读写、浏览器动作后的返回码、耗时、错误。
4. 评分与成本层：DeepSWE 分数、任务通过率、成本估算、每秒烧钱速率。

如果你用grep "62"去捞日志，会把时间戳里的 62、Token 数里的 62、随机 ID 里的 62 全部捞出来，最后得不到调用链。正确做法是先统一 JSONL，再按事件类型过滤。下面是一段最小的环境准备：

mkdir -p ~/deepswe-log && cd ~/deepswe-log export TAOTOKEN_API_KEY="YOUR_API_KEY" export TAOTOKEN_BASE_URL="https://taotoken.net/api"

这里TAOTOKEN_BASE_URL固定为https://taotoken.net/api，不要在后面附加查询参数，也不要带 UTM。UTM 只用于官网入口和文档跳转，工具配置里的 Base URL 必须保持干净。Key 占位符统一用YOUR_API_KEY，真实 Key 只放在本机环境变量或密钥管理工具里，不要写进日志文件。

如果你要在请求侧留下和训练日志一致的关联 ID，可以在调用模型时带上自己的x-trace-id，再把网关返回的 request id 写入模型调用日志。示例：

TRACE_ID="deepswe62-$(date +%s)-001" curl -sS "$TAOTOKEN_BASE_URL/chat/completions" \ -H "Authorization: Bearer $TAOTOKEN_API_KEY" \ -H "Content-Type: application/json" \ -H "x-trace-id: $TRACE_ID" \ -d '{ "model": "YOUR_MODEL_ID", "messages": [ {"role": "system", "content": "You are an agentic coding evaluator."}, {"role": "user", "content": "Read the local log and summarize tool errors."} ], "stream": false }' | jq .

如果当前 SDK 要求 Base URL 后追加版本路径，以 TaoToken 控制台或文档显示为准；但本机配置中仍然以https://taotoken.net/api作为供应商 Base URL 的主值。把请求跑通之后，再回到日志侧做jq查询，顺序不要反。

2. 让 jq 有稳定输入：把 Agentic RL 日志规范成 JSONL

jq的强项是处理结构化 JSON，不是靠正则猜文本。因此第一步不是写复杂过滤器，而是把日志规范成每行一个 JSON 对象。你可以保留原始日志，另存一份清洗后的 JSONL。建议每条模型调用至少包含这些字段：

{ "ts": "2026-04-20T10:00:00Z", "event": "model_call", "trace_id": "deepswe62-001", "span_id": "span-001", "parent_span_id": "root", "model": "mimo-v2.6-pro", "task": "DeepSWE", "score": 62, "tool": null, "latency_ms": 1812, "prompt_tokens": 4096, "completion_tokens": 512, "error": null, "request_id": "req_xxx" }

工具调用可以另起一行：

{ "ts": "2026-04-20T10:00:03Z", "event": "tool_call", "trace_id": "deepswe62-001", "span_id": "span-002", "parent_span_id": "span-001", "model": "mimo-v2.6-pro", "task": "DeepSWE", "score": null, "tool": "bash", "latency_ms": 224, "prompt_tokens": 0, "completion_tokens": 0, "error": null, "request_id": "req_xxx" }

评分事件可以这样：

{ "ts": "2026-04-20T10:03:00Z", "event": "score", "trace_id": "deepswe62-001", "span_id": "span-009", "parent_span_id": "root", "model": "mimo-v2.6-pro", "task": "DeepSWE", "score": 62, "tool": null, "latency_ms": 0, "prompt_tokens": 0, "completion_tokens": 0, "error": null, "request_id": null }

清洗时，你不需要一次写完整套解析器。先用jq -c把每行压成单行 JSON，再补默认字段。下面命令适合本地执行，不连接任何生产库：

# 假设 raw.log 里混有文本和 JSON 行，先只提取以 { 开头的行 grep '^{' raw.log > raw-jsonl.log # 给缺失字段补默认值，统一输出到 agentic-rl.jsonl jq -c ' . + { event: (.event // "unknown"), trace_id: (.trace_id // "no-trace"), model: (.model // "unknown"), task: (.task // "unknown"), score: (.score // null), tool: (.tool // null), latency_ms: (.latency_ms // 0), prompt_tokens: (.prompt_tokens // 0), completion_tokens: (.completion_tokens // 0), error: (.error // null) } ' raw-jsonl.log > agentic-rl.jsonl wc -l agentic-rl.jsonl

此时你得到的是可被jq稳定处理的日志。再看 DeepSWE 62，就不会被文本里的杂音干扰。比如查看任务分布：

jq -r '.task' agentic-rl.jsonl | sort | uniq -c | sort -nr

查看模型分布：

jq -r '.model' agentic-rl.jsonl | sort | uniq -c | sort -nr

这一步的产出看似简单，但它决定了后面的过滤是否可复现。如果没有统一 JSONL，任何“DeepSWE 62 调用日志摘要”都只是一次性的人工浏览，无法在训练继续跑、日志继续追加时复用。

3. jq 过滤命令：抽出 DeepSWE 62 的模型调用与工具链

现在进入核心部分。我们关心三个问题：哪些调用属于 DeepSWE 任务，哪些调用落在mimo-v2.6-pro或 flash 对照模型上，哪些工具调用最终影响了 62 这个分数。下面是一组可复现的jq命令。

先过滤出 DeepSWE 相关调用，并保留关键字段：

jq -c ' select(.task == "DeepSWE") | select(.event == "model_call" or .event == "tool_call" or .event == "score") | { ts, event, trace_id, span_id, parent_span_id, model, task, tool, score, latency_ms, error, request_id } ' agentic-rl.jsonl > deepswe62-calls.jsonl wc -l deepswe62-calls.jsonl head -n 5 deepswe62-calls.jsonl

再按模型汇总调用量、工具调用量、平均延迟和分数范围：

jq -s ' group_by(.model) | map({ model: .[0].model, total_events: length, model_calls: (map(select(.event == "model_call")) | length), tool_calls: (map(select(.event == "tool_call")) | length), avg_latency_ms: ( (map(.latency_ms // 0) | add) / length ), max_score: (map(.score // empty) | max), min_score: (map(.score // empty) | min), last_score: (map(.score // empty) | last) }) ' deepswe62-calls.jsonl

如果你只想看 trace 级别，把一次 DeepSWE 任务的所有 span 聚起来，找延迟最高或工具调用最多的调用链：

jq -s ' map(select(.task == "DeepSWE")) | group_by(.trace_id) | map({ trace_id: .[0].trace_id, models: (map(.model) | unique), score: (map(.score // empty) | last), tool_steps: (map(select(.event == "tool_call")) | length), model_steps: (map(select(.event == "model_call")) | length), total_latency_ms: (map(.latency_ms // 0) | add), errors: (map(select(.error != null)) | length) }) | sort_by(.total_latency_ms) | reverse | .[0:10] ' agentic-rl.jsonl

然后专门抽score == 62的调用链：

jq -c ' select(.task == "DeepSWE" and .score == 62) | { trace_id, model, event, tool, latency_ms, error, request_id } ' agentic-rl.jsonl

如果你还在对照 flash 的 74.2 分数，不要直接把两个数字放在同一张“排名表”里，而应做条件对照：同一任务、同一工具集、同一评测版本、同一时间窗口。命令可以写成：

jq -s ' map(select(.task == "DeepSWE")) | group_by(.model) | map({ model: .[0].model, trace_count: (map(.trace_id) | unique | length), score_seen: (map(.score // empty) | unique), avg_tool_steps: ( (map(select(.event == "tool_call")) | length) / (map(.trace_id) | unique | length) ), avg_latency_ms: ( (map(.latency_ms // 0) | add) / length ) }) ' agentic-rl.jsonl

一个可复现的 DeepSWE 62 调用日志摘要大概长这样：

{ "task": "DeepSWE", "model_under_watch": "mimo-v2.6-pro", "score_seen": 62, "compare_model_hint": "flash 的 74.2 只作对照，不作最终排名", "total_events": 128, "model_calls": 31, "tool_calls": 97, "avg_latency_ms": 1834, "error_count": 3, "top_error_tool": "bash", "cost_watch": { "source_note": "直播底稿作者按窗口推算每秒约 10 美元，仅用于设置告警阈值，不等于最终账单", "threshold_suggestion": "当每秒成本估算超过 10 美元时，先看 trace 级工具重试" } }

这个摘要的价值在于：它把 62 分拆成了调用次数、工具步骤、延迟和错误数，而不是只留下一个分数。下一步再接 TaoToken，就可以用同一套jq查询对比不同供应商下的请求表现。

4. TaoToken Key 与 Base URL：请求侧配置和日志侧关联

如果你已经准备好jq解析日志，接下来要处理 Key 和 Base URL。申请 Key 的步骤不要从直播弹幕或第三方截图里找入口，直接到 TaoToken 官网 https://taotoken.net/?utm_source=taotoken_aicg_blog_end&utm_content=deepswe62_key_console 进入控制台创建 API Key。创建后，本机只保留占位符替换，不要把真实 Key 提交到 Git。

推荐的环境变量写法：

export TAOTOKEN_API_KEY="YOUR_API_KEY" export TAOTOKEN_BASE_URL="https://taotoken.net/api"

注意两点：

1. Base URL 不加 UTM。官网链接可以带utm_source和utm_content，但工具配置里的base_url必须是https://taotoken.net/api。
2. Key 不进日志。如果你在请求日志里记录 header，先脱敏，只记录Authorization: Bearer YOUR_API_KEY或只记录 Key 后四位。

请求侧关联日志侧的做法是：在发起模型调用时生成trace_id，把网关返回的request_id写入 JSONL。这样你用jq过滤 DeepSWE 62 时，就能同时看到：

• 哪一次模型调用属于哪个 trace；
• 这次调用用了哪个模型；
• 工具调用是串行还是并行；
• 失败后是否重试；
• 重试是否把每秒成本推高。

一个本地验证请求可以这样写：

TRACE_ID="deepswe62-check-$(date +%s)" curl -sS "$TAOTOKEN_BASE_URL/chat/completions" \ -H "Authorization: Bearer $TAOTOKEN_API_KEY" \ -H "Content-Type: application/json" \ -H "x-trace-id: $TRACE_ID" \ -d '{ "model": "YOUR_MODEL_ID", "messages": [ {"role": "user", "content": "Return a JSON object with keys: ok, model, trace_id."} ], "temperature": 0, "stream": false }' | jq .

如果返回结构正常，再把这个request_id补进日志：

jq -c ' if .trace_id == "'"$TRACE_ID"'" then . + {"request_id": "REPLACE_WITH_RESPONSE_ID"} else . end ' agentic-rl.jsonl > agentic-rl.with-request-id.jsonl

然后把deepswe62-calls.jsonl重新生成一遍，确保过滤链路包含request_id。这时你读日志的顺序就变成了：先看 DeepSWE 任务，再看模型调用，再看工具调用，最后看成本窗口。DeepSWE 62 不再是一个孤立数字，而是一条可以回溯的调用链。

5. Claude Code settings.json：只让 Claude Code 读 ANTHROPIC_*

Claude Code 的配置走settings.json和ANTHROPIC_*环境变量，不要把这一套写到 Codex 的config.toml里。你可以在 TaoToken 官网 https://taotoken.net/?utm_source=taotoken_aicg_blog_end&utm_content=deepswe62_claude_json 获取 Key 后，按下面方式配置。示例中的模型名用YOUR_CLAUDE_CODE_MODEL占位，实际以控制台可用模型为准。

{ "env": { "ANTHROPIC_BASE_URL": "https://taotoken.net/api", "ANTHROPIC_AUTH_TOKEN": "YOUR_API_KEY", "ANTHROPIC_MODEL": "YOUR_CLAUDE_CODE_MODEL", "ANTHROPIC_SMALL_FAST_MODEL": "YOUR_FAST_MODEL" }, "permissions": { "allow": [ "Read", "Bash(jq:*)", "Bash(grep:*)", "Bash(wc:*)" ] } }

保存位置通常是你本机的 Claude Code 配置目录。配置完成后，启动前可以再用 shell 覆盖一次：

export ANTHROPIC_BASE_URL="https://taotoken.net/api" export ANTHROPIC_AUTH_TOKEN="$TAOTOKEN_API_KEY"

验证 Claude Code 是否读到配置：

claude --version claude "请只回复当前 Base URL 的主机名"

然后回到日志侧，用jq查看 Claude Code 产生的调用是否进入model_call：

jq -c ' select(.event == "model_call") | select(.model | test("claude|YOUR_CLAUDE_CODE_MODEL"; "i")) | {ts, trace_id, model, latency_ms, prompt_tokens, completion_tokens, error} ' agentic-rl.jsonl | tail -n 20

如果你在日志里看到ANTHROPIC_BASE_URL被写进了 Codex 配置，说明配置串了。Claude Code 用ANTHROPIC_*，Codex 用config.toml，两者不要互相复制。

6. Codex config.toml：不要混入 ANTHROPIC_*

Codex 的配置走config.toml。到 TaoToken 官网 https://taotoken.net/?utm_source=taotoken_aicg_blog_end&utm_content=deepswe62_codex_toml 获取 Key 后，可以按下面的字段骨架配置。注意：Codex 不读ANTHROPIC_BASE_URL、ANTHROPIC_AUTH_TOKEN，不要把这些变量塞进config.toml。

model = "YOUR_CODEX_MODEL" model_provider = "taotoken" approval_policy = "on-request" [model_providers.taotoken] name = "TaoToken" base_url = "https://taotoken.net/api" env_key = "TAOTOKEN_API_KEY" wire_api = "chat"

本机环境变量：

export TAOTOKEN_API_KEY="YOUR_API_KEY"

如果你使用的 Codex 版本对wire_api或模型提供商字段有差异，以你本地codex --help和 TaoToken 文档为准；但核心三件事不变：供应商名、Base URL、Key 环境变量。Base URL 仍然是https://taotoken.net/api，不要带 UTM。

验证 Codex 是否读到配置：

codex --version codex "只输出一个 JSON：{\"ok\":true}"

日志侧查询 Codex 产生的调用：

jq -c ' select(.event == "model_call") | select(.model | test("codex|YOUR_CODEX_MODEL"; "i")) | {ts, trace_id, model, latency_ms, prompt_tokens, completion_tokens, error} ' agentic-rl.jsonl | tail -n 20

如果 Codex 调用失败，先查三处：

1. env_key = "TAOTOKEN_API_KEY"是否和 shell 里的环境变量同名；
2. base_url是否误写成带/v1、带 UTM 或带空格的字符串；
3. 是否把 Claude Code 的ANTHROPIC_*变量误当成 Codex 配置。

这三步能排除大部分“配置看起来对，但请求发不出去”的问题。

7. CC Switch 三件套：供应商条目、Claude 配置、Codex 配置

如果你用 CC Switch 管理多个供应商，核心是“三件套”分别落到正确位置。不同版本的 CC Switch 字段名可能不同，但结构可以抽象成下面三类。

第一件：供应商条目。里面必须有名称、Base URL、Key、可用模型。示例仅表达字段关系：

{ "name": "TaoToken", "baseUrl": "https://taotoken.net/api", "apiKey": "YOUR_API_KEY", "models": { "claude": "YOUR_CLAUDE_CODE_MODEL", "codex": "YOUR_CODEX_MODEL" } }

第二件：Claude Code 配置文件。它接收ANTHROPIC_BASE_URL、ANTHROPIC_AUTH_TOKEN、ANTHROPIC_MODEL。示例：

{ "env": { "ANTHROPIC_BASE_URL": "https://taotoken.net/api", "ANTHROPIC_AUTH_TOKEN": "YOUR_API_KEY", "ANTHROPIC_MODEL": "YOUR_CLAUDE_CODE_MODEL" } }

第三件：Codex 配置文件。它接收config.toml里的model_provider、base_url、env_key。示例：

model = "YOUR_CODEX_MODEL" model_provider = "taotoken" [model_providers.taotoken] name = "TaoToken" base_url = "https://taotoken.net/api" env_key = "TAOTOKEN_API_KEY" wire_api = "chat"

三件套的切换顺序建议是：

1. 先在 CC Switch 里选中 TaoToken 供应商；
2. 确认 Claude Code 读的是ANTHROPIC_*；
3. 确认 Codex 读的是config.toml；
4. 分别运行一次最小请求；
5. 最后再用jq查日志。

日志验证命令可以统一成：

jq -c ' select(.event == "model_call") | { ts, trace_id, model, provider: (.provider // "unknown"), latency_ms, error } ' agentic-rl.jsonl | tail -n 30

如果日志里provider仍然显示旧供应商，说明 CC Switch 只改了界面，没有落到对应配置文件。此时回到三件套逐项核对，不要继续在日志层猜。

8. 读摘要而不是读情绪：DeepSWE 62 与 flash 74.2 的 jq 视角

社区直播底稿里最容易引发情绪的是分数对比：mimo-v2.6-pro的 DeepSWE 为 62，flash 为 74.2，作者推算每秒约 10 美元，且判断还在训练早期。读日志时，你要把这些信息拆成三类：

• 事实输入：日志里确实出现了哪些模型、任务、分数、工具调用、延迟、错误。
• 推断输入：每秒成本是作者按直播窗口推算，不是最终账单；74.2 是同一评测版本下的对照，不是永久排名。
• 行动输入：当成本告警触发时，先看哪些 trace 在重试工具，哪些模型调用拉高了延迟。

用jq做一份更像“排障摘要”的输出：

jq -s ' map(select(.task == "DeepSWE")) | { total_traces: (map(.trace_id) | unique | length), models: (map(.model) | unique), scores: (map(.score // empty) | unique), tool_errors: ( map(select(.event == "tool_call" and .error != null)) | group_by(.tool) | map({tool: .[0].tool, count: length}) ), slowest_model_calls: ( map(select(.event == "model_call")) | sort_by(.latency_ms) | reverse | .[0:5] | map({trace_id, model, latency_ms, prompt_tokens, completion_tokens}) ) } ' agentic-rl.jsonl

这份摘要不会告诉你“哪个模型一定更强”，但会告诉你：

• 62 分对应的 trace 是否伴随大量工具错误；
• flash 的 74.2 是否在同一批任务、同一工具集下取得；
• 每秒约 10 美元的成本推算是否集中在少数长链路 trace；
• 接入 TaoToken 后，相同jq查询下请求延迟、失败率、重试次数是否变化。

如果你要把 TaoToken 接入现有 Agentic RL 工作流，建议保留两套 Key：一套用于日志阅读和人工验证，一套用于自动化任务。两套都从 TaoToken 官网获取，不要把 Key 写进deepswe62-calls.jsonl。请求侧 Base URL 始终是https://taotoken.net/api，工具配置里不要加 UTM。

最后给一个最小闭环：

# 1. 过滤 DeepSWE 62 调用链 jq -c 'select(.task=="DeepSWE" and .score==62) | {trace_id,model,tool,latency_ms,error}' agentic-rl.jsonl > deepswe62-score62.jsonl # 2. 汇总模型调用 jq -s 'group_by(.model) | map({model:.[0].model, calls:length, avg_latency_ms:((map(.latency_ms // 0)|add)/length)})' deepswe62-calls.jsonl # 3. 查看工具错误 jq -s 'map(select(.event=="tool_call" and .error!=null)) | group_by(.tool) | map({tool:.[0].tool, errors:length})' deepswe62-calls.jsonl # 4. 查看成本告警窗口 jq -s 'map(select(.event=="model_call")) | {calls:length, total_prompt_tokens:(map(.prompt_tokens // 0)|add), total_completion_tokens:(map(.completion_tokens // 0)|add)}' deepswe62-calls.jsonl

当你能稳定产出这些摘要，再去看 DeepSWE 62、flash 74.2 和每秒约 10 美元的推算，就不会被单一数字带着跑。日志阅读的目标是还原调用链，而不是给训练早期下终局判断。

文末按这条路径继续：先到模型对话验证一次请求，再选 Coding Plan，然后创建 API Key，最后按 Claude Code 文档完成工具配置。

1. 模型对话：https://taotoken.net/models/detail/chat?utm_source=taotoken_aicg_blog_end&utm_content=deepswe62_chat
2. Coding Plan：https://taotoken.net/coding-plan?utm_source=taotoken_aicg_blog_end&utm_content=deepswe62_coding_plan
3. 创建 API Key：https://taotoken.net/console/api-keys?utm_source=taotoken_aicg_blog_end&utm_content=deepswe62_api_keys
4. Claude Code 文档：https://taotoken.net/doc/ClaudeCodeAnthropic?utm_source=taotoken_aicg_blog_end&utm_content=deepswe62_claude_code_doc