@xiaobuyu/nodesign 0.0.1 → 0.0.2

package/server/lib/ingress/upstream-billing.js

@@ -1,52 +1,52 @@
-/**
- * lib/ingress/upstream-billing.js —— 上游**自报**的费用/用量，按会话 × appModel 累加，供回合结账取走。
- *
- * 背景（08-21 晚）：Zen 的 /zen/go 入口每个响应带 `cost`（美元字符串；流式在 [DONE] 之后补一条
- * {"choices":[],"cost":"…"}）和 usage.prompt_tokens_details.cached_tokens。我们原来的仪表是
- * "SDK 按 alias 的 Claude 价目算 → reprice 按表价重算"，CLI 失败时还按字符估算 —— 假表。
- * 上游报了真数就用真数：ingress 每次往返 note 一笔，session-loop 在 absorbResult 之后 take 走本轮累计，
- * 覆盖 counters.modelUsage[appModel].costUsd（context.applyUpstreamBilling）。
- *
- * 只覆盖 cost，token 数仍以 SDK 的 modelUsage 差分为准（两边口径不同：OpenAI 的 prompt_tokens 含缓存命中）；
- * SDK 没给该模型条目时（CLI 失败 / helper），用上游 token 数补一条，别让这笔钱无家可归。
- * 上游没报 cost（cost 为 null）就不动任何东西 —— 假数据比没有更坏。
- */
-
-export class UpstreamBilling {
-  constructor() { this.map = new Map(); }   // sid → Map<appModel, acc>
-  /**
-   * @param {string} sid
-   * @param {string} appModel
-   * @param {{ costUsd?: number|null, usage?: object|null }} info
-   */
-  note(sid, appModel, { costUsd = null, usage = null } = {}) {
-    if (!sid || !appModel) return;
-    const c = costUsd == null || !Number.isFinite(Number(costUsd)) ? null : Number(costUsd);
-    if (c == null && !usage) return;
-    let per = this.map.get(sid);
-    if (!per) { per = new Map(); this.map.set(sid, per); }
-    const acc = per.get(appModel) || { costUsd: null, responses: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, reasoningTokens: 0 };
-    acc.responses += 1;
-    if (c != null) acc.costUsd = (acc.costUsd || 0) + c;
-    if (usage) {
-      acc.promptTokens += Number(usage.prompt_tokens) || 0;
-      acc.completionTokens += Number(usage.completion_tokens) || 0;
-      acc.cachedTokens += Number(usage.prompt_tokens_details?.cached_tokens) || 0;
-      acc.reasoningTokens += Number(usage.completion_tokens_details?.reasoning_tokens) || 0;
-    }
-    per.set(appModel, acc);
-  }
-  /** 取走并清零该会话的累计：{ appModel → acc }；没有 → null */
-  take(sid) {
-    const per = sid ? this.map.get(sid) : null;
-    if (!per) return null;
-    this.map.delete(sid);
-    return Object.fromEntries(per);
-  }
-  peek(sid) { const per = this.map.get(sid); return per ? Object.fromEntries(per) : null; }
-  clear(sid) { if (sid) this.map.delete(sid); else this.map.clear(); }
-}
-
-export const upstreamBilling = new UpstreamBilling();
-export const noteUpstreamBilling = (sid, appModel, info) => upstreamBilling.note(sid, appModel, info);
-export const takeUpstreamBilling = (sid) => upstreamBilling.take(sid);
+/**
+ * lib/ingress/upstream-billing.js —— 上游**自报**的费用/用量，按会话 × appModel 累加，供回合结账取走。
+ *
+ * 背景（08-21 晚）：Zen 的 /zen/go 入口每个响应带 `cost`（美元字符串；流式在 [DONE] 之后补一条
+ * {"choices":[],"cost":"…"}）和 usage.prompt_tokens_details.cached_tokens。我们原来的仪表是
+ * "SDK 按 alias 的 Claude 价目算 → reprice 按表价重算"，CLI 失败时还按字符估算 —— 假表。
+ * 上游报了真数就用真数：ingress 每次往返 note 一笔，session-loop 在 absorbResult 之后 take 走本轮累计，
+ * 覆盖 counters.modelUsage[appModel].costUsd（context.applyUpstreamBilling）。
+ *
+ * 只覆盖 cost，token 数仍以 SDK 的 modelUsage 差分为准（两边口径不同：OpenAI 的 prompt_tokens 含缓存命中）；
+ * SDK 没给该模型条目时（CLI 失败 / helper），用上游 token 数补一条，别让这笔钱无家可归。
+ * 上游没报 cost（cost 为 null）就不动任何东西 —— 假数据比没有更坏。
+ */
+
+export class UpstreamBilling {
+  constructor() { this.map = new Map(); }   // sid → Map<appModel, acc>
+  /**
+   * @param {string} sid
+   * @param {string} appModel
+   * @param {{ costUsd?: number|null, usage?: object|null }} info
+   */
+  note(sid, appModel, { costUsd = null, usage = null } = {}) {
+    if (!sid || !appModel) return;
+    const c = costUsd == null || !Number.isFinite(Number(costUsd)) ? null : Number(costUsd);
+    if (c == null && !usage) return;
+    let per = this.map.get(sid);
+    if (!per) { per = new Map(); this.map.set(sid, per); }
+    const acc = per.get(appModel) || { costUsd: null, responses: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, reasoningTokens: 0 };
+    acc.responses += 1;
+    if (c != null) acc.costUsd = (acc.costUsd || 0) + c;
+    if (usage) {
+      acc.promptTokens += Number(usage.prompt_tokens) || 0;
+      acc.completionTokens += Number(usage.completion_tokens) || 0;
+      acc.cachedTokens += Number(usage.prompt_tokens_details?.cached_tokens) || 0;
+      acc.reasoningTokens += Number(usage.completion_tokens_details?.reasoning_tokens) || 0;
+    }
+    per.set(appModel, acc);
+  }
+  /** 取走并清零该会话的累计：{ appModel → acc }；没有 → null */
+  take(sid) {
+    const per = sid ? this.map.get(sid) : null;
+    if (!per) return null;
+    this.map.delete(sid);
+    return Object.fromEntries(per);
+  }
+  peek(sid) { const per = this.map.get(sid); return per ? Object.fromEntries(per) : null; }
+  clear(sid) { if (sid) this.map.delete(sid); else this.map.clear(); }
+}
+
+export const upstreamBilling = new UpstreamBilling();
+export const noteUpstreamBilling = (sid, appModel, info) => upstreamBilling.note(sid, appModel, info);
+export const takeUpstreamBilling = (sid) => upstreamBilling.take(sid);

