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

package/lib/index.js

@@ -1,4 +1,6 @@
 import z from "@deepseek-ai/schemastery";
+import { recordHostedUsage, withAuxiliaryUsage } from "./auxiliary-usage.js";
+import { installSearchUsage } from "./search-usage.js";
 import { WEB_SEARCH_MAX_QUERIES, applyWebSearchTool, } from "@deepseek-ai/dsh-tool-web";
 import "@deepseek-ai/dsh-agent";
 import "@deepseek-ai/dsh-tools";
@@ -7,21 +9,22 @@ import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import { getSupportedThinkingLevels } from "./pi-responses-runtime.js";
 import { fetchJsonWithRetry } from "./transport.js";
 import { agentSessionId, agentUsesSession, compactionConfigState, compactionPatchCandidate, installCompactionPatch, patchCompactionConfig, patchToolResultPruner, readAgentRouteState, resolveAgentService, resolveContextService, resolveScopedService, restoreCompactionConfig, restoreCompactionPatches, restoreToolResultPruner, sessionFor, sessionFromAgent, scopedToolRuntime, tokenMeterTotal, toolResultPrunerState, } from "./dsh-compat.js";
+import { InvocationPolicyScope } from "./invocation-policy-scope.js";
 import { authenticatedGrokHeaders, authenticatedHeaders, currentRoute, generationControlsFromSession, grokPromptCacheSessionId, promptCacheKey, promptCacheRetention, promptCacheSessionId, resolveGrokResponsesRouteConfig, resolveResponsesRouteConfig, routeFingerprint, } from "./route.js";
 import { DEFAULT_MAX_REQUEST_IMAGE_BYTES, DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET, DEFAULT_REQUEST_IMAGE_MAX_BYTES, hydrateNativeImageReferences, resolveModelImageSupport, responseInputItems, serializeDshMessages, } from "./dsh-responses.js";
 import { mergeFeatureHeader, requestNativeCompaction } from "./compact-v2.js";
 import { buildResponsesBody } from "./responses-request.js";
 import { managedFailureChunk, streamResponsesRequest, } from "./responses-stream.js";
 import { assertSupportedCheckpointMessage, checkpointStateForMessage, compactCheckpointId, createNativeCheckpointBlock, nativeCheckpointChunks, portableMessagesForCheckpoint, stateRouteCompatible, } from "./native-checkpoint.js";
-import { HOSTED_SEARCH_OUTPUT, HOSTED_SEARCH_PARAMETERS, buildHostedSearchBody, normalizeHostedSearchArgs, parseHostedSearchResponse, renderHostedSearchResult, } from "./web-search-hosted.js";
-import { ALPHA_SCHEMA_FINGERPRINT, alphaRefRequiresStore, isAlphaContinuationUrl, isAlphaHttpUrl, ALPHA_SEARCH_OUTPUT, ALPHA_SEARCH_PARAMETERS, buildAlphaSearchBody, normalizeAlphaSearchArgs, parseAlphaSearchResponse, renderAlphaSearchResult, } from "./web-search-alpha.js";
-import { AlphaCapabilityStore, alphaCapabilityFingerprint, alphaCapabilityUsable, } from "./web-search-capability.js";
+import { HOSTED_SEARCH_OUTPUT, HOSTED_SEARCH_PARAMETERS, buildHostedSearchBody, hostedMediaPresentationMeta, normalizeHostedSearchArgs, parseHostedSearchResponse, renderHostedSearchResult, } from "./web-search-hosted.js";
+import { ALPHA_SCHEMA_FINGERPRINT, alphaRefRequiresStore, isAlphaContinuationUrl, isAlphaHttpUrl, ALPHA_SEARCH_OUTPUT, ALPHA_SEARCH_PARAMETERS, alphaSearchRetryOptions, buildAlphaSearchBody, normalizeAlphaSearchArgs, parseAlphaSearchResponse, renderAlphaSearchResult, runWithAlphaSessionLock, } from "./web-search-alpha.js";
+import { AlphaCapabilityStore, alphaCapabilityFingerprint, alphaCapabilityUsable, alphaSearchParametersFor, assertAlphaActionAllowed, } from "./web-search-capability.js";
 import { AlphaRefStore } from "./web-search-ref-store.js";
 import { ServiceMutex } from "./service-mutex.js";
