@sema-agent/server 7.78.0 → 7.78.2

package/dist/trace/ledger-sink.js

@@ -2,7 +2,7 @@ import { terminalProjection } from "@sema-agent/core";
 import { modelTextEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, workspaceChangedEventData, wiringManifestEventData, toolRosterDeltaEventData, toolDisclosureEventData, humanInputEventData, turnEndEventData, contextUsageEventData } from "./project.js";
 import { NotifiedKeys, taskNotificationStreamKey } from "../orchestration/workflow-completion-inbox.js";
 import { isParkLedgerEventType } from "./ledger-events.js";
-import { isModelSegmentBoundary } from "./model-segment.js";
+import { isModelSegmentBoundary, reasoningDeltaBytes, reasoningSegmentEventId } from "./model-segment.js";
 export function createSerialLedgerAppend(appendEvent, startSeq) {
     let seq = startSeq;
     let chain = Promise.resolve();
@@ -19,6 +19,7 @@ export function createLedgerSink(opts) {
     let text = "";
     let reasoning = "";
     let textEventId;
+    let reasoningEventId;
     const beat = (kind, statusData) => {
         try {
             opts.onActivity?.(kind, statusData);
@@ -34,8 +35,9 @@ export function createLedgerSink(opts) {
     };
     const flush = async () => {
         if (reasoning) {
-            await append("reasoning", modelTextEventData({ text: reasoning }));
+            await append("reasoning", modelTextEventData({ text: reasoning, eventId: reasoningEventId }));
             reasoning = "";
+            reasoningEventId = undefined;
         }
         if (text) {
             await append("text", modelTextEventData({ text, eventId: textEventId }));
@@ -53,10 +55,15 @@ export function createLedgerSink(opts) {
                 textEventId ??= td.eventId;
                 break;
             }
-            case "reasoning_delta":
-                if (opts.persistThinking)
-                    reasoning += ev.delta;
+            case "reasoning_delta": {
+                const rd = ev;
+                const bytes = reasoningDeltaBytes(rd);
+                if (opts.persistThinking && bytes !== undefined) {
+                    reasoning += bytes;
+                    reasoningEventId ??= reasoningSegmentEventId(rd.eventId);
+                }
                 break;
+            }
             case "tool_start":
                 await append("tool_start", toolStartEventData(ev));
                 break;

package/dist/trace/model-segment.d.ts

@@ -1,3 +1,4 @@
+import { type SegmentEndFields } from "./project.js";
 /**
  * 本帧是不是模型文本的段界。**四条消费腿共用这一只**:账本投影 switch(`trace/ledger-sink.ts`)、
  * 顶层 live 流与转发子代腿(`http/routes/tasks.ts`)、子代 tail 面(`fleet/subagent-tail-bus.ts`)。
@@ -5,8 +6,10 @@
  * (第三方 Runner 塞进来的野帧不该切走宿主的权威段)。
  */
 export declare function isModelSegmentBoundary(type: string): boolean;
-/** live 面的段末帧(`type` 即事件名;其余键由 `reasoningEndEventData` 白名单铸出)。 */
-export type ReasoningEndFrame = Record<string, unknown> & {
+/** live 面的段末帧(`type` 即事件名;其余键由 `reasoningEndEventData` 白名单铸出)。
+ *  形是**声明**出来的、不是 `Record<string, unknown>`(S-334 门①):`eventId` 是本帧的续流游标,
+ *  型必须说得出口 —— live 腿的 `id:` 行取的正是它。 */
+export type ReasoningEndFrame = SegmentEndFields & {
     type: "reasoning_end";
 };
 /** 登记册**读到的全部字段**,逐个写出来(不是 `Record<string, unknown>`):`TaskEvent` 与转发腿的原始帧
@@ -48,6 +51,33 @@ export interface ReasoningSegments {
      *  与账本腿 `LedgerSink.onDone → flush()` 同位同义 —— 段界表里没有终局词,终局走这扇门。 */
     cut(match?: (ident: ReasoningStreamIdent) => boolean): ReasoningEndFrame[];
 }
+/**
+ * 一段推理的**段末事件 id** —— 唯一铸点,live 段末帧与账本 `reasoning` 行共用这一只。
+ *
+ * 🔴 **为什么段末帧不能沿用任何一块 delta 的 `eventId`**(S-334):SSE 的 `id:` 行是**续流游标**,
+ * 「每帧唯一」就是它的定义(消费端据它做**整帧幂等**:见过的 id 整帧丢);而本仓 live 腿的 `id:` 行
+ * 恰恰取自载荷的 `eventId`(`http/routes/tasks.ts` 的 `sseData`)。沿用段内某一块的锚 ⇒ 段末帧与那一块
+ * delta 顶着同一枚游标,消费端把**权威段**当重放帧丢弃 —— 本帧存在的唯一理由(整段脱敏后的权威副本)
+ * 当场结构性失效。「这段是从哪一帧开始攒的」不是游标要回答的问题,而「整段替换」这条消费律本来就
+ * 不需要段首锚:重连从**帧**续,不从段续。
+ *
+ * 形 = 那一枚锚 + 一个派生记号,**确定性**是它的全部要点:live 腿与账本腿各自看着同一条流、在同一个
+ * 段界上算出**同一枚**字符串,于是「同一份权威副本」在身份面也成立,而两条腿之间不需要任何传值通道
+ * ——bg / resume 两条账本腿上根本没有 live 登记册可问,靠传值就只能做成「detach 车道有、别的腿没有」
+ * 的两种账本行形。
+ *
+ * 输入 = 本段**第一块带锚**的 delta 的 `eventId`(不是「第一块」的:首块无锚不等于整段无锚,三条腿
+ * 统一用 `??=` 闩第一枚**有定义**的锚 —— 与 E18 的 `textEventId ??=` 逐字同律)。整段一块带锚的都没有
+ * ⇒ 段末 id 缺席(诚实的「无锚」,绝不合成占位 —— 与 `sseData` 的既有纪律同源:不可锚的位置不许
+ * 伪装成可锚)。
+ */
+export declare function reasoningSegmentEventId(anchor: unknown): string | undefined;
+/** 一块 `reasoning_delta` 对段的**贡献字节** —— 非空串才算。账本腿与三条 live 腿共用这一只:空/坏形
+ *  增量一个字节都不贡献,既不开段也不参与闩锚 ⇒ 两面结构上不可能把锚闩在不同的帧上(`reasoning_end`
+ *  与账本 `reasoning` 行的正文早就逐字节相等,身份面随 S-334 收进同一条规则)。 */
+export declare function reasoningDeltaBytes(ev: {
+    delta?: unknown;
+}): string | undefined;
 /** 「这条流属于这些子代 id 之一」—— 子代终态收段的匹配器(`task_id` 与 `sessionId` 是同一个子代的两个
  *  id 域,取并集;`undefined` 成员自动忽略)。腿上共用这一只,免得各写一遍 id 域的并集。 */
 export declare function reasoningStreamOfTask(...ids: ReadonlyArray<string | undefined>): (ident: ReasoningStreamIdent) => boolean;

package/dist/trace/model-segment.js

@@ -7,6 +7,13 @@ const BOUNDARY = new Set([
 export function isModelSegmentBoundary(type) {
     return BOUNDARY.has(type);
 }
+const REASONING_SEGMENT_ID_MARK = "~reasoning_end";
+export function reasoningSegmentEventId(anchor) {
+    return typeof anchor === "string" && anchor.length > 0 ? `${anchor}${REASONING_SEGMENT_ID_MARK}` : undefined;
+}
+export function reasoningDeltaBytes(ev) {
+    return typeof ev.delta === "string" && ev.delta !== "" ? ev.delta : undefined;
+}
 export function reasoningStreamOfTask(...ids) {
     const set = new Set(ids.filter((v) => typeof v === "string" && v !== ""));
     return (ident) => (ident.sourceTaskId !== undefined && set.has(ident.sourceTaskId)) || (ident.bgAgentId !== undefined && set.has(ident.bgAgentId));
@@ -25,21 +32,24 @@ export function createReasoningSegments() {
         if (seg === undefined)
             return [];
         open.delete(key);
-        const data = reasoningEndEventData({ ...seg.ident, eventId: seg.eventId, content: seg.buf });
+        const data = reasoningEndEventData({ ...seg.ident, eventId: seg.segmentEventId, content: seg.buf });
         return data === null ? [] : [{ type: "reasoning_end", ...data }];
     };
     return {
         onEvent: (ev) => {
             if (ev.type === "reasoning_delta") {
-                if (typeof ev.delta !== "string" || ev.delta === "")
+                const bytes = reasoningDeltaBytes(ev);
+                if (bytes === undefined)
                     return [];
                 const ident = identOf(ev);
                 const key = streamKeyOf(ident);
                 const seg = open.get(key);
                 if (seg === undefined)
-                    open.set(key, { ident, eventId: ev.eventId, buf: ev.delta });
-                else
-                    seg.buf += ev.delta;
+                    open.set(key, { ident, segmentEventId: reasoningSegmentEventId(ev.eventId), buf: bytes });
+                else {
+                    seg.buf += bytes;
+                    seg.segmentEventId ??= reasoningSegmentEventId(ev.eventId);
+                }
                 return [];
             }
             return isModelSegmentBoundary(ev.type ?? "") ? cutKey(streamKeyOf(identOf(ev))) : [];

package/dist/trace/project.d.ts

@@ -192,8 +192,42 @@ export declare function screenedStoredEventData(type: string, data: unknown): un
  *  此前三处各自逐字透传 —— 同一份文本毫秒后在 `done.result.result` 上已脱,live 面却在凭据生成瞬间明文(B-114)。
  *  `text_delta` 仍逐字:跨 chunk 的凭据无法就地判,流式脱敏是独立设计件(S-270)。
  *  坏形(content 非串/空串)⇒ null(丢帧,不铸「权威空段」:core 契约明言空段不发本帧,消费端收到空段会清掉已攒 delta)。
- *  身份四键零字节变换(live 现状带全四键,消费端可能已依赖)。 */
-export declare function textEndEventData(ev: Record<string, unknown>): Record<string, unknown> | null;
+ *  身份**四键**随行(live 现状带全四键,消费端可能已依赖);值经 {@link identityKey} —— 非空 string 才上 wire
+ *  (S-334 起不再逐字透传:坏形身份键会在 live 写口上铸出假游标)。 */
+export declare function textEndEventData(ev: Record<string, unknown>): SegmentEndFields | null;
+/**
+ * live 面的**身份四键**(core `TaskEventIdentity` 全集)—— 一个属主,两处共用({@link segmentEndFields}
+ * 与 sync 腿白名单 catch-all 的 `ident`;此前是两份手抄)。与 durable 面的 {@link identityFields} 的差别
+ * **只剩键集**:那边两键(durable builder 对另两键的既定排除),这边四键(live 现状,消费端已依赖);
+ * **值判据是同一条** —— 两只都问 {@link identityKey}(非空 `string` 才上 wire,绝不强转)。
+ *
+ * 🔴 **型必须说得出口**(S-334):`eventId` 是 live 腿 SSE `id:` 行的**唯一**来源,而 `id:` 行是续流游标
+ * ——一个连值的型都说不出的键不许铸成游标。非串/空串 ⇒ 键缺席(与「无锚不发 `id:` 行」同一条纪律:
+ * 不可锚的位置绝不伪装成可锚)。转发子代腿的帧是 UNTRUSTED RAW(§E1),这一道同时是它的形判门。
+ *
+ * 🔴 **`type` 而不是 `interface`**(它与 {@link SegmentEndFields} 两处都是,别改回去):TS 只给**类型别名**
+ * 隐式索引签名,interface 没有 ⇒ 写成 interface 的话,每一个把本形交给 `Record<string, unknown>` 形参
+ * (tail 总线帧、live 帧写口)的调用点都得手抄一次 `{ ...frame }` 展开。别名让「声明出来的形」原样流经
+ * 既有写口,零调用点噪声。
+ */
+export type LiveEventIdentity = {
+    eventId?: string;
+    parentToolCallId?: string;
+    sourceTaskId?: string;
+    bgAgentId?: string;
+};
+/** 段末帧(`text_end` / `reasoning_end`)的载荷**形**(两只帧一个字节不差 —— 一个 wire 概念一份形,
+ *  消费端的读法只学一次;差别只有各自铸点的空段判据)。 */
+export type SegmentEndFields = LiveEventIdentity & {
+    content: string;
+};
+/** {@link LiveEventIdentity} 的铸点。[ref] 门①:条件展开的臂逐条是直写字面量(键名对扫描器可见)。 */
+export declare function liveIdentityFields(ev: {
+    eventId?: unknown;
+    parentToolCallId?: unknown;
+    sourceTaskId?: unknown;
+    bgAgentId?: unknown;
+}): LiveEventIdentity;
 /**
  * `reasoning_end` 段末帧的**唯一**铸点(三条 live 腿共用:top stream / 转发子代腿 / 子代 tail 面)——
  * `text_end` 的推理面孪生({@link textEndEventData}),形逐字同(共用 {@link segmentEndFields})。
@@ -210,7 +244,7 @@ export declare function textEndEventData(ev: Record<string, unknown>): Record<st
  * 「整段替换已攒的 delta」—— 发一枚空白权威段 = 让消费端把已渲染的思考清成空白。坏形(`content` 非串)
  * 同样丢帧,理由与 `text_end` 逐字同源。
  */
-export declare function reasoningEndEventData(ev: Record<string, unknown>): Record<string, unknown> | null;
+export declare function reasoningEndEventData(ev: Record<string, unknown>): SegmentEndFields | null;
 /** The durable `tool_end` payload (shared by both append sites). E1: the model-facing `output` is UNTRUSTED RAW
  *  from core (file/shell/API bodies) — core only SIZE-bounds it (`truncated`), REDACTION is ours (same contract as
  *  `tool_start.args`); never re-fed to a model. E2: identity. Absent `output` ⇒ the tool produced no content body.

package/dist/trace/project.js

@@ -78,10 +78,13 @@ export function aggregateModelUsage(events) {
 }
 function identityFields(src) {
     return {
-        ...(src.eventId ? { eventId: String(src.eventId) } : {}),
-        ...(src.parentToolCallId ? { parentToolCallId: String(src.parentToolCallId) } : {}),
+        ...(identityKey(src.eventId) !== undefined ? { eventId: identityKey(src.eventId) } : {}),
+        ...(identityKey(src.parentToolCallId) !== undefined ? { parentToolCallId: identityKey(src.parentToolCallId) } : {}),
     };
 }
+function identityKey(v) {
+    return typeof v === "string" && v !== "" ? v : undefined;
+}
 export function modelTextEventData(ev) {
     return { text: ev.text, ...(ev.eventId ? { eventId: ev.eventId } : {}) };
 }
@@ -192,15 +195,17 @@ export function textEndEventData(ev) {
         return null;
     return segmentEndFields(ev.content, ev);
 }
-function segmentEndFields(content, ev) {
+export function liveIdentityFields(ev) {
     return {
-        content: redactModelText(content),
-        ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
-        ...(ev.parentToolCallId !== undefined ? { parentToolCallId: ev.parentToolCallId } : {}),
-        ...(ev.sourceTaskId !== undefined ? { sourceTaskId: ev.sourceTaskId } : {}),
-        ...(ev.bgAgentId !== undefined ? { bgAgentId: ev.bgAgentId } : {}),
+        ...(identityKey(ev.eventId) !== undefined ? { eventId: identityKey(ev.eventId) } : {}),
+        ...(identityKey(ev.parentToolCallId) !== undefined ? { parentToolCallId: identityKey(ev.parentToolCallId) } : {}),
+        ...(identityKey(ev.sourceTaskId) !== undefined ? { sourceTaskId: identityKey(ev.sourceTaskId) } : {}),
+        ...(identityKey(ev.bgAgentId) !== undefined ? { bgAgentId: identityKey(ev.bgAgentId) } : {}),
     };
 }
+function segmentEndFields(content, ev) {
+    return { content: redactModelText(content), ...liveIdentityFields(ev) };
+}
 export function reasoningEndEventData(ev) {
     if (typeof ev.content !== "string" || ev.content.trim().length === 0)
         return null;
@@ -593,8 +598,7 @@ export function compactedEventData(ev) {
         return Object.keys(out).length > 0 ? out : undefined;
     })();
     return {
-        ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
-        ...(ev.parentToolCallId !== undefined ? { parentToolCallId: ev.parentToolCallId } : {}),
+        ...identityFields(ev),
         ...(typeof ev.trigger === "string" ? { trigger: ev.trigger } : {}),
         ...(num(ev.tokensBefore) !== undefined ? { tokensBefore: num(ev.tokensBefore) } : {}),
         ...(ev.preserved_segment?.firstKeptEntryId ? { preserved_segment: { firstKeptEntryId: ev.preserved_segment.firstKeptEntryId } } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.78.0",
+  "version": "7.78.2",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",
@@ -54,7 +54,7 @@
     "build:binary:run-local:darwin-arm64": "bun build --compile --target=bun-darwin-arm64 src/run-local.ts --outfile dist/run-local-darwin-arm64"
   },
   "dependencies": {
-    "@sema-agent/core": "7.18.0",
+    "@sema-agent/core": "7.19.0",
     "@sema-agent/settings-schema": "2.1.0",
     "e2b": "^2.28.0",
     "libsodium-wrappers": "^0.8.4",
@@ -69,7 +69,7 @@
     "sharp": "^0.35.3"
   },
   "devDependencies": {
-    "@sema-agent/sdk": "9.4.0",
+    "@sema-agent/sdk": "9.5.0",
     "@types/libsodium-wrappers": "^0.7.14",
     "@types/node": "22.10.2",
     "@types/pg": "^8.20.0",