dsh-lcx-codex 0.4.3 → 0.5.0-pre.1

package/lib/transport.js

@@ -1,3 +1,4 @@
+import { abortError } from "./abort-error.js";
 const DEFAULT_TIMEOUT_MS = 300_000;
 const DEFAULT_MAX_BYTES = 8 * 1024 * 1024;
 const MAX_ERROR_BYTES = 512 * 1024;
@@ -6,8 +7,7 @@ function errorFacts(value) {
 }
 export function abortIfNeeded(signal) {
     if (signal?.aborted)
-        throw (signal.reason ??
-            Object.assign(new Error("request aborted"), { code: "LCX_ABORTED" }));
+        throw abortError(signal);
 }
 function makeError(message, code, extra = {}) {
     const error = new Error(message);
@@ -63,11 +63,11 @@ async function sleep(ms, signal) {
         return;
     await new Promise((resolve, reject) => {
         if (signal?.aborted)
-            return reject(signal.reason);
+            return reject(abortError(signal));
         const onAbort = () => {
             clearTimeout(timer);
             signal?.removeEventListener("abort", onAbort);
-            reject(signal?.reason);
+            reject(abortError(signal));
         };
         const timer = setTimeout(() => {
             signal?.removeEventListener("abort", onAbort);
@@ -161,7 +161,7 @@ export async function fetchJsonWithRetry(url, body, headers = {}, signal, timeou
         }
         catch (error) {
             if (signal?.aborted)
-                throw signal.reason ?? error;
+                throw abortError(signal, error);
             const details = errorFacts(error);
             const retryable = details.retryable === true ||
                 details.code === "LCX_HTTP_RETRYABLE" ||
@@ -231,7 +231,7 @@ export async function fetchSseWithRetry(url, body, headers = {}, signal, timeout
         }
         catch (error) {
             if (signal?.aborted)
-                throw signal.reason ?? error;
+                throw abortError(signal, error);
             const details = errorFacts(error);
             const retryable = details.retryable === true ||
                 details.code === "LCX_HTTP_RETRYABLE" ||

package/lib/types/client/search-media.d.ts

@@ -12,5 +12,14 @@ export type StructuredMediaTool = "web_search" | "websearch_gpt_advanced";
 /** Narrow LCX-owned tool-private media metadata without reading model-visible output. */
 export declare function structuredSearchMedia(meta: unknown, expectedTool: StructuredMediaTool): readonly SearchMediaItem[];
 export declare function mergeSearchMedia(structured: readonly SearchMediaItem[], fallback: readonly SearchMediaItem[]): readonly SearchMediaItem[];
-/** Extract bounded remote media linked by visible assistant prose. */
-export declare function extractSearchMedia(text: string): readonly SearchMediaItem[];
+/**
+ * Extract bounded direct media links from visible assistant prose, in text order.
+ *
+ * Ownership (Issue #102): Markdown images are rendered by DSH itself, so their
+ * destinations are never returned, and a bare link to an image DSH already renders
+ * natively in the same text is skipped. Plain direct image links and direct video
+ * files are LCX's; everything else (pages, video sites) stays an ordinary link.
+ */
+export declare function extractDirectMediaLinks(text: string): readonly SearchMediaItem[];
+/** Direct video files only (see `extractDirectMediaLinks`). */
+export declare function extractDirectVideoLinks(text: string): readonly SearchMediaItem[];

package/lib/types/index.d.ts

@@ -1,5 +1,5 @@
 import z from "@deepseek-ai/schemastery";
-import type { Context } from "@deepseek-ai/cordis";
+import type { Context, Volatile } from "@deepseek-ai/cordis";
 import "@deepseek-ai/dsh-agent";
 import "@deepseek-ai/dsh-tools";
 import "@deepseek-ai/dsh-web";
@@ -26,56 +26,84 @@ type ConfigInput = {
     assistantRetentionTokenReserve?: unknown;
     assistantRetentionPerMessageTokenCap?: unknown;
 };
+type LiveSettingsConfig = {
+    enabled: Volatile<boolean>;
+    webSearch: Volatile<boolean>;
+    advancedHostedSearch: Volatile<boolean>;
+    alphaSearch: Volatile<boolean>;
+    grokNativeWebSearch: Volatile<boolean>;
+    grokNativeXSearch: Volatile<boolean>;
+    searchMediaPreview: Volatile<boolean>;
+};
 type HostContext = Context;
-export declare const Config: z<Schemastery.ObjectS<{
-    supportsLongCacheRetention: z<boolean, boolean>;
-    supportsExplicitPromptCacheMode: z<boolean, boolean>;
-    alphaCapabilityPath: z<string, string>;
-    alphaRefPath: z<string, string>;
-    alphaProfile: z<string, string>;
-    alphaGroup: z<string, string>;
-    alphaMaxOutputTokens: z<number, number>;
-    webSearchProvider: z<string, string>;
-    webMaxResults: z<number, number>;
-    timeoutMs: z<number, number>;
-    maxResponseBytes: z<number, number>;
-    maxAttempts: z<number, number>;
-    maxRequestImageBytes: z<number, number>;
-    requestImagePixelBudget: z<number, number>;
-    requestImageMaxBytes: z<number, number>;
-    portableReplayMaxChars: z<number, number>;
-    nativeRetentionTokenBudget: z<number, number>;
-    assistantRetentionTokenReserve: z<number, number>;
-    assistantRetentionPerMessageTokenCap: z<number, number>;
-}>, Schemastery.ObjectT<{
-    supportsLongCacheRetention: z<boolean, boolean>;
-    supportsExplicitPromptCacheMode: z<boolean, boolean>;
-    alphaCapabilityPath: z<string, string>;
-    alphaRefPath: z<string, string>;
-    alphaProfile: z<string, string>;
-    alphaGroup: z<string, string>;
-    alphaMaxOutputTokens: z<number, number>;
-    webSearchProvider: z<string, string>;
-    webMaxResults: z<number, number>;
-    timeoutMs: z<number, number>;
-    maxResponseBytes: z<number, number>;
-    maxAttempts: z<number, number>;
-    maxRequestImageBytes: z<number, number>;
-    requestImagePixelBudget: z<number, number>;
-    requestImageMaxBytes: z<number, number>;
-    portableReplayMaxChars: z<number, number>;
-    nativeRetentionTokenBudget: z<number, number>;
-    assistantRetentionTokenReserve: z<number, number>;
-    assistantRetentionPerMessageTokenCap: z<number, number>;
-}>>;
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    enabled: z<boolean, boolean, "volatile-defined">;
+    webSearch: z<boolean, boolean, "volatile-defined">;
+    advancedHostedSearch: z<boolean, boolean, "volatile-defined">;
+    alphaSearch: z<boolean, boolean, "volatile-defined">;
+    grokNativeWebSearch: z<boolean, boolean, "volatile-defined">;
+    grokNativeXSearch: z<boolean, boolean, "volatile-defined">;
+    searchMediaPreview: z<boolean, boolean, "volatile-defined">;
+    supportsLongCacheRetention: z<boolean, boolean, "defined">;
+    supportsExplicitPromptCacheMode: z<boolean, boolean, "defined">;
+    alphaCapabilityPath: z<string, string, "defined">;
+    alphaRefPath: z<string, string, "defined">;
+    alphaProfile: z<string, string, "defined">;
+    alphaGroup: z<string, string, "defined">;
+    alphaMaxOutputTokens: z<number, number, "defined">;
+    webSearchProvider: z<string, string, "defined">;
+    webMaxResults: z<number, number, "defined">;
+    timeoutMs: z<number, number, "defined">;
+    maxResponseBytes: z<number, number, "defined">;
+    maxAttempts: z<number, number, "defined">;
+    maxRequestImageBytes: z<number, number, "defined">;
+    requestImagePixelBudget: z<number, number, "defined">;
+    requestImageMaxBytes: z<number, number, "defined">;
+    portableReplayMaxChars: z<number, number, "defined">;
+    nativeRetentionTokenBudget: z<number, number, "defined">;
+    assistantRetentionTokenReserve: z<number, number, "defined">;
+    assistantRetentionPerMessageTokenCap: z<number, number, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    enabled: z<boolean, boolean, "volatile-defined">;
+    webSearch: z<boolean, boolean, "volatile-defined">;
+    advancedHostedSearch: z<boolean, boolean, "volatile-defined">;
+    alphaSearch: z<boolean, boolean, "volatile-defined">;
+    grokNativeWebSearch: z<boolean, boolean, "volatile-defined">;
+    grokNativeXSearch: z<boolean, boolean, "volatile-defined">;
+    searchMediaPreview: z<boolean, boolean, "volatile-defined">;
+    supportsLongCacheRetention: z<boolean, boolean, "defined">;
+    supportsExplicitPromptCacheMode: z<boolean, boolean, "defined">;
+    alphaCapabilityPath: z<string, string, "defined">;
+    alphaRefPath: z<string, string, "defined">;
+    alphaProfile: z<string, string, "defined">;
+    alphaGroup: z<string, string, "defined">;
+    alphaMaxOutputTokens: z<number, number, "defined">;
+    webSearchProvider: z<string, string, "defined">;
+    webMaxResults: z<number, number, "defined">;
+    timeoutMs: z<number, number, "defined">;
+    maxResponseBytes: z<number, number, "defined">;
+    maxAttempts: z<number, number, "defined">;
+    maxRequestImageBytes: z<number, number, "defined">;
+    requestImagePixelBudget: z<number, number, "defined">;
+    requestImageMaxBytes: z<number, number, "defined">;
+    portableReplayMaxChars: z<number, number, "defined">;
+    nativeRetentionTokenBudget: z<number, number, "defined">;
+    assistantRetentionTokenReserve: z<number, number, "defined">;
+    assistantRetentionPerMessageTokenCap: z<number, number, "defined">;
+}>>, "plain">;
 export declare function compactionPressureBand(totalTokens: number, contextWindow: number, policy: {
     auto: number;
     emergency: number;
+    outputReserve: number;
+    headroomTokens: number;
 }): {
+    pressureBudget: number;
+    nativeThreshold: number;
+    emergencyThreshold: number;
     ratioPercent: number;
     band: string;
 };
-export declare function apply(ctx: HostContext, configInput?: ConfigInput): void;
+export declare function apply(ctx: HostContext, configInput: ConfigInput & LiveSettingsConfig): void;
 export declare namespace apply {
     export { inject };
     export { Config };

package/lib/web-search-alpha-history.js

@@ -0,0 +1,62 @@
+const ASSISTANT_CONTEXT_TOKEN_LIMIT = 1_000;
+const APPROX_BYTES_PER_TOKEN = 4;
+function textBlocks(message) {
+    const type = message.role === "user" ? "input_text" : "output_text";
+    return message.content.flatMap((block) => block.type === "text" ? [{ type, text: block.text }] : []);
+}
+function approxTokens(text) {
+    return Math.ceil(Buffer.byteLength(text, "utf8") / APPROX_BYTES_PER_TOKEN);
+}
+// Codex's UTF-8 middle truncation for one over-budget assistant text block.
+function truncateAssistantText(text, tokens) {
+    const bytes = Buffer.byteLength(text, "utf8");
+    const budget = tokens * APPROX_BYTES_PER_TOKEN;
+    if (bytes <= budget)
+        return text;
+    const leftBudget = Math.floor(budget / 2);
+    const rightBudget = budget - leftBudget;
+    let prefix = "";
+    let suffix = "";
+    let consumed = 0;
+    for (const char of text) {
+        const next = consumed + Buffer.byteLength(char, "utf8");
+        if (next <= leftBudget)
+            prefix += char;
+        if (consumed >= bytes - rightBudget)
+            suffix += char;
+        consumed = next;
+    }
+    return `${prefix}…${Math.ceil((bytes - budget) / APPROX_BYTES_PER_TOKEN)} tokens truncated…${suffix}`;
+}
+/** Codex recent_input on the canonical DSH message surface. */
+export function recentAlphaInput(messages) {
+    const users = messages.flatMap((message, index) => message.role === "user" && message.source.kind === "user" && textBlocks(message).length ? [index] : []);
+    if (!users.length)
+        return undefined;
+    const start = users.at(-2) ?? users.at(-1);
+    const end = users.at(-1);
+    let assistantTokens = ASSISTANT_CONTEXT_TOKEN_LIMIT;
+    const items = [];
+    for (let index = start; index <= end; index++) {
+        const message = messages[index];
+        if (message.role === "user" && message.source.kind === "user") {
+            const content = textBlocks(message);
+            if (content.length)
+                items.push({ type: "message", role: "user", content });
+        }
+        else if (message.role === "assistant" && assistantTokens > 0) {
+            const content = [];
+            for (const block of textBlocks(message)) {
+                if (assistantTokens === 0)
+                    break;
+                const cost = approxTokens(block.text);
+                content.push({ type: "output_text", text: cost <= assistantTokens
+                        ? block.text : truncateAssistantText(block.text, assistantTokens) });
+                assistantTokens = Math.max(0, assistantTokens - cost);
+            }
+            if (content.length)
+                items.push({ type: "message", role: "assistant", content });
+        }
+    }
+    return items.length ? items : undefined;
+}

package/lib/web-search-alpha.js

@@ -31,12 +31,16 @@ const RESPONSE_LENGTHS = ["short", "medium", "long"];
 export const ALPHA_SEARCH_PARAMETERS = {
     type: "object",
     properties: {
-        action: { type: "string", enum: ALPHA_ACTIONS },
+        action: {
+            type: "string",
+            enum: ALPHA_ACTIONS,
+            description: "Choose one action. search_query/image_query use query, domains, recency; open uses refId, lineNumber; find uses refId, pattern; click uses refId, linkId; screenshot uses refId, pageNumber; finance uses ticker, assetType, market; weather uses location, start, duration; sports uses fn, league, team, opponent, dateFrom, dateTo, numberOfGames, locale; time uses utcOffset. responseLength applies to every action. Other declared fields are ignored.",
+        },
         query: { type: "string" },
         domains: { type: "array", items: { type: "string" } },
         recency: { type: "integer" },
-        refId: { type: "string" },
-        lineNumber: { type: "integer" },
+        refId: { type: "string", description: "Copy only the reference after opaqueRef=, including any lcx-alpha- handle. Do not include the opaqueRef= label. A public URL is allowed for open/find." },
+        lineNumber: { type: "integer", description: "Omit unless opening a specific line. Zero requests line 0." },
         linkId: { type: "integer" },
         pattern: { type: "string" },
         pageNumber: { type: "integer" },
@@ -105,7 +109,9 @@ export const ALPHA_SEARCH_OUTPUT = {
 export const ALPHA_SCHEMA_FINGERPRINT = createHash("sha256")
     .update(JSON.stringify(ALPHA_SEARCH_PARAMETERS))
     .digest("hex");
-export const ALPHA_PROBE_VERSION = 12;
+export const ALPHA_PROBE_VERSION = 15;
+export const ALPHA_PROBE_QUERY = "Python official documentation docs.python.org/3/";
+export const ALPHA_PROBE_MAX_OPEN_CANDIDATES = 3;
 function failure(message, code = "WEB_INVALID_REQUEST") {
     return Object.assign(new Error(message), { code });
 }
@@ -140,7 +146,7 @@ function date(value, field) {
     return normalized;
 }
 function normalizeDomains(value) {
-    if (!Array.isArray(value) || !value.length || value.length > 100)
+    if (!Array.isArray(value) || value.length > 100)
         throw failure("websearch_alpha.domains is invalid");
     return value.map((item) => {
         const d = text(item, "domains", 253).toLowerCase();
@@ -149,35 +155,16 @@ function normalizeDomains(value) {
         return d;
     });
 }
-const FIELDS = {
-    search_query: ["query", "domains", "recency"],
-    image_query: ["query", "domains", "recency"],
-    open: ["refId", "lineNumber"],
-    find: ["refId", "pattern"],
-    click: ["refId", "linkId"],
-    screenshot: ["refId", "pageNumber"],
-    finance: ["ticker", "assetType", "market"],
-    weather: ["location", "start", "duration"],
-    sports: [
-        "fn",
-        "league",
-        "team",
-        "opponent",
-        "dateFrom",
-        "dateTo",
-        "numberOfGames",
-        "locale",
-    ],
-    time: ["utcOffset"],
-};
 function isAlphaAction(value) {
     return typeof value === "string" && ALPHA_ACTIONS.includes(value);
 }
 export function normalizeAlphaSearchArgs(args) {
     if (!isObject(args) || !isAlphaAction(args.action))
         throw failure("websearch_alpha.action is invalid");
-    const allowed = new Set(["action", "responseLength", ...FIELDS[args.action]]);
-    if (Object.keys(args).some((k) => !allowed.has(k)))
+    // The advertised flat schema permits every declared field for every action.
+    // Ignore fields owned by another action; never forward them to Alpha.
+    const declared = new Set(Object.keys(ALPHA_SEARCH_PARAMETERS.properties));
+    if (Object.keys(args).some((k) => !declared.has(k)))
         throw failure(`websearch_alpha.${args.action} received an unrelated field`);
     const result = { action: args.action };
     if (args.responseLength !== undefined) {
@@ -190,7 +177,7 @@ export function normalizeAlphaSearchArgs(args) {
         case "search_query":
         case "image_query":
             result.query = text(args.query, "query", 16000);
-            if (args.domains !== undefined)
+            if (args.domains !== undefined && (!Array.isArray(args.domains) || args.domains.length > 0))
                 result.domains = normalizeDomains(args.domains);
             if (args.recency !== undefined)
                 result.recency = integer(args.recency, "recency", 0, 3650);
@@ -326,30 +313,13 @@ export function alphaActionCommand(args) {
         ...(args.responseLength ? { response_length: args.responseLength } : {}),
     };
 }
-function actionInput(args) {
-    return String(args.query ??
-        (args.refId
-            ? `${args.action}: ${args.refId}`
-            : args.ticker
-                ? `${args.action}: ${args.ticker}`
-                : args.location
-                    ? `${args.action}: ${args.location}`
-                    : args.utcOffset
-                        ? `${args.action}: ${args.utcOffset}`
-                        : `${args.action}: ${args.league ?? ""}`.trim()));
-}
-export function buildAlphaSearchBody(args, model, sessionId, externalWebAccess = true, maxOutputTokens = 2500) {
+export function buildAlphaSearchBody(args, model, sessionId, externalWebAccess = true, maxOutputTokens = 2500, input) {
     if (typeof sessionId !== "string" || !sessionId)
         throw failure("websearch_alpha requires a DSH session", "LCX_ALPHA_SESSION_REQUIRED");
     return {
         id: sessionId,
         model,
-        input: [
-            {
-                role: "user",
-                content: [{ type: "input_text", text: actionInput(args) }],
-            },
-        ],
+        ...(input?.length ? { input } : {}),
         commands: alphaActionCommand(args),
         settings: {
             allowed_callers: ["direct"],
@@ -684,8 +654,26 @@ const ALPHA_SEMANTIC_FAILURE = /^\s*(?:reference(?: id)?\s+(?:is\s+)?(?:invalid|
 const ALPHA_COMMAND_ERROR_ENVELOPE = /^\s*Internal Error\s*\([^\r\n)]*\)\s*(?:\r?\n[ \t]*)+(?:\uE200cite\uE202[^\uE201\r\n]+\uE201[ \t]*(?:\[wordlim:\s*\d+\][ \t]*)?)?Unable to resolve (open|find|click|screenshot) call\s*:/iu;
 const ALPHA_FETCH_FAILURE_ENVELOPE = /^\s*Internal Error\s*\([^\r\n)]*\)\s*(?:\r?\n[ \t]*)+(?:\uE200cite\uE202[^\uE201\r\n]+\uE201[ \t]*(?:\[wordlim:\s*\d+\][ \t]*)?)?Source:\s*(open|find|click|screenshot)\s*\([^\r\n]*\)\s*;\s*Total lines:\s*\d+\s*(?:\r?\n)L0:[ \t]*Failed to fetch \S+:[ \t]*\(\d{3}\)/iu;
 const ALPHA_REFERENCE_ERROR_ENVELOPE = /^\s*(?:\*\*Result:\*\*[ \t]*)?Unable to (?:execute[ \t]+)?`?(open|find|click|screenshot)`?(?=[\s:])([^\r\n]*)/iu;
+const ALPHA_FIND_SOURCE_ERROR_ENVELOPE = /^\s*The (?:request|search) failed: `[^`\r\n]+` is not a valid or available source reference, so\b/iu;
+// Recorded HTTP-200 empty error view: no page body, but a newly produced view citation.
+// Anchor the entire envelope so error examples inside fetched pages never match.
+const ALPHA_EMPTY_FETCH_ERROR_VIEW = /^\s*(?:Internal[ \t]+)?Error[ \t]*\([ \t]*\)[ \t]*\r?\n[ \t]*\uE200cite\uE202turn\d+view\d+\uE201[ \t]*(?:\[wordlim:\s*\d+\][ \t]*)?\s*$/u;
+// A notice-only open view: every body line belongs to the fetch failure,
+// never arbitrary page prose or numbered page content.
+const ALPHA_FETCH_NOTICE_VIEW = /^\s*(?:(?:Internal[ \t]+)?Error[ \t]*\([ \t]*\)[ \t]*\r?\n[ \t]*)?(?:\uE200cite\uE202turn\d+view\d+\uE201[ \t]*(?:\[wordlim:\s*\d+\][ \t]*)?\r?\n[ \t]*)?Failed to fetch[ \t]+https?:\/\/\S+[^\r\n]*?(?:\r?\n[ \t]*|[ \t]+)Error fetching[ \t]+https?:\/\/\S+[^\r\n]*\s*$/u;
+function alphaPageFetchFailed(output, action) {
+    if (action !== "open" && action !== "click")
+        return false;
+    const text = String(output ?? "");
+    const explicit = text.match(ALPHA_FETCH_FAILURE_ENVELOPE);
+    return ALPHA_EMPTY_FETCH_ERROR_VIEW.test(text) ||
+        (action === "open" && ALPHA_FETCH_NOTICE_VIEW.test(text)) ||
+        explicit?.[1].toLowerCase() === action;
+}
 function alphaCommandErrorEnvelope(output, action) {
     const text = String(output ?? "");
+    if (action === "find" && ALPHA_FIND_SOURCE_ERROR_ENVELOPE.test(text))
+        return true;
     const command = text.match(ALPHA_COMMAND_ERROR_ENVELOPE);
     if (command && command[1].toLowerCase() === action)
         return true;
@@ -705,6 +693,8 @@ export function parseAlphaSearchResponse(response, options) {
         (response.results !== undefined && !Array.isArray(response.results)))
         throw failure("LCX Alpha Web Search returned an invalid response", "LCX_ALPHA_INVALID_RESPONSE");
     const action = typeof options.action === "string" ? options.action : undefined;
+    if (alphaPageFetchFailed(response.output, action))
+        throw failure("LCX Alpha Web Search: the page could not be fetched; try another result", "LCX_ALPHA_PAGE_FETCH_FAILED");
     if (ACTION_ERROR.test(response.output) ||
         (["open", "find", "click", "screenshot"].includes(action ?? "") &&
             (ALPHA_SEMANTIC_FAILURE.test(response.output) ||
@@ -818,6 +808,28 @@ export function renderAlphaSearchResult(value) {
     parts.push(`检索时间：${String(data.retrievedAt ?? "")}`);
     return [{ type: "text", text: parts.filter(Boolean).join("\n\n") }];
 }
+export function remapAlphaResultRefs(value, handles) {
+    const changes = Object.entries(handles).filter(([raw, handle]) => raw !== handle);
+    if (!changes.length)
+        return value;
+    const urlFields = new Set(["url", "source_url", "source_website_url", "image_url", "thumbnail_url", "href"]);
+    const replace = (input, key = "") => {
+        if (urlFields.has(key))
+            return input;
+        if (typeof input === "string") {
+            let output = input;
+            for (const [raw, handle] of changes)
+                output = output.replace(new RegExp(`(?<![\\w-])${raw.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}(?![\\w-])`, "gu"), handle);
+            return output;
+        }
+        if (Array.isArray(input))
+            return input.map((item) => replace(item));
+        if (isObject(input))
+            return Object.fromEntries(Object.entries(input).map(([field, item]) => [field, replace(item, field)]));
+        return input;
+    };
+    return replace(value);
+}
 export const ALPHA_STATEFUL_RETRY_MAX_ATTEMPTS = 1;
 const alphaSessionLocks = new Map();
 export function alphaSearchRetryOptions(maxResponseBytes) {
@@ -892,6 +904,8 @@ function alphaProbeStructuredBlock(block) {
 const ALPHA_PROBE_SEMANTIC_FAILURE = /\breference(?: id)?\s+(?:is\s+)?(?:invalid|unavailable)\b/iu;
 function alphaProbeResultHasEvidence(action, value) {
     const data = isObject(value) ? value : {};
+    if (alphaPageFetchFailed(data.content, action))
+        return false;
     if (alphaCommandErrorEnvelope(data.content, action))
         return false;
     if (ALPHA_PROBE_SEMANTIC_FAILURE.test(String(data.content ?? "")) &&
@@ -913,7 +927,7 @@ function alphaProbeResultHasEvidence(action, value) {
         return Boolean(refs || pdfRefs || structuredResults || structuredBlocks);
     return Boolean(refs || links || pdfRefs || structuredResults || structuredBlocks);
 }
-export async function probeAlphaCapabilities({ invoke, schemaFingerprint, trustedNativeProvenance = false, actionProbes = {}, clickProbeRef, screenshotProbeRef, }) {
+export async function probeAlphaCapabilities({ invoke, startChain, schemaFingerprint, trustedNativeProvenance = false, actionProbes = {}, clickProbeRef, screenshotProbeRef, }) {
     const actions = Object.fromEntries(ALPHA_ACTIONS.map((action) => [action, "unknown"]));
     const result = {
         classification: "unsupported",
@@ -923,78 +937,89 @@ export async function probeAlphaCapabilities({ invoke, schemaFingerprint, truste
         probeVersion: ALPHA_PROBE_VERSION,
         provenance: trustedNativeProvenance ? "trusted-native" : "unavailable",
     };
-    let search;
-    try {
-        search = await invoke({
-            action: "search_query",
-            query: "OpenAI official documentation",
-            responseLength: "short",
-        });
-        actions.search_query = "supported";
-    }
-    catch (error) {
-        actions.search_query = probeFailureState(error);
-        result.classification =
-            actions.search_query === "unsupported" ? "unsupported" : "unknown";
-        return result;
-    }
-    const searchSources = Array.isArray(search.sources) ? search.sources : [];
-    const searchUrl = searchSources
-        .map((source) => isObject(source) ? httpUrl(source.url) : undefined)
-        .find((value) => value !== undefined);
-    const searchRefs = Array.isArray(search.refs) ? search.refs : [];
-    const searchRef = searchRefs[0];
-    const continuationTarget = searchUrl ?? searchRef;
-    if (!continuationTarget) {
-        result.classification = "emulated-search-only";
-        actions.open = "unsupported";
-        actions.find = "unsupported";
-        actions.click = "unsupported";
-        return result;
-    }
     let opened;
-    try {
-        opened = await invoke({
-            action: "open",
-            refId: continuationTarget,
-            responseLength: "short",
-        });
-        if (!alphaProbeResultHasEvidence("open", opened)) {
+    const chainIds = new Set();
+    // Two independent chains, each bounded to search + 3 candidate opens + find:
+    // at most 10 mandatory calls, 19 with all optional checks. Only page-fetch
+    // failures allow another candidate; never retry the same ref or failed find.
+    for (let chain = 0; chain < 2; chain++) {
+        try {
+            const chainId = await startChain(chain);
+            if (typeof chainId !== "string" || !chainId || chainIds.has(chainId)) {
+                result.classification = "unknown";
+                return result;
+            }
+            chainIds.add(chainId);
+        }
+        catch {
+            result.classification = "unknown";
+            return result;
+        }
+        let search;
+        try {
+            search = await invoke({ action: "search_query", query: ALPHA_PROBE_QUERY, responseLength: "short" });
+            actions.search_query = "supported";
+        }
+        catch (error) {
+            actions.search_query = probeFailureState(error);
+            result.classification = chain === 0 && actions.search_query === "unsupported" ? "unsupported" : "unknown";
+            return result;
+        }
+        const searchRefs = Array.isArray(search.refs) ? search.refs : [];
+        const candidates = [...new Set(searchRefs.filter((ref) => typeof ref === "string" && ref && !isAlphaHttpUrl(ref)))].slice(0, ALPHA_PROBE_MAX_OPEN_CANDIDATES);
+        if (!candidates.length) {
+            result.classification = chain === 0 ? "emulated-search-only" : "unknown";
             actions.open = "unsupported";
-            result.classification = "emulated-search-only";
+            actions.find = "unsupported";
+            actions.click = "unsupported";
+            return result;
+        }
+        opened = undefined;
+        let continuationTarget;
+        for (const candidate of candidates) {
+            try {
+                const value = await invoke({ action: "open", refId: candidate, responseLength: "short" });
+                if (alphaPageFetchFailed(value.content, "open"))
+                    continue;
+                if (!alphaProbeResultHasEvidence("open", value)) {
+                    actions.open = "unsupported";
+                    result.classification = chain === 0 ? "emulated-search-only" : "unknown";
+                    return result;
+                }
+                opened = value;
+                continuationTarget = candidate;
+                actions.open = "supported";
+                break;
+            }
+            catch (error) {
+                if (isObject(error) && error.code === "LCX_ALPHA_PAGE_FETCH_FAILED")
+                    continue;
+                actions.open = probeFailureState(error);
+                result.classification = chain === 0 && actions.open === "unsupported" ? "emulated-search-only" : "unknown";
+                return result;
+            }
+        }
+        if (!opened) {
+            actions.open = "unknown";
+            result.classification = "unknown";
+            return result;
+        }
+        const openedRefs = Array.isArray(opened.refs) ? opened.refs : [];
+        const findTarget = openedRefs.find((ref) => typeof ref === "string" && !isAlphaHttpUrl(ref)) ?? continuationTarget;
+        try {
+            const found = await invoke({ action: "find", refId: findTarget, pattern: "Python", responseLength: "short" });
+            actions.find = alphaProbeResultHasEvidence("find", found) ? "supported" : "unsupported";
+        }
+        catch (error) {
+            actions.find = probeFailureState(error);
+        }
+        if (actions.find !== "supported") {
+            result.classification = "unknown";
             return result;
         }
-        actions.open = "supported";
-    }
-    catch (error) {
-        actions.open = probeFailureState(error);
-        result.classification =
-            actions.open === "unsupported" ? "emulated-search-only" : "unknown";
-        return result;
-    }
-    const openedSources = opened && Array.isArray(opened.sources) ? opened.sources : [];
-    const openedUrl = openedSources
-        .map((source) => isObject(source) ? httpUrl(source.url) : undefined)
-        .find((value) => value !== undefined);
-    const openedRefs = opened && Array.isArray(opened.refs) ? opened.refs : [];
-    const findTarget = searchUrl ?? openedUrl ?? openedRefs[0] ?? continuationTarget;
-    try {
-        const found = await invoke({
-            action: "find",
-            refId: findTarget,
-            pattern: "OpenAI",
-            responseLength: "short",
-        });
-        actions.find = alphaProbeResultHasEvidence("find", found)
-            ? "supported"
-            : "unsupported";
-    }
-    catch (error) {
-        actions.find = probeFailureState(error);
     }
-    let clickPage = opened, clickProbeUsed = false;
+    let clickPage = opened;
     if (!(clickPage && Array.isArray(clickPage.links) && clickPage.links.length > 0) && clickProbeRef) {
-        clickProbeUsed = true;
         try {
             clickPage = await invoke({
                 action: "open",
@@ -1026,15 +1051,7 @@ export async function probeAlphaCapabilities({ invoke, schemaFingerprint, truste
             actions.click = probeFailureState(error);
         }
     }
-    if (actions.find === "supported" ||
-        (actions.click === "supported" && !clickProbeUsed))
-        result.classification = trustedNativeProvenance
-            ? "native"
-            : "command-capable";
-    else if (actions.find === "unsupported" && actions.click === "unsupported")
-        result.classification = "emulated-search-only";
-    else
-        result.classification = "unknown";
+    result.classification = trustedNativeProvenance ? "native" : "command-capable";
     if (screenshotProbeRef) {
         try {
             const pdf = await invoke({

package/lib/web-search-capability.js

@@ -67,7 +67,7 @@ export function alphaSearchParametersFor(record) {
         ...ALPHA_SEARCH_PARAMETERS,
         properties: {
             ...ALPHA_SEARCH_PARAMETERS.properties,
-            action: { type: "string", enum: alphaAdvertisedActions(record) },
+            action: { ...ALPHA_SEARCH_PARAMETERS.properties.action, enum: alphaAdvertisedActions(record) },
         },
     };
 }