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

package/lib/dsh-compat.js

@@ -132,43 +132,105 @@ export function compactionPatchCandidate(value, records) {
         typeof compaction.compactIfNeeded !== "function" ||
         records.has(compaction))
         return undefined;
+    let originalOwnDescriptor;
+    try {
+        originalOwnDescriptor = Object.getOwnPropertyDescriptor(compaction, "compactIfNeeded");
+    }
+    catch {
+        return undefined;
+    }
     return {
         compaction: compaction,
         original: compaction.compactIfNeeded,
+        originalOwnDescriptor,
     };
 }
-export function installCompactionPatch(records, candidate, mutex, lifecycle, behavior) {
-    const { compaction, original } = candidate;
+function inheritedPropertyDescriptor(target, key) {
+    try {
+        for (let current = Object.getPrototypeOf(target); current; current = Object.getPrototypeOf(current)) {
+            const descriptor = Object.getOwnPropertyDescriptor(current, key);
+            if (descriptor)
+                return descriptor;
+        }
+    }
+    catch { }
+    return undefined;
+}
+function sameDataDescriptor(left, right) {
+    return (left !== undefined &&
+        "value" in left &&
+        "value" in right &&
+        left.value === right.value &&
+        left.writable === right.writable &&
+        left.enumerable === right.enumerable &&
+        left.configurable === right.configurable);
+}
+export function installCompactionPatch(records, candidate, mutex, policyScope, lifecycle, behavior) {
+    const { compaction, original, originalOwnDescriptor } = candidate;
+    if (originalOwnDescriptor &&
+        (!("value" in originalOwnDescriptor) || originalOwnDescriptor.writable !== true))
+        return false;
+    if (!originalOwnDescriptor) {
+        const inherited = inheritedPropertyDescriptor(compaction, "compactIfNeeded");
+        if (!inherited || !("value" in inherited) || inherited.writable !== true)
+            return false;
+    }
     const callOriginal = async (agent, trigger, signal) => {
         const result = Reflect.apply(original, compaction, [agent, trigger, signal]);
         return Promise.resolve(result);
     };
-    const record = {
-        compaction,
-        original,
-        mutex,
-        lifecycle,
-        wrapper: async function (agent, trigger, signal) {
-            return behavior(agent, trigger, signal, (activeSignal) => callOriginal(agent, trigger, activeSignal));
-        },
+    const wrapper = async function (agent, trigger, signal) {
+        return behavior(agent, trigger, signal, (activeSignal) => callOriginal(agent, trigger, activeSignal));
     };
+    const installedOwnDescriptor = originalOwnDescriptor
+        ? { ...originalOwnDescriptor, value: wrapper }
+        : {
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value: wrapper,
+        };
     try {
-        compaction.compactIfNeeded = record.wrapper;
+        Object.defineProperty(compaction, "compactIfNeeded", installedOwnDescriptor);
     }
     catch {
         return false;
     }
-    records.set(compaction, record);
+    if (!sameDataDescriptor(Object.getOwnPropertyDescriptor(compaction, "compactIfNeeded"), installedOwnDescriptor)) {
+        try {
+            if (originalOwnDescriptor)
+                Object.defineProperty(compaction, "compactIfNeeded", originalOwnDescriptor);
+            else
+                Reflect.deleteProperty(compaction, "compactIfNeeded");
+        }
+        catch { }
+        return false;
+    }
+    records.set(compaction, {
+        compaction,
+        original,
+        originalOwnDescriptor,
+        installedOwnDescriptor,
+        wrapper,
+        mutex,
+        policyScope,
+        lifecycle,
+    });
     return true;
 }
 export function restoreCompactionPatches(records, entries = records.values()) {
-    for (const record of entries)
-        if (record.compaction.compactIfNeeded === record.wrapper) {
-            try {
-                record.compaction.compactIfNeeded = record.original;
-            }
-            catch { }
+    for (const record of entries) {
+        const current = Object.getOwnPropertyDescriptor(record.compaction, "compactIfNeeded");
+        if (!sameDataDescriptor(current, record.installedOwnDescriptor))
+            continue;
+        try {
+            if (record.originalOwnDescriptor)
+                Object.defineProperty(record.compaction, "compactIfNeeded", record.originalOwnDescriptor);
+            else
+                Reflect.deleteProperty(record.compaction, "compactIfNeeded");
         }
+        catch { }
+    }
     records.clear();
 }
 export function toolResultPrunerState(value) {

package/lib/dsh-responses.js

@@ -1,7 +1,5 @@
 import { offloadedImageText, offloadRequestImagesWithPolicy, requestImageHandleText, resolveImageAttachmentAccess, } from "@deepseek-ai/dsh-llm";
-import { convertResponsesMessages, convertResponsesTools, } from "@earendil-works/pi-ai/api/openai-responses-shared";
-import { createGrammarToolInputProperties } from "@earendil-works/pi-ai/api/constrained-sampling";
-import { getBuiltinModels } from "@earendil-works/pi-ai/providers/all";
+import { convertResponsesMessages, convertResponsesTools, createGrammarToolInputProperties, getBuiltinModels, } from "./pi-responses-runtime.js";
 const DEFAULT_MAX_REQUEST_IMAGE_BYTES = 20 * 1024 * 1024;
 const DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET = 2048 * 2048;
 const DEFAULT_REQUEST_IMAGE_MAX_BYTES = 1024 * 1024;
@@ -93,7 +91,7 @@ function attachmentResolver(ctx, options) {
     const attachments = attachmentServices(ctx?.attachments);
     return async (block, signal) => {
         if (attachments === undefined)
-            throw error("LCX requires the DSH 0.1.3 request-image attachment API", "LCX_COMPACT_IMAGE_API_UNAVAILABLE");
+            throw error("LCX requires the DSH 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;
@@ -159,6 +157,57 @@ function unsupportedContent(type) {
 function replayBlockType(type) {
     return type === "text" || type === "reasoning" || type === "tool-call" ? type : undefined;
 }
+function replayTextPhase(signature) {
+    if (typeof signature !== "string" || !signature.startsWith("{"))
+        return undefined;
+    try {
+        const parsed = JSON.parse(signature);
+        if (!isObject(parsed) || parsed.v !== 1 || typeof parsed.id !== "string")
+            return undefined;
+        return parsed.phase === "commentary" || parsed.phase === "final_answer"
+            ? parsed.phase
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function restorePortableAssistantPhases(input, messages, target) {
+    const slots = [];
+    for (const message of messages) {
+        if (message.role !== "assistant" || message.stopReason === "error" || message.stopReason === "aborted")
+            continue;
+        const sameProviderAndApi = message.provider === target.provider && message.api === target.api;
+        const sameModel = sameProviderAndApi && message.model === target.id;
+        for (const block of message.content) {
+            if (block.type === "text") {
+                const phase = sameProviderAndApi && !sameModel
+                    ? replayTextPhase(block.textSignature)
+                    : undefined;
+                slots.push({ text: block.text, ...(phase === undefined ? {} : { phase }) });
+            }
+            else if (block.type === "thinking" && !sameModel && !block.redacted && block.thinking.trim()) {
+                slots.push({ text: block.thinking });
+            }
+        }
+    }
+    const output = structuredClone(input);
+    let slotIndex = 0;
+    for (const [index, candidate] of output.entries()) {
+        if (!isObject(candidate) || candidate.type !== "message" || candidate.role !== "assistant" ||
+            !Array.isArray(candidate.content))
+            continue;
+        const slot = slots[slotIndex++];
+        if (slot?.phase === undefined)
+            continue;
+        const text = candidate.content
+            .map((part) => isObject(part) && part.type === "output_text" ? String(part.text ?? "") : "")
+            .join("");
+        if (text === slot.text)
+            output[index] = { ...candidate, phase: slot.phase };
+    }
+    return output;
+}
 export function readDshPiReplayState(value) {
     if (!isObject(value))
         throw invalidReplay("expected a replay envelope");
@@ -250,6 +299,8 @@ async function piToolContent(blocks, ctx, options, imageMap) {
             content.push({ type: "text", text: block.text });
         else if (block.type === "image")
             content.push(...(await piImageParts(block, ctx, options, imageMap)));
+        else if (block.type === "reasoning")
+            continue;
         else if (block.type === "tool-result")
             content.push(...(await piToolContent(block.content, ctx, options, imageMap)));
         else
@@ -280,13 +331,25 @@ 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 = [];
+    const toolNames = new Map();
     for (const message of messages) {
-        if (message.role === "system")
+        if (message.role === "system") {
+            result.push({ role: "user", content: flattenMessageText(message), timestamp: 0 });
             continue;
+        }
         if (message.role === "assistant") {
-            result.push(toPiAssistant(message, options.onReplayDegrade));
+            const assistant = toPiAssistant(message, options.onReplayDegrade);
+            for (const block of assistant.content)
+                if (block.type === "toolCall")
+                    toolNames.set(String(block.id), block.name);
+            result.push(assistant);
             continue;
         }
         const ordinary = [];
@@ -294,6 +357,8 @@ async function dshToPiMessages(messages, ctx, options, imageMap) {
         for (const block of message.content) {
             if (block.type === "text" || block.type === "image")
                 ordinary.push(block);
+            else if (block.type === "reasoning")
+                continue;
             else if (block.type === "tool-result")
                 toolResults.push(block);
             else
@@ -313,7 +378,8 @@ async function dshToPiMessages(messages, ctx, options, imageMap) {
         for (const block of toolResults) {
             if (block.type !== "tool-result")
                 continue;
-            result.push({ role: "toolResult", toolCallId: String(block.toolCallId), toolName: "unknown", content: await piToolContent(block.content, ctx, options, imageMap), addedToolNames: [], isError: block.isError === true, timestamp: 0 });
+            const toolCallId = String(block.toolCallId);
+            result.push({ role: "toolResult", toolCallId, toolName: toolNames.get(toolCallId) ?? "unknown", content: await piToolContent(block.content, ctx, options, imageMap), addedToolNames: [], isError: block.isError === true, timestamp: 0 });
         }
     }
     return result;
@@ -379,7 +445,8 @@ export async function serializeDshMessages(messages, ctx, options = {}) {
         tools: context.tools,
     };
     const piModel = model;
-    const input = convertResponsesMessages(piModel, piContext, new Set(["openai", "openai-codex", "opencode"]), { includeSystemPrompt: normalized.includeSystemPrompt, grammarToolInputProperties, deferredTools: new Map(), deferredToolsMode, toolOptions });
+    const convertedInput = convertResponsesMessages(piModel, piContext, new Set(["openai", "openai-codex", "opencode"]), { includeSystemPrompt: normalized.includeSystemPrompt, grammarToolInputProperties, deferredTools: new Map(), deferredToolsMode, toolOptions });
+    const input = restorePortableAssistantPhases(convertedInput, context.messages, { provider: model.provider, id: model.id, api: model.api });
     const tools = options.tools === undefined ? undefined : convertResponsesTools([...immediateTools.values()], toolOptions);
     return { input, imageMap, tools, model: piModel, grammarToolInputProperties, deferredToolsMode };
 }

package/lib/grok-native-search.js

@@ -8,6 +8,13 @@ const GROK_EXCLUDED_SEARCH_FUNCTIONS = new Set([
     "websearch_gpt_advanced",
     "websearch_alpha",
 ]);
+const GROK_NATIVE_X_EXTENSION_NAMES = new Set([
+    "x_user_search",
+    "x_keyword_search",
+    "x_semantic_search",
+    "x_thread_fetch",
+]);
+const GROK_NATIVE_WEB_EXTENSION_NAMES = new Set(["browse_page"]);
 const GROK_NATIVE_VISIBLE_ITEM_TYPES = new Set([
     "message",
     "reasoning",
@@ -16,9 +23,104 @@ const GROK_NATIVE_VISIBLE_ITEM_TYPES = new Set([
 ]);
 const GROK_NATIVE_REPLAY_MAX_ITEMS = 256;
 const GROK_NATIVE_REPLAY_MAX_CHARS = 8 * 1024 * 1024;
+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+)\}?[ \t]*/giu;
+const GROK_CITATION_ID_MARKER = /([ \t]?)\{render_inline_citation:citation_id=(\d+)\}/giu;
+const GROK_UI_CITATION_MARKER = /render_inline_citation[^\r\n]*[ \t]*/giu;
+const GROK_PRIVATE_RENDER_MARKER = /[\uE000-\uF8FF]render_inline_citation[^\uE000-\uF8FF\r\n]*[\uE000-\uF8FF][ \t]*/giu;
+const GROK_EOS_MARKER = /<\|eos\|>/giu;
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function citationId(annotation) {
+    const value = annotation.citation_id ?? annotation.citationId ?? annotation.id;
+    return typeof value === "string" || typeof value === "number"
+        ? String(value)
+        : undefined;
+}
+function citationUrl(annotation) {
+    if (annotation.type !== "url_citation" || typeof annotation.url !== "string")
+        return undefined;
+    try {
+        const parsed = new URL(annotation.url);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+            return undefined;
+        return annotation.url.replace(/\)/gu, "%29");
+    }
+    catch {
+        return undefined;
+    }
+}
+function stripTrailingSourcesList(value) {
+    const newline = value.includes("\r\n") ? "\r\n" : "\n";
+    const lines = value.split(/\r?\n/u);
+    let fence;
+    for (let index = 0; index < lines.length; index += 1) {
+        const fenceMatch = /^\s*(```|~~~)/u.exec(lines[index] ?? "");
+        if (fenceMatch) {
+            const marker = fenceMatch[1];
+            fence = fence === marker ? undefined : fence ?? marker;
+            continue;
+        }
+        if (fence !== undefined || !/^\s*Sources:[ \t]*$/iu.test(lines[index] ?? ""))
+            continue;
+        let sourceCount = 0;
+        let validTail = true;
+        for (const line of lines.slice(index + 1)) {
+            if (!line.trim())
+                continue;
+            if (/^\s*[-*][ \t]+.*https?:\/\/\S+/iu.test(line))
+                sourceCount += 1;
+            else {
+                validTail = false;
+                break;
+            }
+        }
+        if (validTail && sourceCount > 0)
+            return lines.slice(0, index).join(newline);
+    }
+    return value;
+}
+export function grokPendingSourcesStart(value) {
+    const lines = value.split(/(?<=\n)/u);
+    let offset = 0;
+    let fence;
+    let candidate;
+    for (const lineWithEnding of lines) {
+        const line = lineWithEnding.replace(/\r?\n$/u, "");
+        const fenceMatch = /^\s*(```|~~~)/u.exec(line);
+        if (fenceMatch) {
+            const marker = fenceMatch[1];
+            fence = fence === marker ? undefined : fence ?? marker;
+        }
+        else if (fence === undefined && /^\s*Sources:[ \t]*$/iu.test(line)) {
+            candidate = offset;
+        }
+        offset += lineWithEnding.length;
+    }
+    return candidate;
+}
+export function sanitizeGrokVisibleText(value, annotations = []) {
+    const citations = new Map();
+    for (const candidate of annotations) {
+        if (!isRecord(candidate))
+            continue;
+        const id = citationId(candidate);
+        const url = citationUrl(candidate);
+        if (id !== undefined && url !== undefined && !citations.has(id))
+            citations.set(id, url);
+    }
+    let text = value
+        .replace(GROK_CITATION_ID_MARKER, (_marker, leading, id) => {
+        const url = citations.get(id);
+        return url === undefined ? "" : `${leading}[[${id}]](${url})`;
+    })
+        .replace(GROK_RENDER_MARKER, "")
+        .replace(GROK_UI_CITATION_MARKER, "")
+        .replace(GROK_PRIVATE_RENDER_MARKER, "")
+        .replace(GROK_EOS_MARKER, "");
+    text = stripTrailingSourcesList(text);
+    return text.trimEnd();
+}
 function canonicalHeaders(headers) {
     return Object.entries(headers ?? {})
         .map(([name, value]) => [name.toLowerCase(), value])
@@ -43,6 +145,21 @@ export function grokVisibleFunctionTools(tools, state = { web: false, x: false }
     return tools?.filter((tool) => !GROK_EXCLUDED_SEARCH_FUNCTIONS.has(tool.name) &&
         !(state.x && tool.name === "x_search"));
 }
+export function isGrokNativeServerToolItem(value, state, declaredToolNames) {
+    if (!isRecord(value) || typeof value.type !== "string")
+        return false;
+    if (GROK_NATIVE_SERVER_TOOL_TYPES.has(value.type))
+        return true;
+    if (value.type !== "custom_tool_call" || typeof value.name !== "string" ||
+        declaredToolNames.has(value.name) || typeof value.id !== "string" ||
+        !value.id.startsWith("ctc_") || typeof value.call_id !== "string")
+        return false;
+    if (state.x && GROK_NATIVE_X_EXTENSION_NAMES.has(value.name) &&
+        value.call_id.startsWith("xs_call-"))
+        return true;
+    return state.web && GROK_NATIVE_WEB_EXTENSION_NAMES.has(value.name) &&
+        (value.call_id.startsWith("ws_call-") || value.call_id.startsWith("web_search_call-"));
+}
 export function grokWireTools(tools, state) {
     const nativeTypes = new Set(["web_search", "x_search"]);
     const result = (tools ?? [])
@@ -75,37 +192,10 @@ 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 !== 1 && value.version !== 2))
+        value.version !== 3)
         return undefined;
     if (value.provider !== route.provider ||
         value.model !== route.model ||
@@ -127,16 +217,16 @@ function readGrokNativeReplayEnvelope(value, route) {
     const output = [];
     const itemKinds = new Map();
     const callIds = new Set();
-    const migratedAdditions = [];
+    if (value.serverSearchEchoCallIds !== undefined &&
+        (!Array.isArray(value.serverSearchEchoCallIds) ||
+            !value.serverSearchEchoCallIds.every((id) => typeof id === "string" && id.length > 0) ||
+            new Set(value.serverSearchEchoCallIds).size !== value.serverSearchEchoCallIds.length))
+        return undefined;
+    const serverSearchEchoCallIds = new Set(value.serverSearchEchoCallIds ?? []);
     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;
@@ -163,45 +253,45 @@ function readGrokNativeReplayEnvelope(value, route) {
     }
     if (output.length === 0)
         return undefined;
-    const visibleAdditions = value.version === 1
-        ? migratedAdditions
-        : validVisibleAdditions(value.visibleAdditions);
-    if (!visibleAdditions)
-        return undefined;
+    for (const id of serverSearchEchoCallIds)
+        if (!output.some((item) => item.type === "custom_tool_call" && item.call_id === id))
+            return undefined;
     return {
         kind: "xai-responses-native-search",
-        version: 2,
+        version: 3,
         provider: route.provider,
         model: route.model,
         sourceSessionId: route.sessionId,
         routeAuthorityFingerprint: grokNativeReplayRouteFingerprint(route),
+        ...(serverSearchEchoCallIds.size > 0 ? { serverSearchEchoCallIds: [...serverSearchEchoCallIds] } : {}),
         output,
-        visibleAdditions,
     };
 }
-export function createGrokNativeReplayEnvelope(output, route, visibleAdditions = []) {
+export function createGrokNativeReplayEnvelope(output, route, serverSearchEchoCallIds = []) {
     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: 2,
+        version: 3,
         provider: route.provider,
         model: route.model,
         sourceSessionId: route.sessionId,
         routeAuthorityFingerprint: grokNativeReplayRouteFingerprint(route),
+        ...(serverSearchEchoCallIds.length > 0 ? { serverSearchEchoCallIds: [...serverSearchEchoCallIds] } : {}),
         output,
-        visibleAdditions: additions,
     }, route);
 }
-function itemText(item) {
+function itemText(item, visible = false) {
     if (item.type === "message")
         return (Array.isArray(item.content) ? item.content : [])
-            .map((part) => isRecord(part) ? String(part.text ?? part.refusal ?? "") : "")
+            .map((part) => {
+            if (!isRecord(part))
+                return "";
+            const text = String(part.text ?? part.refusal ?? "");
+            return visible
+                ? sanitizeGrokVisibleText(text, Array.isArray(part.annotations) ? part.annotations : [])
+                : text;
+        })
             .join("");
     if (item.type === "reasoning") {
         const parts = Array.isArray(item.summary) && item.summary.length > 0
@@ -213,7 +303,7 @@ function itemText(item) {
 }
 function visibleItemMatchesBlock(item, block) {
     if (item.type === "message")
-        return block.type === "text" && block.text === itemText(item);
+        return block.type === "text" && block.text === itemText(item, true);
     if (item.type === "reasoning")
         return block.type === "reasoning" && block.text === itemText(item);
     if (item.type === "function_call")
@@ -233,19 +323,6 @@ 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;
@@ -257,7 +334,9 @@ function replayForMessage(message, route) {
     const envelope = readGrokNativeReplayEnvelope(replayState.grokNative, route);
     if (!envelope)
         return undefined;
-    const visible = envelope.output.filter((item) => !GROK_NATIVE_SERVER_TOOL_TYPES.has(item.type));
+    const serverSearchEchoCallIds = new Set(envelope.serverSearchEchoCallIds ?? []);
+    const visible = envelope.output.filter((item) => !GROK_NATIVE_SERVER_TOOL_TYPES.has(item.type) &&
+        !(item.type === "custom_tool_call" && serverSearchEchoCallIds.has(String(item.call_id))));
     if (visible.length === 0)
         return undefined;
     const reasoningCounts = new Map();
@@ -272,22 +351,18 @@ function replayForMessage(message, route) {
             anchors.push(item);
             blockIndex += 1;
         }
-        else if (!(item.type === "reasoning" && (reasoningCounts.get(String(item.id)) ?? 0) > 1)) {
+        else if (!(item.type === "reasoning" &&
+            (!itemText(item).trim() || (reasoningCounts.get(String(item.id)) ?? 0) > 1))) {
             return undefined;
         }
     }
-    // Pi can coalesce repeated reasoning IDs in terminal-only gateway responses.
-    // Match every provider-visible DSH block and only the hashed LCX additions.
+    // 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.
     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, additions: envelope.visibleAdditions };
+    return { envelope, visible: anchors };
 }
 export function restoreGrokNativeReplay(input, messages, route) {
     const restored = structuredClone(input);
@@ -298,12 +373,11 @@ export function restoreGrokNativeReplay(input, messages, route) {
         const replay = replayForMessage(message, route);
         if (!replay)
             continue;
-        const { envelope, visible, additions } = replay;
-        const replacedLength = visible.length + additions.length;
+        const { envelope, visible } = replay;
+        const replacedLength = visible.length;
         let start = -1;
         for (let index = cursor; index <= restored.length - replacedLength; index += 1) {
-            if (visible.every((item, offset) => visibleItemMatchesInput(item, restored[index + offset])) &&
-                additions.every((addition, offset) => additionMatchesInput(addition, restored[index + visible.length + offset]))) {
+            if (visible.every((item, offset) => visibleItemMatchesInput(item, restored[index + offset]))) {
                 start = index;
                 break;
             }