-import { GROK_NATIVE_SERVER_TOOL_TYPES, grokNativeSearchEnabled, grokVisibleFunctionTools, grokWireTools, restoreGrokNativeReplay, } from "./grok-native-search.js";
+import { GROK_NATIVE_SERVER_TOOL_TYPES, grokNativeSearchEnabled, grokVisibleFunctionTools, isGrokNativeServerToolItem, grokWireTools, restoreGrokNativeReplay, } from "./grok-native-search.js";
 export const name = "lcx-codex";
 export const inject = ["llm", "web", "sessions", "tools", "settings", "credentials", "attachments", "fs"];
 const SETTINGS_NS = "lcx-codex";
@@ -118,6 +121,7 @@ const SettingsSchema = z.object({
     alphaSearch: z.boolean().default(false),
     grokNativeWebSearch: z.boolean().default(false),
     grokNativeXSearch: z.boolean().default(false),
+    searchMediaPreview: z.boolean().default(false),
 });
 function normalizeConfig(input = {}) {
     return {
@@ -201,6 +205,7 @@ async function executeHostedSearch(ctx, routeConfig, args, signal, sessionId = "
         maxAttempts: routeConfig.maxAttempts,
         maxResponseBytes: routeConfig.maxResponseBytes,
     });
+    recordHostedUsage(response, requestId, routeConfig.provider, routeConfig.model);
     return parseHostedSearchResponse(response, requestId, routeConfig.webMaxResults);
 }
 class LcxResponsesSearchProvider {
@@ -261,8 +266,15 @@ function createScopedGptWebSearchTool(ctx, state, getConfig, provider, fetchEnab
     if (!definition)
         throw new Error("DSH web_search composition did not register a tool");
     const execute = definition.execute.bind(definition);
-    return {
+    const output = definition.output;
+    return withAuxiliaryUsage({
         ...definition,
+        output: {
+            ...output,
+            presentationMeta(args, value) {
+                return hostedMediaPresentationMeta(value, "web_search", output.presentationMeta?.(args, value));
+            },
+        },
         async execute(args, exec) {
             if (!state.enabled || !state.webSearch)
                 throw webError("web_search GPT Hosted Search is disabled", "LCX_WEB_DISABLED");
@@ -272,16 +284,17 @@ function createScopedGptWebSearchTool(ctx, state, getConfig, provider, fetchEnab
                 throw webError("GPT Hosted Search requires the active GPT openai-responses route", "LCX_WEB_ROUTE_UNAVAILABLE");
             return hostedSearchRouteContext.run(active, () => execute(args, exec));
         },
-    };
+    });
 }
 function createAdvancedHostedTool(ctx, state, getConfig) {
-    return {
+    return withAuxiliaryUsage({
         name: ADVANCED_HOSTED_TOOL,
         description: "Advanced GPT Responses Hosted Search. Use DSH web_search for ordinary lookup. Call this only when you need domain allow/block filters, approximate user location, search-context size, image search, external-web-access or return-token-budget controls. It is one-shot and has no open/find/click state.",
         parameters: HOSTED_SEARCH_PARAMETERS,
         output: {
             schema: HOSTED_SEARCH_OUTPUT,
             render: (_args, value) => renderHostedSearchResult(value),
+            presentationMeta: (_args, value) => hostedMediaPresentationMeta(value, ADVANCED_HOSTED_TOOL),
         },
         async execute(args, exec) {
             if (!state.enabled || !state.webSearch || !state.advancedHostedSearch)
@@ -293,7 +306,7 @@ function createAdvancedHostedTool(ctx, state, getConfig) {
                 throw webError("Advanced Hosted Search requires the active GPT openai-responses route", "LCX_WEB_ROUTE_UNAVAILABLE");
             return executeHostedSearch(ctx, routeWithPolicies(route, config), args, exec.signal, active.sessionId);
         },
-    };
+    });
 }
 function disposeGptToolsForAgent(agent, registrations) {
     const registration = registrations.get(agent);
@@ -376,52 +389,69 @@ function verifiedAlphaCapabilityForRoute(ctx, active, config, store) {
     };
 }
 async function executeAlpha(ctx, routeConfig, capability, refStore, args, exec) {
-    const normalized = normalizeAlphaSearchArgs(args);
-    if (["open", "find", "screenshot"].includes(normalized.action) &&
-        isAlphaHttpUrl(normalized.refId) &&
-        !isAlphaContinuationUrl(normalized.refId)) {
-        throw webError("Alpha Search direct URLs must be public HTTP(S) targets", "LCX_ALPHA_URL_UNAVAILABLE");
-    }
     const sessionId = agentSessionId(exec?.agent);
     if (!sessionId)
         throw webError("Alpha Search requires a DSH session", "LCX_ALPHA_SESSION_REQUIRED");
-    const routeFp = routeFingerprint({
-        provider: routeConfig.provider,
-        model: routeConfig.model,
-        baseURL: routeConfig.baseURL,
-        sessionId,
-    });
-    if (alphaRefRequiresStore(normalized.action, normalized.refId))
-        refStore.assertUsable(sessionId, routeFp, normalized.refId);
-    const requestId = randomUUID();
-    const headers = await authenticatedHeaders(ctx, routeConfig, sessionId, requestId);
-    let response;
-    try {
-        response = await fetchJsonWithRetry(`${routeConfig.baseURL}/alpha/search`, buildAlphaSearchBody(normalized, routeConfig.model, sessionId, true, routeConfig.alphaMaxOutputTokens), headers, exec?.signal, routeConfig.timeoutMs, {
-            maxAttempts: routeConfig.maxAttempts,
-            maxResponseBytes: routeConfig.maxResponseBytes,
+    return runWithAlphaSessionLock(sessionId, exec?.signal, async () => {
+        const normalized = normalizeAlphaSearchArgs(args);
+        assertAlphaActionAllowed(capability, normalized.action);
+        if (["open", "find", "screenshot"].includes(normalized.action) &&
+            isAlphaHttpUrl(normalized.refId) &&
+            !isAlphaContinuationUrl(normalized.refId)) {
+            throw webError("Alpha Search direct URLs must be public HTTP(S) targets", "LCX_ALPHA_URL_UNAVAILABLE");
+        }
+        const routeFp = routeFingerprint({
+            provider: routeConfig.provider,
+            model: routeConfig.model,
+            baseURL: routeConfig.baseURL,
+            sessionId,
         });
-    }
-    catch (error) {
-        const details = errorDetails(error);
-        if ([404, 405].includes(Number(details.status)) ||
-            /channel does not support/iu.test(String(details.message ?? "")))
-            throw webError("Alpha Search is not supported by this route", "LCX_ALPHA_UNAVAILABLE", error);
-        throw webError("Alpha Search provider request failed", "LCX_ALPHA_PROVIDER_ERROR", error);
-    }
-    const { refRecords, ...result } = parseAlphaSearchResponse(response, {
-        action: normalized.action,
-        capability: capability.classification,
-        requestId,
+        const continuedRef = alphaRefRequiresStore(normalized.action, normalized.refId)
+            ? refStore.assertUsable(sessionId, routeFp, normalized.refId)
+            : undefined;
+        const requestId = randomUUID();
+        const headers = await authenticatedHeaders(ctx, routeConfig, sessionId, requestId);
+        let response;
+        try {
+            response = await fetchJsonWithRetry(`${routeConfig.baseURL}/alpha/search`, buildAlphaSearchBody(normalized, routeConfig.model, sessionId, true, routeConfig.alphaMaxOutputTokens), headers, exec?.signal, routeConfig.timeoutMs, alphaSearchRetryOptions(routeConfig.maxResponseBytes));
+        }
+        catch (error) {
+            const details = errorDetails(error);
+            if ([404, 405].includes(Number(details.status)) ||
+                /channel does not support/iu.test(String(details.message ?? "")))
+                throw webError("Alpha Search is not supported by this route", "LCX_ALPHA_UNAVAILABLE", error);
+            throw webError("Alpha Search provider request failed", "LCX_ALPHA_PROVIDER_ERROR", error);
+        }
+        const { refRecords: observedRefs, ...result } = parseAlphaSearchResponse(response, {
+            action: normalized.action,
+            capability: capability.classification,
+            requestId,
+        });
+        const refRecords = observedRefs.map((observation) => {
+            if (observation.refId !== normalized.refId || !continuedRef)
+                return observation;
+            const observedArtifact = observation.provenance.artifactFingerprint;
+            const acceptedArtifact = continuedRef.provenance.artifactFingerprint;
+            if (observedArtifact && observedArtifact !== acceptedArtifact)
+                return observation;
+            // An echoed input ref retains its accepted origin; an omitted URL makes no new claim.
+            return {
+                ...observation,
+                ...(observation.url === undefined && continuedRef.url ? { url: continuedRef.url } : {}),
+                provenance: { ...continuedRef.provenance },
+            };
+        });
+        refStore.record(sessionId, routeFp, refRecords);
+        return result;
     });
-    refStore.record(sessionId, routeFp, refRecords);
-    return result;
 }
-function createAlphaTool(ctx, state, getConfig, capabilityStore, refStore) {
+function createAlphaTool(ctx, state, getConfig, capabilityStore, refStore, advertisedRecord) {
     return {
         name: ALPHA_TOOL,
         description: "Stateful Codex/Alpha web command tool. Use it for search/open/find/click/PDF screenshot and the structured image/finance/weather/sports/time actions. Use DSH web_search for ordinary search, and websearch_gpt_advanced only for Hosted Search controls.",
-        parameters: ALPHA_SEARCH_PARAMETERS,
+        parameters: advertisedRecord
+            ? alphaSearchParametersFor(advertisedRecord)
+            : ALPHA_SEARCH_PARAMETERS,
         output: {
             schema: ALPHA_SEARCH_OUTPUT,
             render: (_args, value) => renderAlphaSearchResult(value),
@@ -474,7 +504,7 @@ function syncAlphaToolForAgent(ctx, agent, state, getConfig, capabilityStore, re
         // Alpha is route-bound; global registration would advertise a static record to other routes.
         registrations.set(agent, {
             fingerprint: capability.fingerprint,
-            dispose: scopedTools.register(createAlphaTool(ctx, state, getConfig, capabilityStore, refStore)),
+            dispose: scopedTools.register(createAlphaTool(ctx, state, getConfig, capabilityStore, refStore, capability.record)),
         });
         return true;
     }
@@ -522,8 +552,15 @@ 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: options.system,
+        systemPrompt,
         includeSystemPrompt: true,
     }));
     const ephemeralPreludeItemCount = prelude.input.length;
@@ -544,7 +581,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 messages ?? []) {
+    for (const message of surfaceMessages ?? []) {
         assertSupportedCheckpointMessage(message);
         const state = session
             ? checkpointStateForMessage(session, message)
@@ -600,7 +637,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, system: options.system, tools: options.tools });
+        const prepared = await serializeNativeAware(history, route, routeConfig, ctx, { signal: options.signal, 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);
@@ -715,56 +752,68 @@ function patchCompactionPressureService(compactionValue, state, getConfig, ctx,
     if (!candidate)
         return false;
     const mutex = new ServiceMutex();
+    const policyScope = new InvocationPolicyScope();
     const lifecycle = new AbortController();
-    return installCompactionPatch(records, candidate, mutex, lifecycle, async (agent, trigger, signal, callOriginal) => {
+    return installCompactionPatch(records, candidate, mutex, policyScope, lifecycle, async (agent, trigger, signal, callOriginal) => {
         const activeSignal = combinedAbortSignal(signal, lifecycle.signal);
-        return mutex.run(activeSignal, async () => {
-            if (trigger !== "pressure" || !state.enabled)
-                return callOriginal(activeSignal);
-            const config = getConfig();
-            const target = routedTargetForAgent(agent);
-            if (!target || !resolveResponsesRouteConfig(ctx, target, config))
-                return callOriginal(activeSignal);
-            const session = sessionFromAgent(agent);
-            const tokenMeter = resolveScopedService(agent, "tokenMeter") ??
-                resolveContextService(ctx, "tokenMeter");
-            if (!session || tokenMeter === undefined)
-                return callOriginal(activeSignal);
-            let contextWindow;
-            try {
-                contextWindow = (await ctx.llm.resolveModelInfo(target.provider, target.model, activeSignal)).context?.contextWindow;
-            }
-            catch {
-                return callOriginal(activeSignal);
-            }
-            const totalTokens = tokenMeterTotal(tokenMeter, session);
-            if (contextWindow === undefined ||
-                contextWindow <= 0 ||
-                totalTokens === undefined)
-                return callOriginal(activeSignal);
-            const auto = AUTO_COMPACTION_THRESHOLD_PERCENT;
-            const emergency = EMERGENCY_PRUNE_THRESHOLD_PERCENT;
-            const pressure = compactionPressureBand(totalTokens, contextWindow, {
-                auto,
-                emergency,
-            });
-            if (pressure.band === "below")
-                return null;
-            const prunerState = toolResultPrunerState(resolveAgentService(ctx, agent, "toolResultPruner"));
-            const configState = compactionConfigState(compactionValue);
-            const nativeFirst = pressure.band === "native";
-            const prunerPatch = nativeFirst
-                ? patchToolResultPruner(prunerState, () => ({ pruned: [], charsRemoved: 0 }))
-                : undefined;
-            const configPatch = patchCompactionConfig(configState, (originalConfig) => adjustedCompactionConfig(originalConfig, target, auto / 100));
-            ctx.logger?.info?.(`[lcx-codex] auto pressure ${pressure.ratioPercent.toFixed(1)}%: ${nativeFirst ? "Native V2 first" : "emergency DSH prune allowed"} (native ${auto}%, emergency ${emergency}%)`);
-            try {
-                return await callOriginal(activeSignal);
-            }
-            finally {
-                restoreCompactionConfig(configPatch);
-                restoreToolResultPruner(prunerPatch);
-            }
+        const configScoped = policyScope.ensure(compactionConfigState(candidate.compaction).service, "config");
+        const prunerState = toolResultPrunerState(resolveAgentService(ctx, agent, "toolResultPruner") ??
+            resolveScopedService(agent, "toolResultPruner") ??
+            resolveContextService(ctx, "toolResultPruner"));
+        const prunerScoped = !prunerState.pruner ||
+            (typeof prunerState.original === "function" &&
+                policyScope.ensure(prunerState.pruner, "pruneSession"));
+        const accessMode = configScoped && prunerScoped ? "shared" : "exclusive";
+        return policyScope.run(activeSignal, accessMode, async () => {
+            const invoke = async () => {
+                if (trigger !== "pressure" || !state.enabled)
+                    return callOriginal(activeSignal);
+                const config = getConfig();
+                const target = routedTargetForAgent(agent);
+                if (!target || !resolveResponsesRouteConfig(ctx, target, config))
+                    return callOriginal(activeSignal);
+                const session = sessionFromAgent(agent);
+                const tokenMeter = resolveScopedService(agent, "tokenMeter") ??
+                    resolveContextService(ctx, "tokenMeter");
+                if (!session || tokenMeter === undefined)
+                    return callOriginal(activeSignal);
+                let contextWindow;
+                try {
+                    contextWindow = (await ctx.llm.resolveModelInfo(target.provider, target.model, activeSignal)).context?.contextWindow;
+                }
+                catch {
+                    return callOriginal(activeSignal);
+                }
+                const totalTokens = tokenMeterTotal(tokenMeter, session);
+                if (contextWindow === undefined ||
+                    contextWindow <= 0 ||
+                    totalTokens === undefined)
+                    return callOriginal(activeSignal);
+                const auto = AUTO_COMPACTION_THRESHOLD_PERCENT;
+                const emergency = EMERGENCY_PRUNE_THRESHOLD_PERCENT;
+                const pressure = compactionPressureBand(totalTokens, contextWindow, {
+                    auto,
+                    emergency,
+                });
+                if (pressure.band === "below")
+                    return null;
+                const nativeFirst = pressure.band === "native";
+                const prunerPatch = nativeFirst
+                    ? patchToolResultPruner(prunerState, () => ({ pruned: [], charsRemoved: 0 }))
+                    : undefined;
+                const configPatch = patchCompactionConfig(compactionConfigState(candidate.compaction), (originalConfig) => adjustedCompactionConfig(originalConfig, target, auto / 100));
+                ctx.logger?.info?.(`[lcx-codex] auto pressure ${pressure.ratioPercent.toFixed(1)}%: ${nativeFirst ? "Native V2 first" : "emergency DSH prune allowed"} (native ${auto}%, emergency ${emergency}%)`);
+                try {
+                    return await callOriginal(activeSignal);
+                }
+                finally {
+                    restoreCompactionConfig(configPatch);
+                    restoreToolResultPruner(prunerPatch);
+                }
+            };
+            return accessMode === "shared"
+                ? invoke()
+                : mutex.run(activeSignal, invoke);
         });
     });
 }
@@ -778,8 +827,13 @@ async function restoreCompactionPressure(records) {
         if (!record.lifecycle.signal.aborted)
             record.lifecycle.abort(reason);
     }
-    await Promise.allSettled(entries.map((record) => record.mutex.close(reason)));
+    await Promise.allSettled(entries.flatMap((record) => [
+        record.policyScope.close(reason),
+        record.mutex.close(reason),
+    ]));
     restoreCompactionPatches(records, entries);
+    for (const record of entries)
+        record.policyScope.restore();
 }
 function messagesContainNativeCheckpoint(messages, session) {
     return session !== undefined && messages.some((message) => checkpointStateForMessage(session, message));
@@ -792,7 +846,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, system: options.system, tools: options.tools });
+        const prepared = await serializeNativeAware(options.messages, route, routeConfig, ctx, { signal: options.signal, tools: options.tools });
         const cacheSessionId = promptCacheSessionId(route, routeConfig, ctx);
         const headers = await authenticatedHeaders(ctx, routeConfig, cacheSessionId, cacheSessionId === undefined ? null : route.sessionId);
         const body = buildResponsesBody({
@@ -837,9 +891,9 @@ async function* managedGrokNativeSearchStream(options, routeConfig, nativeSearch
         if (options.stop !== undefined)
             throw Object.assign(new Error("LCX Responses does not support GenerateOptions.stop"), { code: "LCX_RESPONSES_UNSUPPORTED_OPTION" });
         const visibleTools = grokVisibleFunctionTools(options.tools, nativeSearch);
+        const declaredToolNames = new Set(visibleTools?.map((tool) => tool.name) ?? []);
         const prepared = await serializeNativeAware(options.messages, route, routeConfig, ctx, {
             signal: options.signal,
-            system: options.system,
             tools: visibleTools,
             grokNativeReplayRoute: nativeReplayRoute,
         });
@@ -889,6 +943,8 @@ async function* managedGrokNativeSearchStream(options, routeConfig, nativeSearch
             maxAttempts: 1,
             maxResponseBytes: routeConfig.maxResponseBytes,
             serverToolTypes: GROK_NATIVE_SERVER_TOOL_TYPES,
+            isServerToolItem: (item) => isGrokNativeServerToolItem(item, nativeSearch, declaredToolNames),
+            declaredToolNames,
             nativeReplayRoute,
             onServerToolUsage(usage) {
                 ctx.logger?.info?.(`[lcx-codex] Grok native search used ${usage.total} server-side tool call(s) (web=${usage.webSearchCalls}, x=${usage.xSearchCalls})`);
@@ -906,6 +962,7 @@ async function* unavailableManagedRouteStream(options) {
     yield managedFailureChunk(Object.assign(new Error("LCX is enabled but the selected DSH route cannot be resolved as an authenticated OpenAI Responses wire route"), { code: "LCX_RESPONSES_ROUTE_UNAVAILABLE" }), options.signal);
 }
 function installInjected(ctx, configInput = {}) {
+    installSearchUsage(ctx);
     const baseConfig = normalizeConfig(configInput);
     let runtimeConfig = baseConfig;
     const state = {
@@ -952,6 +1009,7 @@ function installInjected(ctx, configInput = {}) {
         alphaSearch: false,
         grokNativeWebSearch: false,
         grokNativeXSearch: false,
+        searchMediaPreview: false,
     };
     let source = () => settingsEntry;
     ctx.settings.installSection(ctx, SETTINGS_NS, SettingsSchema, settingsEntry, {