dsh-lcx-codex 0.4.3-pre.12 → 0.4.3-pre.3

package/README.md

@@ -7,7 +7,7 @@
 **为 DeepSeek Harness 中的 GPT 提供 Responses 生命周期能力，并为 Grok 接入原生 Web / X Search。**
 
 [![npm prerelease](https://img.shields.io/npm/v/dsh-lcx-codex/prelatest?label=prelatest)](https://www.npmjs.com/package/dsh-lcx-codex)
-[![DSH](https://img.shields.io/badge/DSH-0.1.5--alpha.1-16803c)](#安装)
+[![DSH](https://img.shields.io/badge/DSH-0.1.3--alpha.2-16803c)](#安装)
 [![License](https://img.shields.io/badge/license-MIT-555)](LICENSE)
 
 **简体中文** · [English](README_EN.md) · [更新日志](CHANGELOG.md) · [问题反馈](https://github.com/kk3ya03-star/dsh-lcx-codex/issues)
@@ -20,20 +20,18 @@ LCX Codex 是 [DeepSeek Harness](https://github.com/deepseek-ai/DeepSeek-Harness
 
 ## 安装
 
-本页对应 **`0.4.3-pre.12` 预发布版**，只支持 **DSH `0.1.5-alpha.1` + Pi `0.85.1`**。稳定版仍为 `0.4.2`；本预发布版不为旧 DSH / 旧 Session 格式保留兼容层。
+本页对应 **`0.4.3-pre.3` 预发布版**，适配 **DSH `0.1.3-alpha.2`**。稳定版仍为 `0.4.2`，使用旧版 DSH `0.1.1-rc.2` 的用户请看[稳定版说明](https://github.com/kk3ya03-star/dsh-lcx-codex/blob/v0.4.2/README.md)。
 
-安装前，请确认 DSH `0.1.5-alpha.1` Web 能正常启动，并已配置需要使用的 GPT Responses 或 Grok Responses API 路由。Node.js 要求 `^22.19.0 || >=24.0.0`。
+安装前，请确认 DSH Web 能正常启动，并已配置需要使用的 GPT Responses 或 Grok Responses API 路由。Node.js 要求 `^22.19.0 || >=24.0.0`；Windows 启动出现 `fs-ext` 报错时，先看下方[故障排查](#故障排查)。
 
 ```sh
-dsh plugin --profile web add dsh-lcx-codex@0.4.3-pre.12
+dsh plugin --profile web add dsh-lcx-codex@0.4.3-pre.3
 dsh web
 ```
 
 以后升级预发布版，可执行 `dsh plugin --profile web add dsh-lcx-codex@prelatest`。不带版本或标签安装会得到稳定版，**不是本页介绍的新版本**。
 
-**升级到本版：** 只支持 DSH `0.1.5-alpha.1` 的 Session V3。旧插件配置、旧 DSH session、旧 LCX checkpoint / Grok replay envelope 都不迁移到活动目录。需要保留旧历史时，请先将旧 `sessions` 目录改名或归档，再让 DSH `0.1.5-alpha.1` 从新的空 `sessions` 目录开始；旧数据只作为离线备份保留。
-
-DSH 持久化层重新打开同一个已保存 session 时，LCX 可以恢复该 session 内保存的 v5 checkpoint；这只是 DSH session persistence 上的继续对话，**不是 Codex rollout/checkpoint 的进程级 restart/resume 机制**。
+**从 `0.4.2` 升级：** 旧插件配置和 v3/v4 压缩检查点不再兼容，请重新配置插件并新建会话。新版 v5 GPT 检查点仍支持重启续聊。
 
 ## 启用
 
@@ -77,7 +75,7 @@ Grok 使用 xAI Responses 的服务端工具，而不是把搜索包装成 DSH f
 
 开启任意 Grok 原生搜索后，Grok 请求会移除 DSH `web_search`，避免重复搜索语义；`web_fetch`、`read` 及其他 DSH/MCP function tools 仍保持可用。原生搜索结果可以继续进入本地工具调用，再回到同一 Grok agentic workflow；插件会保存 xAI 必需的 provider-native replay state，但不会把服务端搜索伪装成 DSH 本地工具调用。
 
-当前支持 **API Key / API Gateway** 路由；OAuth / SuperGrok / X Premium 订阅登录不在本版范围内。LCX 不再为 Grok 自动追加可见的 synthetic `Sources:` 列表，并会清理已知的 `render_inline_citation` / `stateless_invoke` /私有区 renderer 标记、尾部 `<|eos|>` 等上游渲染协议残留；模型正文中主动写出的普通链接仍保持可见。完整 provider-native 搜索输出只保存在 same-session replay state 中。
+当前支持 **API Key / API Gateway** 路由；OAuth / SuperGrok / X Premium 订阅登录不在本版范围内。搜索来源 URL 会尽量保留，但具体 citation 展示形式仍受上游兼容网关返回格式影响。
 
 ### GPT 搜索图片并显示
 
@@ -105,9 +103,9 @@ Alpha 需要单独开启，且接口通过能力探测后才会出现。目前
 | `90%` 至 `95%` | 优先尝试远程原生压缩。 |
 | 达到 `95%` | 允许 DSH 紧急裁剪工具结果，再按流程压缩。 |
 
-也可以输入 `/compact` 手动压缩。这些阈值是固定策略，不需要额外设置；实际能否压缩取决于是否有可压缩的历史以及接口支持情况。Grok 不走 GPT Native V2，而继续使用 DSH `0.1.5-alpha.1` 自己的 compaction；Session V3 的 leading `system/message` 由 DSH 保持在摘要之外。
+也可以输入 `/compact` 手动压缩。这些阈值是固定策略，不需要额外设置；实际能否压缩取决于是否有可压缩的历史以及接口支持情况。
 
-压缩后可以在同一存活 session 内继续对话；如果 DSH 自身重新打开同一个已持久化 session，LCX 也会校验并恢复其中的 v5 checkpoint。遇到不兼容的模型、route 或 session identity 时，插件改用可迁移的历史，不会强行复用原生状态。首次建立检查点时，部分可恢复失败可以回退到 DSH 基础压缩；并非所有失败都会回退。这里不引入 Codex 式 rollout/checkpoint restart-resume。
+压缩后可以继续对话、重启恢复或切换 GPT 模型。遇到不兼容的模型或接口配置时，插件改用可迁移的历史，不会强行复用原生状态。首次建立检查点时，部分可恢复失败可以回退到 DSH 基础压缩；并非所有失败都会回退。
 
 ## 缓存
 
@@ -120,9 +118,11 @@ Pi `0.85.1` 的显式缓存模式支持 `30m` 长保留参数；`cacheRetention=
 
 ## 故障排查
 
-**从旧版 Windows DSH 升级后还需要 `fs-ext` 本地补丁吗？**
+**DSH 在 Windows 启动时报 `fs-ext` 错误？**
+
+DSH `0.1.3-alpha.2` 会在启动时加载 `fs-ext`，即使 Windows 实际不使用它。当它的原生模块不可用时，DSH 会在启动阶段退出。这是 **DSH 的依赖加载问题，不是插件压缩或会话锁损坏**。
 
-不需要把 `0.1.3-alpha.2` 的 `fs-ext` 本地 workaround 带到 DSH `0.1.5-alpha.1`。本版已经在未修改的 Windows DSH `0.1.5-alpha.1` 上完成 Web 与 headless 启动验证。若旧安装曾手工修改 DSH 文件，请通过正常安装得到干净的 `0.1.5-alpha.1` 文件，不要把旧补丁复制到新版本。
+本版 Windows 实测使用了一个最小 DSH 修正：仅在非 Windows 平台加载 `fs-ext`，保留原有 Win32 会话锁。插件不会自动修改 DSH；未经该修正的 Windows 环境不保证能启动。不要用关闭会话锁来绕过问题。
 
 **安装后没有变化？**
 
@@ -134,20 +134,18 @@ Pi `0.85.1` 的显式缓存模式支持 `30m` 长保留参数；`cacheRetention=
 
 ## 版本与验证范围
 
-本版使用 DSH `0.1.5-alpha.1`、DSH host Pi `0.85.1` 和插件 Pi `0.85.1`。插件单独声明 Pi 依赖，不替换 DSH 的依赖。
-
-发布候选已通过 **246/246 PASS**、strict host/client typecheck 与 DSH schema 校验。真实 DSH `0.1.5-alpha.1` 隔离运行已验证：Web 启动、headless GPT 普通请求、Session V3 `system/message`、Native V2 `/compact`、compact 后同 session continuation，以及 v5 checkpoint 的 session identity 绑定。
+本版使用 DSH `0.1.3-alpha.2`、DSH host Pi `0.85.1` 和插件 Pi `0.85.1`。插件单独声明 Pi 依赖，不替换 DSH 的依赖。
 
-Grok 另做了真实长会话验证：原生 Web Search → 足够长的上下文 → DSH 实际 `/compact` → compact 后再次原生搜索/续聊。marker 与关键事实保持，`system/message` 只出现一次，Grok replay 为当前 v3 envelope，最终可见正文 `sourceLeak=false`。
+发布前完整测试为 **237/237 PASS**，strict host/client typecheck 与 4 个 DSH schema 均通过。真实运行覆盖 GPT Hosted/Native V2 回归、DeepSeek 原生 DSH 搜索回归，以及 Grok 4.5/4.6 原生 Web/X Search、Web/X → 本地 `read` → continuation、provider-native replay、完整 DSH 重启后的续聊、Grok 父/子代理 session/cache 隔离。GPT 已验证的父 cache-sharing 策略保持不变。
 
-仍需保留的预发布限制：Alpha 引用及 screenshot 展示、代理/NO_PROXY、更广的并发/取消和后台 continuable subagent 矩阵仍未全面覆盖；Grok OAuth 不支持；未知的新型上游 renderer 协议仍可能需要额外适配。DSH `0.1.5-alpha.1` 本身仍是 alpha/developer-preview 级上游。
+仍需保留的预发布限制：Windows DSH `0.1.3-alpha.2` 的 `fs-ext` 启动问题需要文档中的最小 host loading 修正；Alpha 引用及 screenshot 展示、代理/NO_PROXY、更广的并发/取消和后台 continuable subagent 矩阵仍未全面覆盖；Grok OAuth 不支持，citation 渲染仍可能受上游网关格式影响。详细变更见 [v0.4.3-pre.3 发布说明](https://github.com/kk3ya03-star/dsh-lcx-codex/releases/tag/v0.4.3-pre.3)。
 
 ## 开发与反馈
 
 ```sh
 npm ci --ignore-scripts
-npm ci --prefix scripts/runtime-dsh015 --ignore-scripts
-node scripts/link-dsh-runtime.mjs scripts/runtime-dsh015
+npm ci --prefix scripts/runtime-alpha2 --ignore-scripts
+node scripts/link-dsh-runtime.mjs scripts/runtime-alpha2
 node scripts/check-generated.mjs
 npm run typecheck
 npm test

package/lib/dsh-responses.js

@@ -93,7 +93,7 @@ function attachmentResolver(ctx, options) {
     const attachments = attachmentServices(ctx?.attachments);
     return async (block, signal) => {
         if (attachments === undefined)
-            throw error("LCX requires the DSH request-image attachment API", "LCX_COMPACT_IMAGE_API_UNAVAILABLE");
+            throw error("LCX requires the DSH 0.1.3 request-image attachment API", "LCX_COMPACT_IMAGE_API_UNAVAILABLE");
         const request = await attachments.store.readImageRequest(block.attachment, { maxPixels: options.requestImagePixelBudget, maxBytes: options.requestImageMaxBytes }, signal);
         const data = request.data;
         const mediaType = request.mediaType ?? block.attachment.mediaType;
@@ -280,18 +280,11 @@ function projectFiles(messages, ctx) {
         content: projectFileContent(message.content, fileRequestText),
     }));
 }
-function flattenMessageText(message) {
-    return message.content
-        .map((block) => (block.type === "text" ? block.text : ""))
-        .join("");
-}
 async function dshToPiMessages(messages, ctx, options, imageMap) {
     const result = [];
     for (const message of messages) {
-        if (message.role === "system") {
-            result.push({ role: "user", content: flattenMessageText(message), timestamp: 0 });
+        if (message.role === "system")
             continue;
-        }
         if (message.role === "assistant") {
             result.push(toPiAssistant(message, options.onReplayDegrade));
             continue;

package/lib/grok-native-search.js

@@ -75,10 +75,37 @@ function validVisibleItem(item) {
             typeof item.name === "string" && typeof item.input === "string";
     return false;
 }
+function textSha256(text) {
+    return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function lcxCitationAddition(item) {
+    if (item.type !== "message" ||
+        typeof item.id !== "string" ||
+        !item.id.startsWith("msg_lcx_sources_"))
+        return undefined;
+    const text = itemText(item);
+    return text.startsWith("\n\nSources:\n")
+        ? { kind: "citation-sources", textSha256: textSha256(text) }
+        : undefined;
+}
+function validVisibleAdditions(value) {
+    if (!Array.isArray(value) || value.length > GROK_NATIVE_REPLAY_MAX_ITEMS)
+        return undefined;
+    const additions = [];
+    for (const candidate of value) {
+        if (!isRecord(candidate) ||
+            candidate.kind !== "citation-sources" ||
+            typeof candidate.textSha256 !== "string" ||
+            !/^[0-9a-f]{64}$/u.test(candidate.textSha256))
+            return undefined;
+        additions.push({ kind: "citation-sources", textSha256: candidate.textSha256 });
+    }
+    return additions;
+}
 function readGrokNativeReplayEnvelope(value, route) {
     if (!isRecord(value) ||
         value.kind !== "xai-responses-native-search" ||
-        value.version !== 3)
+        (value.version !== 1 && value.version !== 2))
         return undefined;
     if (value.provider !== route.provider ||
         value.model !== route.model ||
@@ -100,10 +127,16 @@ function readGrokNativeReplayEnvelope(value, route) {
     const output = [];
     const itemKinds = new Map();
     const callIds = new Set();
+    const migratedAdditions = [];
     for (const candidate of value.output) {
         if (!isRecord(candidate) || typeof candidate.type !== "string")
             return undefined;
         const item = candidate;
+        const legacyAddition = value.version === 1 ? lcxCitationAddition(item) : undefined;
+        if (legacyAddition) {
+            migratedAdditions.push(legacyAddition);
+            continue;
+        }
         if (GROK_NATIVE_SERVER_TOOL_TYPES.has(item.type)) {
             if (typeof item.id !== "string" || item.id.length === 0)
                 return undefined;
@@ -130,27 +163,39 @@ function readGrokNativeReplayEnvelope(value, route) {
     }
     if (output.length === 0)
         return undefined;
+    const visibleAdditions = value.version === 1
+        ? migratedAdditions
+        : validVisibleAdditions(value.visibleAdditions);
+    if (!visibleAdditions)
+        return undefined;
     return {
         kind: "xai-responses-native-search",
-        version: 3,
+        version: 2,
         provider: route.provider,
         model: route.model,
         sourceSessionId: route.sessionId,
         routeAuthorityFingerprint: grokNativeReplayRouteFingerprint(route),
         output,
+        visibleAdditions,
     };
 }
-export function createGrokNativeReplayEnvelope(output, route) {
+export function createGrokNativeReplayEnvelope(output, route, visibleAdditions = []) {
     if (!route || !Array.isArray(output))
         return undefined;
+    const additions = visibleAdditions.map((candidate) => isRecord(candidate) && typeof candidate.type === "string"
+        ? lcxCitationAddition(candidate)
+        : undefined);
+    if (additions.some((addition) => addition === undefined))
+        return undefined;
     return readGrokNativeReplayEnvelope({
         kind: "xai-responses-native-search",
-        version: 3,
+        version: 2,
         provider: route.provider,
         model: route.model,
         sourceSessionId: route.sessionId,
         routeAuthorityFingerprint: grokNativeReplayRouteFingerprint(route),
         output,
+        visibleAdditions: additions,
     }, route);
 }
 function itemText(item) {
@@ -188,6 +233,19 @@ function visibleItemMatchesInput(item, candidate) {
         return candidate.call_id === item.call_id;
     return true;
 }
+function additionMatchesBlock(addition, candidate) {
+    return isRecord(candidate) && candidate.type === "text" &&
+        typeof candidate.text === "string" &&
+        candidate.text.startsWith("\n\nSources:\n") &&
+        textSha256(candidate.text) === addition.textSha256;
+}
+function additionMatchesInput(addition, candidate) {
+    if (!isRecord(candidate) || candidate.type !== "message")
+        return false;
+    if (typeof candidate.id !== "string" || !candidate.id.startsWith("msg_lcx_sources_"))
+        return false;
+    return textSha256(itemText(candidate)) === addition.textSha256;
+}
 function replayForMessage(message, route) {
     if (message.role !== "assistant" || message.source.kind !== "model")
         return undefined;
@@ -214,18 +272,22 @@ function replayForMessage(message, route) {
             anchors.push(item);
             blockIndex += 1;
         }
-        else if (!(item.type === "reasoning" &&
-            (!itemText(item).trim() || (reasoningCounts.get(String(item.id)) ?? 0) > 1))) {
+        else if (!(item.type === "reasoning" && (reasoningCounts.get(String(item.id)) ?? 0) > 1)) {
             return undefined;
         }
     }
-    // Empty Grok reasoning has no UI block. Pi can coalesce repeated reasoning IDs
-    // in terminal-only gateway responses; every actual DSH-visible block must still match.
+    // Pi can coalesce repeated reasoning IDs in terminal-only gateway responses.
+    // Match every provider-visible DSH block and only the hashed LCX additions.
     if (anchors.length === 0)
         return undefined;
+    for (const addition of envelope.visibleAdditions) {
+        if (!additionMatchesBlock(addition, message.content[blockIndex]))
+            return undefined;
+        blockIndex += 1;
+    }
     if (blockIndex !== message.content.length)
         return undefined;
-    return { envelope, visible: anchors };
+    return { envelope, visible: anchors, additions: envelope.visibleAdditions };
 }
 export function restoreGrokNativeReplay(input, messages, route) {
     const restored = structuredClone(input);
@@ -236,11 +298,12 @@ export function restoreGrokNativeReplay(input, messages, route) {
         const replay = replayForMessage(message, route);
         if (!replay)
             continue;
-        const { envelope, visible } = replay;
-        const replacedLength = visible.length;
+        const { envelope, visible, additions } = replay;
+        const replacedLength = visible.length + additions.length;
         let start = -1;
         for (let index = cursor; index <= restored.length - replacedLength; index += 1) {
-            if (visible.every((item, offset) => visibleItemMatchesInput(item, restored[index + offset]))) {
+            if (visible.every((item, offset) => visibleItemMatchesInput(item, restored[index + offset])) &&
+                additions.every((addition, offset) => additionMatchesInput(addition, restored[index + visible.length + offset]))) {
                 start = index;
                 break;
             }

package/lib/index.js

@@ -522,15 +522,8 @@ async function serializeNativeAware(messages, route, routeConfig, ctx, options)
         responsesCompat: routeConfig.responsesCompat,
         ...extra,
     });
-    const firstMessage = messages[0];
-    const systemHead = firstMessage?.role === "system" ? firstMessage : undefined;
-    const surfaceMessages = systemHead ? messages.slice(1) : messages;
-    const systemPrompt = systemHead?.content
-        .filter((block) => block.type === "text")
-        .map((block) => block.text)
-        .join("") || undefined;
     const prelude = await serializeDshMessages([], ctx, serializeOptions(undefined, {
-        systemPrompt,
+        systemPrompt: options.system,
         includeSystemPrompt: true,
     }));
     const ephemeralPreludeItemCount = prelude.input.length;
@@ -551,7 +544,7 @@ async function serializeNativeAware(messages, route, routeConfig, ctx, options)
         input.push(...restoreGrokNativeReplay(serialized.input, batch, options.grokNativeReplayRoute));
         mergeMap(imageMap, serialized.imageMap);
     };
-    for (const message of surfaceMessages ?? []) {
+    for (const message of messages ?? []) {
         assertSupportedCheckpointMessage(message);
         const state = session
             ? checkpointStateForMessage(session, message)
@@ -607,7 +600,7 @@ async function* remoteCompactionStream(options, routeConfig, ctx, next) {
     const history = stripCompactionDirective(options.messages);
     const route = currentRoute(options, routeConfig);
     try {
-        const prepared = await serializeNativeAware(history, route, routeConfig, ctx, { signal: options.signal, tools: options.tools });
+        const prepared = await serializeNativeAware(history, route, routeConfig, ctx, { signal: options.signal, system: options.system, tools: options.tools });
         const cacheSessionId = promptCacheSessionId(route, routeConfig, ctx);
         const headers = await authenticatedHeaders(ctx, routeConfig, cacheSessionId, cacheSessionId === undefined ? null : route.sessionId);
         const generation = generationControlsFromSession(sessionFor(ctx, route.sessionId), route);
@@ -799,7 +792,7 @@ async function* managedResponsesStream(options, routeConfig, ctx) {
     try {
         if (options.stop !== undefined)
             throw Object.assign(new Error("LCX Responses does not support GenerateOptions.stop"), { code: "LCX_RESPONSES_UNSUPPORTED_OPTION" });
-        const prepared = await serializeNativeAware(options.messages, route, routeConfig, ctx, { signal: options.signal, tools: options.tools });
+        const prepared = await serializeNativeAware(options.messages, route, routeConfig, ctx, { signal: options.signal, system: options.system, tools: options.tools });
         const cacheSessionId = promptCacheSessionId(route, routeConfig, ctx);
         const headers = await authenticatedHeaders(ctx, routeConfig, cacheSessionId, cacheSessionId === undefined ? null : route.sessionId);
         const body = buildResponsesBody({
@@ -846,6 +839,7 @@ async function* managedGrokNativeSearchStream(options, routeConfig, nativeSearch
         const visibleTools = grokVisibleFunctionTools(options.tools, nativeSearch);
         const prepared = await serializeNativeAware(options.messages, route, routeConfig, ctx, {
             signal: options.signal,
+            system: options.system,
             tools: visibleTools,
             grokNativeReplayRoute: nativeReplayRoute,
         });

package/lib/responses-stream.js

@@ -484,40 +484,6 @@ function itemText(item) {
         return String(item.input ?? "");
     return "";
 }
-const GROK_RENDER_MARKER = /(?:\bstateless_invoke\s+)?\{?render_inline_citation(?:\s*\(\s*citation_id\s*=\s*\d+\s*\)|\s+with\s+citation_id\s+is\s+\d+)\}?/giu;
-const GROK_UI_CITATION_MARKER = /render_inline_citation[^\r\n]*/giu;
-const GROK_PRIVATE_RENDER_MARKER = /[\uE000-\uF8FF]render_inline_citation[^\uE000-\uF8FF\r\n]*[\uE000-\uF8FF]/giu;
-const GROK_NUMBERED_CITATION = /\[\[\d+\]\]\(https?:\/\/[^)\s]+\)/giu;
-const GROK_EOS_MARKER = /<\|eos\|>/giu;
-const GROK_SOURCE_TAIL = /(?:^|[ \t\r\n]+)Sources:\s*(?=(?:\r?\n)?\s*[-*])/iu;
-function sanitizeGrokVisibleText(value) {
-    let text = value
-        .replace(GROK_RENDER_MARKER, "")
-        .replace(GROK_UI_CITATION_MARKER, "")
-        .replace(GROK_PRIVATE_RENDER_MARKER, "")
-        .replace(GROK_NUMBERED_CITATION, "")
-        .replace(GROK_EOS_MARKER, "");
-    const sourceTail = text.search(GROK_SOURCE_TAIL);
-    if (sourceTail >= 0)
-        text = text.slice(0, sourceTail);
-    return text.replace(/[ \t]{2,}/gu, " ").replace(/[ \t]+([,.;:!?])/gu, "$1").replace(/[ \t]+\n/gu, "\n").trimEnd();
-}
-function sanitizeGrokTerminalItem(item, index) {
-    const normalized = normalizedTerminalItem(item, index);
-    if (normalized.type !== "message" || !Array.isArray(normalized.content))
-        return normalized;
-    return {
-        ...normalized,
-        content: normalized.content.map((part) => {
-            if (!isObject(part) || (part.type !== "output_text" && part.type !== "refusal"))
-                return structuredClone(part);
-            const text = sanitizeGrokVisibleText(String(part.text ?? part.refusal ?? ""));
-            return part.type === "output_text"
-                ? { ...structuredClone(part), text }
-                : { ...structuredClone(part), refusal: text };
-        }),
-    };
-}
 /** @param {UnknownRecord} item @param {number} index */
 function normalizedTerminalItem(item, index) {
     if (item.type === "message")
@@ -608,52 +574,43 @@ function recordMatches(record, item) {
  */
 async function* normalizedResponseEvents(source, meta = {}, options = {}) {
     const open = new Map();
-    const grokTextProjection = new Map();
-    const hiddenPrefixTokens = ["sources:", "render_inline_citation", "{render_inline_citation", "render_inline_citation", "stateless_invoke", "[[", "<|eos|>"];
-    const safeGrokRawPrefix = (raw, final) => {
-        if (final || raw.search(GROK_SOURCE_TAIL) >= 0)
-            return raw;
-        const lower = raw.toLowerCase();
-        let holdStart = raw.length;
-        const pendingSource = lower.lastIndexOf("sources:");
-        if (pendingSource >= 0 && (pendingSource === 0 || /\s/u.test(raw[pendingSource - 1] ?? "")))
-            holdStart = Math.min(holdStart, pendingSource);
-        for (const token of hiddenPrefixTokens) {
-            const complete = lower.lastIndexOf(token);
-            if (complete >= 0) {
-                const tail = raw.slice(complete);
-                if (sanitizeGrokVisibleText(tail).toLowerCase().includes(token.replace(/^\{/u, "")))
-                    holdStart = Math.min(holdStart, complete);
-            }
-            const max = Math.min(token.length - 1, lower.length);
-            for (let size = max; size > 0; size -= 1) {
-                if (lower.endsWith(token.slice(0, size))) {
-                    holdStart = Math.min(holdStart, raw.length - size);
-                    break;
-                }
-            }
+    const completed = new Set();
+    const completedWireItems = new Map();
+    const serverToolIds = new Map();
+    const citations = new Map();
+    const observeCitation = (candidate) => {
+        if (!isObject(candidate))
+            return;
+        try {
+            const url = new URL(String(candidate.url ?? ""));
+            if (url.protocol !== "http:" && url.protocol !== "https:")
+                return;
+            const title = typeof candidate.title === "string"
+                ? candidate.title.replace(/[\r\n]+/gu, " ").trim()
+                : "";
+            if (!citations.has(url.href))
+                citations.set(url.href, title);
         }
-        return raw.slice(0, holdStart);
+        catch { }
     };
-    const grokProjectionDelta = (index, rawText, final = false) => {
-        let state = grokTextProjection.get(index);
-        if (!state) {
-            state = { raw: "", emitted: "" };
-            grokTextProjection.set(index, state);
+    const observeCitations = (item) => {
+        if (!isObject(item))
+            return;
+        if (item.type === "message" && Array.isArray(item.content)) {
+            for (const part of item.content) {
+                if (!isObject(part) || part.type !== "output_text" || !Array.isArray(part.annotations))
+                    continue;
+                for (const annotation of part.annotations)
+                    if (isObject(annotation) && annotation.type === "url_citation")
+                        observeCitation(annotation);
+            }
         }
-        state.raw = rawText;
-        const target = sanitizeGrokVisibleText(safeGrokRawPrefix(rawText, final));
-        if (!target.startsWith(state.emitted))
-            return "";
-        const delta = target.slice(state.emitted.length);
-        state.emitted = target;
-        if (final)
-            grokTextProjection.delete(index);
-        return delta;
+        if (item.type === "web_search_call" &&
+            isObject(item.action) &&
+            Array.isArray(item.action.sources))
+            for (const source of item.action.sources)
+                observeCitation(source);
     };
-    const completed = new Set();
-    const completedWireItems = new Map();
-    const serverToolIds = new Map();
     const isServerToolItem = (value) => isObject(value) && options.serverToolTypes?.has(String(value.type ?? "")) === true;
     const observeServerTool = (item) => {
         const type = String(item.type);
@@ -686,6 +643,10 @@ async function* normalizedResponseEvents(source, meta = {}, options = {}) {
         const index = Number.isInteger(event.output_index)
             ? Number(event.output_index)
             : 0;
+        if ((event.type === "response.output_item.added" ||
+            event.type === "response.output_item.done") &&
+            isObject(event.item))
+            observeCitations(event.item);
         if (event.type === "response.output_item.done" && isObject(event.item))
             completedWireItems.set(index, structuredClone(event.item));
         if ((event.type === "response.output_item.added" ||
@@ -694,18 +655,10 @@ async function* normalizedResponseEvents(source, meta = {}, options = {}) {
             observeServerTool(event.item);
             continue;
         }
-        // Grok may send many encrypted reasoning items with no visible summary.
-        // Keep them in completedWireItems/nativeOutput, but do not open empty UI blocks.
-        if (options.serverToolTypes &&
-            (event.type === "response.output_item.added" || event.type === "response.output_item.done") &&
-            isObject(event.item) && event.item.type === "reasoning" &&
-            !itemText(event.item).trim() && !open.get(index)?.text.trim())
-            continue;
         if (event.type === "response.output_item.added" && isObject(event.item)) {
-            const rawItem = normalizedTerminalItem(event.item, index);
-            const item = options.serverToolTypes ? sanitizeGrokTerminalItem(rawItem, index) : rawItem;
-            open.set(index, { kind: itemKind(item), item: rawItem, text: itemText(rawItem) });
-            yield { ...event, item: options.serverToolTypes ? addedShell(item, index) : item };
+            const item = normalizedTerminalItem(event.item, index);
+            open.set(index, { kind: itemKind(item), item, text: itemText(item) });
+            yield { ...event, item };
             continue;
         }
         if (event.type === "response.output_text.delta") {
@@ -726,19 +679,11 @@ async function* normalizedResponseEvents(source, meta = {}, options = {}) {
                 record = next.value;
             }
             record.text = String(record.text ?? "") + String(event.delta ?? "");
-            if (!options.serverToolTypes)
-                yield event;
-            else {
-                const delta = grokProjectionDelta(index, record.text);
-                if (delta)
-                    yield { ...event, delta };
-            }
+            yield event;
             continue;
         }
         if (event.type === "response.reasoning_summary_text.delta" ||
             event.type === "response.reasoning_text.delta") {
-            if (options.serverToolTypes && !open.has(index) && !String(event.delta ?? "").trim())
-                continue;
             let record = open.get(index);
             if (!record) {
                 const item = {
@@ -810,13 +755,7 @@ async function* normalizedResponseEvents(source, meta = {}, options = {}) {
             continue;
         }
         if (event.type === "response.output_item.done" && isObject(event.item)) {
-            const rawItem = normalizedTerminalItem(event.item, index);
-            const item = options.serverToolTypes ? sanitizeGrokTerminalItem(rawItem, index) : rawItem;
-            if (options.serverToolTypes && item.type === "message") {
-                const delta = grokProjectionDelta(index, itemText(rawItem), true);
-                if (delta)
-                    yield { type: "response.output_text.delta", output_index: index, content_index: 0, item_id: item.id, delta };
-            }
+            const item = normalizedTerminalItem(event.item, index);
             const identity = itemIdentity(item);
             if (identity)
                 completed.add(identity);
@@ -836,23 +775,50 @@ async function* normalizedResponseEvents(source, meta = {}, options = {}) {
                     .sort(([left], [right]) => left - right)
                     .map(([, item]) => item);
             const nativeOutput = terminalOutput.map((item) => structuredClone(item));
+            const nativeVisibleAdditions = [];
             for (const item of terminalOutput) {
+                observeCitations(item);
                 if (isServerToolItem(item))
                     observeServerTool(item);
             }
             const output = terminalOutput
                 .filter((item) => !isServerToolItem(item))
-                .filter((item) => !(options.serverToolTypes && isObject(item) &&
-                item.type === "reasoning" && !itemText(item).trim()))
                 .map((item, terminalIndex) => isObject(item)
-                ? (options.serverToolTypes
-                    ? sanitizeGrokTerminalItem(item, terminalIndex)
-                    : normalizedTerminalItem(item, terminalIndex))
+                ? normalizedTerminalItem(item, terminalIndex)
                 : item);
+            if (options.serverToolTypes && citations.size > 0) {
+                const visibleText = output
+                    .filter(isObject)
+                    .map((item) => itemText(item))
+                    .join("\n");
+                const missing = [...citations].filter(([url]) => !visibleText.includes(url));
+                if (missing.length > 0) {
+                    const suffix = missing
+                        .map(([url, title]) => `- ${title ? `${title}: ` : ""}${url}`)
+                        .join("\n");
+                    const responseId = String(response.id ?? "native")
+                        .replace(/[^A-Za-z0-9_-]/gu, "_")
+                        .slice(0, 40);
+                    const fallbackItem = {
+                        type: "message",
+                        id: `msg_lcx_sources_${responseId}`.slice(0, 64),
+                        role: "assistant",
+                        status: "completed",
+                        content: [{
+                                type: "output_text",
+                                text: `\n\nSources:\n${suffix}`,
+                                annotations: [],
+                            }],
+                    };
+                    output.push(fallbackItem);
+                    nativeVisibleAdditions.push(structuredClone(fallbackItem));
+                }
+            }
             if (event.type === "response.completed" &&
                 response.status === "completed" &&
                 options.serverToolTypes) {
                 meta.nativeOutput = nativeOutput;
+                meta.nativeVisibleAdditions = nativeVisibleAdditions;
             }
             const used = new Set();
             for (const [streamIndex, record] of open) {
@@ -869,11 +835,6 @@ async function* normalizedResponseEvents(source, meta = {}, options = {}) {
                     : normalizedTerminalItem(record.item, streamIndex);
                 if (terminalIndex >= 0)
                     used.add(terminalIndex);
-                if (options.serverToolTypes && item.type === "message") {
-                    const delta = grokProjectionDelta(streamIndex, itemText(item), true);
-                    if (delta)
-                        yield { type: "response.output_text.delta", output_index: streamIndex, content_index: 0, item_id: item.id, delta };
-                }
                 yield {
                     type: "response.output_item.done",
                     output_index: streamIndex,
@@ -884,7 +845,6 @@ async function* normalizedResponseEvents(source, meta = {}, options = {}) {
                     completed.add(identity);
             }
             open.clear();
-            grokTextProjection.clear();
             for (const [terminalIndex, candidate] of output.entries()) {
                 if (!isObject(candidate) ||
                     !itemKind(candidate) ||
@@ -1000,7 +960,7 @@ function rawArguments(value) {
     }
 }
 /** @param {unknown} message */
-function replayState(message, nativeOutput, nativeReplayRoute) {
+function replayState(message, nativeOutput, nativeVisibleAdditions, nativeReplayRoute) {
     if (!isObject(message))
         return undefined;
     const content = Array.isArray(message.content)
@@ -1011,7 +971,7 @@ function replayState(message, nativeOutput, nativeReplayRoute) {
     const api = typeof message.api === "string" ? message.api : undefined;
     if (!provider || !model || !api)
         return undefined;
-    const grokNative = createGrokNativeReplayEnvelope(nativeOutput, nativeReplayRoute);
+    const grokNative = createGrokNativeReplayEnvelope(nativeOutput, nativeReplayRoute, nativeVisibleAdditions);
     return {
         response: {
             kind: "pi-ai",
@@ -1189,7 +1149,7 @@ async function* toDshChunks(events, signal, wireMeta, nativeReplayRoute) {
                 const reason = successfulFinish(message);
                 const replay = reason.kind === "error"
                     ? undefined
-                    : replayState(message, wireMeta?.nativeOutput, nativeReplayRoute);
+                    : replayState(message, wireMeta?.nativeOutput, wireMeta?.nativeVisibleAdditions, nativeReplayRoute);
                 yield {
                     type: "finish",
                     reason,

package/lib/types/grok-native-search.d.ts

@@ -16,19 +16,24 @@ type WireTool = Record<string, unknown>;
 type WireItem = Record<string, unknown> & {
     type: string;
 };
+type GrokNativeVisibleAddition = {
+    kind: "citation-sources";
+    textSha256: string;
+};
 type GrokNativeReplayEnvelope = {
     kind: "xai-responses-native-search";
-    version: 3;
+    version: 2;
     provider: string;
     model: string;
     sourceSessionId: string;
     routeAuthorityFingerprint: string;
     output: WireItem[];
+    visibleAdditions: GrokNativeVisibleAddition[];
 };
 export declare function grokNativeReplayRouteFingerprint(route: GrokNativeReplayRoute): string;
 export declare function grokNativeSearchEnabled(state: GrokNativeSearchState): boolean;
 export declare function grokVisibleFunctionTools(tools: readonly ToolSchema[] | undefined, state?: GrokNativeSearchState): ToolSchema[] | undefined;
 export declare function grokWireTools(tools: readonly unknown[] | undefined, state: GrokNativeSearchState): WireTool[];
-export declare function createGrokNativeReplayEnvelope(output: readonly unknown[] | undefined, route: GrokNativeReplayRoute | undefined): GrokNativeReplayEnvelope | undefined;
+export declare function createGrokNativeReplayEnvelope(output: readonly unknown[] | undefined, route: GrokNativeReplayRoute | undefined, visibleAdditions?: readonly unknown[]): GrokNativeReplayEnvelope | undefined;
 export declare function restoreGrokNativeReplay(input: readonly unknown[], messages: readonly Message[], route: GrokNativeReplayRoute | undefined): unknown[];
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-lcx-codex",
-  "version": "0.4.3-pre.12",
-  "description": "Model-scoped DSH plugin: GPT Responses lifecycle, Native V2 compaction and Hosted/Alpha Search; Grok native Web/X Search",
+  "version": "0.4.3-pre.3",
+  "description": "DSH GPT Responses lifecycle owner with Native V2 compaction/replay and Hosted/Alpha Search capabilities",
   "keywords": [
     "deepseek-harness",
     "dsh",
@@ -11,10 +11,7 @@
     "openai-responses",
     "sub2api",
     "newapi",
-    "compaction",
-    "grok",
-    "xai",
-    "x-search"
+    "compaction"
   ],
   "repository": {
     "type": "git",
@@ -59,7 +56,6 @@
     "@earendil-works/pi-ai": "0.85.1"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh": "0.1.5-alpha.1",
     "@deepseek-ai/schemastery": "^3.18.2",
     "@types/node": "^22.20.0",
     "@types/react": "~18.3.1",
@@ -68,21 +64,21 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-agent": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-attachment": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-client-locale": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-client-modules": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-client-store": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-client-ui-settings-plugins": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-compaction": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-credentials": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-fs": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-llm": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-session": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-settings": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-tool-web": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-tools": "0.1.5-alpha.1",
-    "@deepseek-ai/dsh-web": "0.1.5-alpha.1",
+    "@deepseek-ai/dsh-agent": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-attachment": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-client-locale": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-client-modules": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-client-store": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-client-ui-settings-plugins": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-compaction": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-credentials": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-fs": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-llm": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-session": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-settings": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-tool-web": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-tools": "0.1.3-alpha.2",
+    "@deepseek-ai/dsh-web": "0.1.3-alpha.2",
     "@deepseek-ai/schemastery": "^3.18.2",
     "react": "^18.2.0"
   },