package/server/lib/ingress/upstream-fail-streak.js

@@ -1,72 +1,72 @@
-/**
- * lib/ingress/upstream-fail-streak.js —— 每会话的上游连续失败计数（08-21 晚，僵尸 run 案）。
- *
- * 病：Zen 持续回 503 / network_error 时，我们按规矩发 5xx 或流内 error 事件，CLI 对 5xx 做**无上限**
- * 指数退避重试（假上游实测：75s 内 16 次还在涨），每次又挂 Zen 50~185s —— 一个回合跑了一小时，
- * 用户早断线，run 一直 running。流内 error 事件本身 CLI 只试 4 次就放弃，真正喂活循环的是
- * 非流式兜底那一跳拿到的 502/503。
- *
- * 治法：同一会话连续 N 次上游失败后，ingress 对下一个请求直接回 **HTTP 400**（invalid_request_error）。
- * 假上游 + 真 SDK 循环实测：400 不重试、回合以 is_error 的 result 收场、错误文本原样到用户、
- * streamInput 会话不死（下一条消息照常处理）。消费掉上限后计数归零，用户再发就有新的 N 次机会。
- *
- * 什么算失败：上游 5xx / 转发层网络错 / 200 但零 choices / 私货 finish_reason 且零可见输出（流式与
- * 非流式都算）。什么算成功：一次回应带可见内容（或透传路 2xx）。成功一次就清零。
- * 超过 DECAY_MS 没有新失败也清零（别让昨天的坏账拦今天的人）。
- */
-
-export const DEFAULT_MAX = 4;
-export const DECAY_MS = 30 * 60 * 1000;
-
-export function failStreakMax(env = process.env) {
-  const v = Number(env.NODESIGN_UPSTREAM_FAIL_STREAK);
-  return Number.isInteger(v) && v > 0 ? v : DEFAULT_MAX;
-}
-
-export class FailStreaks {
-  constructor({ max = null, decayMs = DECAY_MS, now = () => Date.now() } = {}) {
-    this.map = new Map();   // sid → { n, last, reason }
-    this.maxOverride = max;
-    this.decayMs = decayMs;
-    this.now = now;
-  }
-  get max() { return this.maxOverride ?? failStreakMax(); }
-  /** 记一次结果。ok=true 清零；ok=false 累加并记原因。返回当前计数。 */
-  note(sid, ok, reason = '') {
-    if (!sid) return 0;
-    if (ok) { this.map.delete(sid); return 0; }
-    const now = this.now();
-    const cur = this.map.get(sid);
-    const n = cur && now - cur.last < this.decayMs ? cur.n + 1 : 1;
-    this.map.set(sid, { n, last: now, reason: String(reason || '').slice(0, 160) });
-    return n;
-  }
-  /** 到上限了吗（含衰减判断） */
-  exhausted(sid) {
-    const cur = sid ? this.map.get(sid) : null;
-    if (!cur) return false;
-    if (this.now() - cur.last >= this.decayMs) { this.map.delete(sid); return false; }
-    return cur.n >= this.max;
-  }
-  /** 取走并清零：返回 { n, reason }，用于组拒绝话术；之后用户再发有新的 max 次机会 */
-  consume(sid) {
-    const cur = this.map.get(sid) || { n: 0, reason: '' };
-    this.map.delete(sid);
-    return cur;
-  }
-  clear(sid) { if (sid) this.map.delete(sid); else this.map.clear(); }
-}
-
-/** ingress 进程内单例 */
-export const failStreaks = new FailStreaks();
-
-/** 拒绝体（Anthropic error 形状；400 = CLI 不重试，实测） */
-export function exhaustedErrorBody({ label, n, reason }) {
-  return {
-    type: 'error',
-    error: {
-      type: 'invalid_request_error',
-      message: `${label} 连续 ${n} 次没有返回可用内容（最近一次：${reason || '未知'}），这轮先停了。稍后再发一次，或换个模型。`,
-    },
-  };
-}
+/**
+ * lib/ingress/upstream-fail-streak.js —— 每会话的上游连续失败计数（08-21 晚，僵尸 run 案）。
+ *
+ * 病：Zen 持续回 503 / network_error 时，我们按规矩发 5xx 或流内 error 事件，CLI 对 5xx 做**无上限**
+ * 指数退避重试（假上游实测：75s 内 16 次还在涨），每次又挂 Zen 50~185s —— 一个回合跑了一小时，
+ * 用户早断线，run 一直 running。流内 error 事件本身 CLI 只试 4 次就放弃，真正喂活循环的是
+ * 非流式兜底那一跳拿到的 502/503。
+ *
+ * 治法：同一会话连续 N 次上游失败后，ingress 对下一个请求直接回 **HTTP 400**（invalid_request_error）。
+ * 假上游 + 真 SDK 循环实测：400 不重试、回合以 is_error 的 result 收场、错误文本原样到用户、
+ * streamInput 会话不死（下一条消息照常处理）。消费掉上限后计数归零，用户再发就有新的 N 次机会。
+ *
+ * 什么算失败：上游 5xx / 转发层网络错 / 200 但零 choices / 私货 finish_reason 且零可见输出（流式与
+ * 非流式都算）。什么算成功：一次回应带可见内容（或透传路 2xx）。成功一次就清零。
+ * 超过 DECAY_MS 没有新失败也清零（别让昨天的坏账拦今天的人）。
+ */
+
+export const DEFAULT_MAX = 4;
+export const DECAY_MS = 30 * 60 * 1000;
+
+export function failStreakMax(env = process.env) {
+  const v = Number(env.NODESIGN_UPSTREAM_FAIL_STREAK);
+  return Number.isInteger(v) && v > 0 ? v : DEFAULT_MAX;
+}
+
+export class FailStreaks {
+  constructor({ max = null, decayMs = DECAY_MS, now = () => Date.now() } = {}) {
+    this.map = new Map();   // sid → { n, last, reason }
+    this.maxOverride = max;
+    this.decayMs = decayMs;
+    this.now = now;
+  }
+  get max() { return this.maxOverride ?? failStreakMax(); }
+  /** 记一次结果。ok=true 清零；ok=false 累加并记原因。返回当前计数。 */
+  note(sid, ok, reason = '') {
+    if (!sid) return 0;
+    if (ok) { this.map.delete(sid); return 0; }
+    const now = this.now();
+    const cur = this.map.get(sid);
+    const n = cur && now - cur.last < this.decayMs ? cur.n + 1 : 1;
+    this.map.set(sid, { n, last: now, reason: String(reason || '').slice(0, 160) });
+    return n;
+  }
+  /** 到上限了吗（含衰减判断） */
+  exhausted(sid) {
+    const cur = sid ? this.map.get(sid) : null;
+    if (!cur) return false;
+    if (this.now() - cur.last >= this.decayMs) { this.map.delete(sid); return false; }
+    return cur.n >= this.max;
+  }
+  /** 取走并清零：返回 { n, reason }，用于组拒绝话术；之后用户再发有新的 max 次机会 */
+  consume(sid) {
+    const cur = this.map.get(sid) || { n: 0, reason: '' };
+    this.map.delete(sid);
+    return cur;
+  }
+  clear(sid) { if (sid) this.map.delete(sid); else this.map.clear(); }
+}
+
+/** ingress 进程内单例 */
+export const failStreaks = new FailStreaks();
+
+/** 拒绝体（Anthropic error 形状；400 = CLI 不重试，实测） */
+export function exhaustedErrorBody({ label, n, reason }) {
+  return {
+    type: 'error',
+    error: {
+      type: 'invalid_request_error',
+      message: `${label} 连续 ${n} 次没有返回可用内容（最近一次：${reason || '未知'}），这轮先停了。稍后再发一次，或换个模型。`,
+    },
+  };
+}

package/server/lib/ingress/upstream-truncation.js

@@ -1,48 +1,48 @@
-/**
- * lib/ingress/upstream-truncation.js —— 「上一次响应是不是半截」的会话级标记（08-21 晚）。
- *
- * 病：Zen 会在模型说到一半时把流掐了（无 finish_reason，或私货 finish 如 network_error），
- * 而正文已经吐出来一部分。转换层照旧按 end_turn 收尾（这是对的，假上游实测：有可见输出后
- * 再发 error 事件 CLI 不重试、只会把半截 + "Server error mid-response" 一起判 is_error 给用户），
- * 于是**半截答案就成了最终答案** —— agent 说了半句话就收工，用户以为它答完了。
- * 08-21 当天生产日志 4 次。
- *
- * 治法（对齐 OpenCode 1.18.21 对 unknown finish 的处理）：ingress 每次往返把「半截」标记记到
- * 会话上，session-loop 收到 result 时取走；有标记就自动补一条续接消息再跑一轮，
- * 半截那段原样留在对话历史里（跟 OpenCode 一样，不删不改，让模型自己接着说）。
- *
- * 只记**最近一次**，不累加：一个回合里有多次 API 往返（工具调用），我们关心的是收尾那次
- * 是不是半截。任何一次完整收尾都把标记清掉。
- */
-
-export class UpstreamTruncation {
-  constructor({ now = () => Date.now() } = {}) {
-    this.map = new Map();   // sid → { reason, appModel, at }
-    this.now = now;
-  }
-  /**
-   * 记一次往返的收尾形态。truncated 为 null/'' = 这次收得完整 → 清掉旧标记。
-   * @param {string} sid
-   * @param {string|null} truncated  半截原因串（openai-chat.js 的 truncationReason 产出）
-   * @param {{ appModel?: string }} [meta]
-   */
-  note(sid, truncated, { appModel = '' } = {}) {
-    if (!sid) return;
-    if (!truncated) { this.map.delete(sid); return; }
-    this.map.set(sid, { reason: String(truncated).slice(0, 120), appModel, at: this.now() });
-  }
-  /** 取走并清零：{ reason, appModel, at } 或 null */
-  take(sid) {
-    if (!sid) return null;
-    const cur = this.map.get(sid) || null;
-    this.map.delete(sid);
-    return cur;
-  }
-  clear(sid) { if (sid) this.map.delete(sid); else this.map.clear(); }
-}
-
-/** ingress 进程内单例 */
-export const upstreamTruncation = new UpstreamTruncation();
-
-export function noteUpstreamTruncation(sid, truncated, meta) { upstreamTruncation.note(sid, truncated, meta); }
-export function takeUpstreamTruncation(sid) { return upstreamTruncation.take(sid); }
+/**
+ * lib/ingress/upstream-truncation.js —— 「上一次响应是不是半截」的会话级标记（08-21 晚）。
+ *
+ * 病：Zen 会在模型说到一半时把流掐了（无 finish_reason，或私货 finish 如 network_error），
+ * 而正文已经吐出来一部分。转换层照旧按 end_turn 收尾（这是对的，假上游实测：有可见输出后
+ * 再发 error 事件 CLI 不重试、只会把半截 + "Server error mid-response" 一起判 is_error 给用户），
+ * 于是**半截答案就成了最终答案** —— agent 说了半句话就收工，用户以为它答完了。
+ * 08-21 当天生产日志 4 次。
+ *
+ * 治法（对齐 OpenCode 1.18.21 对 unknown finish 的处理）：ingress 每次往返把「半截」标记记到
+ * 会话上，session-loop 收到 result 时取走；有标记就自动补一条续接消息再跑一轮，
+ * 半截那段原样留在对话历史里（跟 OpenCode 一样，不删不改，让模型自己接着说）。
+ *
+ * 只记**最近一次**，不累加：一个回合里有多次 API 往返（工具调用），我们关心的是收尾那次
+ * 是不是半截。任何一次完整收尾都把标记清掉。
+ */
+
+export class UpstreamTruncation {
+  constructor({ now = () => Date.now() } = {}) {
+    this.map = new Map();   // sid → { reason, appModel, at }
+    this.now = now;
+  }
+  /**
+   * 记一次往返的收尾形态。truncated 为 null/'' = 这次收得完整 → 清掉旧标记。
+   * @param {string} sid
+   * @param {string|null} truncated  半截原因串（openai-chat.js 的 truncationReason 产出）
+   * @param {{ appModel?: string }} [meta]
+   */
+  note(sid, truncated, { appModel = '' } = {}) {
+    if (!sid) return;
+    if (!truncated) { this.map.delete(sid); return; }
+    this.map.set(sid, { reason: String(truncated).slice(0, 120), appModel, at: this.now() });
+  }
+  /** 取走并清零：{ reason, appModel, at } 或 null */
+  take(sid) {
+    if (!sid) return null;
+    const cur = this.map.get(sid) || null;
+    this.map.delete(sid);
+    return cur;
+  }
+  clear(sid) { if (sid) this.map.delete(sid); else this.map.clear(); }
+}
+
+/** ingress 进程内单例 */
+export const upstreamTruncation = new UpstreamTruncation();
+
+export function noteUpstreamTruncation(sid, truncated, meta) { upstreamTruncation.note(sid, truncated, meta); }
+export function takeUpstreamTruncation(sid) { return upstreamTruncation.take(sid); }