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

package/lib/transport.js

@@ -22,6 +22,16 @@ function retryableStatus(status) {
         status === 429 ||
         (status >= 500 && status <= 599));
 }
+// Retain only an allowlisted class, never upstream messages or account balances.
+function isQuotaError(text) {
+    try {
+        const code = JSON.parse(text)?.error?.code;
+        return code === "insufficient_user_quota" || code === "insufficient_quota";
+    }
+    catch {
+        return false;
+    }
+}
 function retryAfterFromHeaders(headers) {
     const rawMillis = headers?.get?.("retry-after-ms");
     const millis = Number(rawMillis);
@@ -54,11 +64,16 @@ async function sleep(ms, signal) {
     await new Promise((resolve, reject) => {
         if (signal?.aborted)
             return reject(signal.reason);
-        const timer = setTimeout(resolve, ms);
-        signal?.addEventListener("abort", () => {
+        const onAbort = () => {
             clearTimeout(timer);
-            reject(signal.reason);
-        }, { once: true });
+            signal?.removeEventListener("abort", onAbort);
+            reject(signal?.reason);
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
     });
 }
 function combinedSignal(signal, timeoutMs) {
@@ -116,9 +131,10 @@ export async function fetchJsonWithRetry(url, body, headers = {}, signal, timeou
             });
             const text = await readLimited(response, response.ok ? maxResponseBytes : Math.min(maxResponseBytes, MAX_ERROR_BYTES));
             if (!response.ok) {
-                const retryable = retryableStatus(response.status);
+                const quota = isQuotaError(text);
+                const retryable = !quota && retryableStatus(response.status);
                 const providerRetryAfterMs = retryAfterFromHeaders(response.headers);
-                const error = makeError(`HTTP ${response.status}`, retryable ? "LCX_HTTP_RETRYABLE" : "LCX_HTTP_ERROR", {
+                const error = makeError(`HTTP ${response.status}`, quota ? "LCX_INSUFFICIENT_QUOTA" : retryable ? "LCX_HTTP_RETRYABLE" : "LCX_HTTP_ERROR", {
                     status: response.status,
                     retryable,
                     requestId: response.headers.get("x-request-id") ??
@@ -189,10 +205,11 @@ export async function fetchSseWithRetry(url, body, headers = {}, signal, timeout
                 redirect: "error",
             });
             if (!response.ok) {
-                await readLimited(response, Math.min(options.maxResponseBytes ?? DEFAULT_MAX_BYTES, MAX_ERROR_BYTES));
-                const retryable = retryableStatus(response.status);
+                const text = await readLimited(response, Math.min(options.maxResponseBytes ?? DEFAULT_MAX_BYTES, MAX_ERROR_BYTES));
+                const quota = isQuotaError(text);
+                const retryable = !quota && retryableStatus(response.status);
                 const providerRetryAfterMs = retryAfterFromHeaders(response.headers);
-                const error = makeError(`HTTP ${response.status}`, retryable ? "LCX_HTTP_RETRYABLE" : "LCX_HTTP_ERROR", {
+                const error = makeError(`HTTP ${response.status}`, quota ? "LCX_INSUFFICIENT_QUOTA" : retryable ? "LCX_HTTP_RETRYABLE" : "LCX_HTTP_ERROR", {
                     status: response.status,
                     retryable,
                     requestId: response.headers.get("x-request-id") ??
@@ -288,6 +305,17 @@ export async function consumeSse(response, onEvent, options = {}) {
         dispatch();
     }
     finally {
-        await reader.cancel().catch(() => undefined);
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // Cleanup must not replace the stream/parse/cancellation outcome.
+        }
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // The acquired reader owns no further work after settlement.
+        }
     }
 }

package/lib/types/client/index.d.ts

@@ -1,6 +1,18 @@
 import type { ClientModuleLoaderTarget } from "@deepseek-ai/dsh-client-modules/client";
+import { type SearchMediaItem } from "./search-media.js";
+type SearchMediaData = {
+    readonly items: readonly SearchMediaItem[];
+    readonly provider: string;
+    readonly model: string;
+};
+declare module "@deepseek-ai/dsh-client-ui-chat/client" {
+    interface ChatNodeDataMap {
+        "lcx-search-media": SearchMediaData;
+    }
+}
 declare global {
     interface Window {
         __ModuleLoader__: Pick<ClientModuleLoaderTarget, "load">;
     }
 }
+export {};

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

@@ -0,0 +1,16 @@
+export type SearchMediaItem = {
+    readonly kind: "image" | "video" | "page";
+    readonly url: string;
+    readonly poster?: string;
+    readonly previewUrl?: string;
+    readonly sourceUrl?: string;
+    readonly caption?: string;
+    readonly structured?: true;
+};
+export declare const SEARCH_MEDIA_LIMIT = 60;
+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[];

package/lib/web-run-output.js

@@ -152,6 +152,28 @@ export function outputLinks(blocks) {
         }
     return links;
 }
+export function mergeWebRunLinks(base, extra) {
+    const links = [];
+    for (const link of [...base, ...extra]) {
+        if (!Number.isSafeInteger(link.id) || !link.label)
+            continue;
+        const existing = links.find((value) => value.id === link.id);
+        if (!existing) {
+            links.push({
+                id: link.id,
+                label: link.label,
+                ...(link.domain ? { domain: link.domain } : {}),
+                ...(link.url ? { url: link.url } : {}),
+            });
+            continue;
+        }
+        if (!existing.domain && link.domain)
+            existing.domain = link.domain;
+        if (!existing.url && link.url)
+            existing.url = link.url;
+    }
+    return links;
+}
 export function outputPdfRefs(blocks) {
     const refs = [];
     for (const block of blocks) {

package/lib/web-search-alpha.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
 import { isIP } from "node:net";
-import { outputDomains, outputLineRange, outputLinks, outputPdfRefs, parseWebRunOutput, } from "./web-run-output.js";
+import { ServiceMutex } from "./service-mutex.js";
+import { fetchJsonWithRetry } from "./transport.js";
+import { mergeWebRunLinks, outputDomains, outputLineRange, outputLinks, outputPdfRefs, parseWebRunOutput, } from "./web-run-output.js";
 export const ALPHA_ACTIONS = [
     "search_query",
     "image_query",
@@ -125,9 +127,16 @@ function integer(value, field, min = 0, max = 10000) {
 }
 function date(value, field) {
     const normalized = text(value, field, 10);
-    if (!/^\d{4}-\d{2}-\d{2}$/u.test(normalized) ||
-        Number.isNaN(Date.parse(`${normalized}T00:00:00Z`)))
+    if (!/^\d{4}-\d{2}-\d{2}$/u.test(normalized))
         throw failure(`websearch_alpha.${field} must use YYYY-MM-DD`);
+    const year = Number(normalized.slice(0, 4));
+    const month = Number(normalized.slice(5, 7));
+    const day = Number(normalized.slice(8, 10));
+    const utc = new Date(Date.UTC(year, month - 1, day));
+    if (utc.getUTCFullYear() !== year ||
+        utc.getUTCMonth() !== month - 1 ||
+        utc.getUTCDate() !== day)
+        throw failure(`websearch_alpha.${field} must be a real calendar date`);
     return normalized;
 }
 function normalizeDomains(value) {
@@ -514,15 +523,92 @@ function safeResult(value, seen = new Set()) {
     }
     return result;
 }
-function artifacts(results) {
-    const refs = [], refRecords = [], sources = [], seenRefs = new Set(), seenSources = new Set();
-    const visit = (value) => {
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function canonicalJson(value, seen = new Set()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return JSON.stringify(value);
+    if (typeof value === "number")
+        return Number.isFinite(value) ? JSON.stringify(value) : undefined;
+    if (typeof value !== "object" || seen.has(value))
+        return undefined;
+    seen.add(value);
+    let result;
+    if (Array.isArray(value)) {
+        const items = value.map(item => canonicalJson(item, seen));
+        if (items.every((item) => item !== undefined))
+            result = `[${items.join(",")}]`;
+    }
+    else {
+        const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+        const items = [];
+        for (const [key, item] of entries) {
+            const encoded = canonicalJson(item, seen);
+            if (encoded === undefined) {
+                result = undefined;
+                break;
+            }
+            items.push(`${JSON.stringify(key)}:${encoded}`);
+            result = `{${items.join(",")}}`;
+        }
+        if (entries.length === 0)
+            result = "{}";
+    }
+    seen.delete(value);
+    return result;
+}
+function explicitArtifactFingerprint(value) {
+    const explicit = Object.fromEntries(["provenance", "provider_provenance"]
+        .filter(key => Object.hasOwn(value, key))
+        .map(key => [key, value[key]]));
+    if (Object.keys(explicit).length === 0)
+        return undefined;
+    const canonical = canonicalJson(explicit);
+    return canonical === undefined ? sha256("invalid-explicit-provenance") : sha256(canonical);
+}
+function alphaRefCollision(refId) {
+    return Object.assign(new Error(`Alpha reference collision in one provider response: ${refId}`), {
+        code: "LCX_ALPHA_REF_COLLISION",
+    });
+}
+function addRefObservation(artifacts, observation) {
+    const accepted = artifacts.observations.get(observation.refId);
+    if (!accepted) {
+        artifacts.observations.set(observation.refId, observation);
+        artifacts.refs.push(observation.refId);
+        artifacts.refRecords.push(observation);
+        return;
+    }
+    if ((accepted.url && observation.url && accepted.url !== observation.url) ||
+        (accepted.provenance.artifactFingerprint && observation.provenance.artifactFingerprint &&
+            accepted.provenance.artifactFingerprint !== observation.provenance.artifactFingerprint)) {
+        throw alphaRefCollision(observation.refId);
+    }
+    const merged = {
+        refId: accepted.refId,
+        ...(accepted.url || observation.url ? { url: accepted.url ?? observation.url } : {}),
+        provenance: {
+            ...accepted.provenance,
+            ...(accepted.provenance.artifactFingerprint || observation.provenance.artifactFingerprint
+                ? { artifactFingerprint: accepted.provenance.artifactFingerprint ?? observation.provenance.artifactFingerprint }
+                : {}),
+        },
+    };
+    artifacts.observations.set(observation.refId, merged);
+    artifacts.refRecords[artifacts.refRecords.indexOf(accepted)] = merged;
+}
+function artifacts(results, provenance) {
+    const result = { refs: [], refRecords: [], sources: [], observations: new Map() };
+    const seenSources = new Set();
+    const visit = (value, inheritedArtifact) => {
         if (!isObject(value) && !Array.isArray(value))
             return;
         if (Array.isArray(value)) {
-            value.forEach(visit);
+            value.forEach(item => visit(item, inheritedArtifact));
             return;
         }
+        const artifactFingerprint = explicitArtifactFingerprint(value) ?? inheritedArtifact;
         const candidate = typeof value.ref_id === "string" && value.ref_id
             ? value.ref_id
             : typeof value.id === "string" && /^turn[\w-]+$/u.test(value.id)
@@ -530,14 +616,15 @@ function artifacts(results) {
                 : undefined;
         const refId = isAlphaHttpUrl(candidate) ? undefined : candidate;
         const url = httpUrl(value.url ?? value.source_url ?? value.source_website_url ?? candidate);
-        if (refId && !seenRefs.has(refId)) {
-            seenRefs.add(refId);
-            refs.push(refId);
-            refRecords.push({ refId, ...(url ? { url } : {}) });
-        }
+        if (refId)
+            addRefObservation(result, {
+                refId,
+                ...(url ? { url } : {}),
+                provenance: { ...provenance, ...(artifactFingerprint ? { artifactFingerprint } : {}) },
+            });
         if (url && !seenSources.has(url)) {
             seenSources.add(url);
-            sources.push({
+            result.sources.push({
                 url,
                 ...(typeof value.title === "string" ? { title: value.title } : {}),
                 ...(typeof value.snippet === "string"
@@ -546,21 +633,67 @@ function artifacts(results) {
                 ...(refId ? { refId } : {}),
             });
         }
+        Object.entries(value)
+            .filter(([key]) => key !== "encrypted_output" && key !== "encrypted_content")
+            .forEach(([, item]) => visit(item, artifactFingerprint));
+    };
+    visit(results);
+    return result;
+}
+function structuredLinks(results) {
+    const links = [];
+    const visit = (value) => {
+        if (Array.isArray(value)) {
+            value.forEach(visit);
+            return;
+        }
+        if (!isObject(value))
+            return;
+        if (Array.isArray(value.links)) {
+            for (const item of value.links) {
+                if (!isObject(item))
+                    continue;
+                const id = item.id ?? item.link_id ?? item.linkId;
+                if (typeof id !== "number" || !Number.isSafeInteger(id))
+                    continue;
+                const url = httpUrl(item.url ?? item.href);
+                const label = (typeof item.label === "string" && item.label.trim()) ||
+                    (typeof item.title === "string" && item.title.trim()) ||
+                    url ||
+                    String(id);
+                const domain = typeof item.domain === "string" && item.domain.trim()
+                    ? item.domain.trim().slice(0, 253)
+                    : undefined;
+                if (!links.some((link) => link.id === id)) {
+                    links.push({
+                        id,
+                        label: String(label).slice(0, 500),
+                        ...(domain ? { domain } : {}),
+                        ...(url ? { url } : {}),
+                    });
+                }
+            }
+        }
         Object.values(value).forEach(visit);
     };
     visit(results);
-    return { refs, refRecords, sources };
+    return links;
 }
 const ACTION_ERROR = /^\s*(?:Error parsing function call\b|Invalid function_name=|Invalid function call\b)/iu;
 const ALPHA_SEMANTIC_FAILURE = /^\s*(?:reference(?: id)?\s+(?:is\s+)?(?:invalid|unavailable)\b|unable to access requested content\b|service unavailable\b)/iu;
 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;
 function alphaCommandErrorEnvelope(output, action) {
-    const match = String(output ?? "").match(ALPHA_COMMAND_ERROR_ENVELOPE);
-    if (match && match[1].toLowerCase() === action)
+    const text = String(output ?? "");
+    const command = text.match(ALPHA_COMMAND_ERROR_ENVELOPE);
+    if (command && command[1].toLowerCase() === action)
+        return true;
+    const fetchFailure = text.match(ALPHA_FETCH_FAILURE_ENVELOPE);
+    if (fetchFailure && fetchFailure[1].toLowerCase() === action)
         return true;
     // Match the action failure header, never error phrases quoted inside a page.
-    const reference = String(output ?? "").match(ALPHA_REFERENCE_ERROR_ENVELOPE);
+    const reference = text.match(ALPHA_REFERENCE_ERROR_ENVELOPE);
     return Boolean(reference &&
         reference[1].toLowerCase() === action &&
         /\b(?:reference(?: id)?|turn[\w-]+)\b/iu.test(reference[2]) &&
@@ -578,7 +711,14 @@ export function parseAlphaSearchResponse(response, options) {
                 alphaCommandErrorEnvelope(response.output, action))))
         throw failure("LCX Alpha Web Search could not execute the requested action", "LCX_ALPHA_ACTION_FAILED");
     const results = safeResult(response.results ?? []);
-    const a = artifacts(results);
+    const originKind = typeof response.id === "string" && response.id ? "response" : "request";
+    const originValue = originKind === "response" ? String(response.id) : String(options.requestId ?? "");
+    const provenance = {
+        action: action ?? "unknown",
+        originKind,
+        originFingerprint: sha256(originValue),
+    };
+    const a = artifacts(response.results ?? [], provenance);
     const outputBlocks = parseWebRunOutput(response.output);
     for (const block of outputBlocks)
         if (block.url) {
@@ -592,13 +732,11 @@ export function parseAlphaSearchResponse(response, options) {
         for (const ref of block.references ?? []) {
             if (isAlphaHttpUrl(ref))
                 continue;
-            if (!a.refs.includes(ref))
-                a.refs.push(ref);
-            if (!a.refRecords.some((item) => item.refId === ref))
-                a.refRecords.push({
-                    refId: ref,
-                    ...(block.url ? { url: block.url } : {}),
-                });
+            addRefObservation(a, {
+                refId: ref,
+                ...(block.url ? { url: block.url } : {}),
+                provenance,
+            });
         }
     for (const source of outputBlocks.flatMap((b) => b.url ? [{ url: b.url, ...(b.title ? { title: b.title } : {}) }] : []))
         if (!a.sources.some((x) => x.url === source.url))
@@ -614,7 +752,7 @@ export function parseAlphaSearchResponse(response, options) {
         sources: a.sources,
         citations: a.sources.map((s) => ({ ...s })),
         outputBlocks,
-        links: outputLinks(outputBlocks),
+        links: mergeWebRunLinks(outputLinks(outputBlocks), structuredLinks(results)),
         pdfRefs: outputPdfRefs(outputBlocks),
         domains: outputDomains(outputBlocks),
         ...(outputLineRange(outputBlocks)
@@ -633,18 +771,82 @@ export function parseAlphaSearchResponse(response, options) {
         refRecords: a.refRecords,
     };
 }
+function opaqueRefList(value) {
+    return Array.isArray(value)
+        ? value.filter((ref) => typeof ref === "string" && Boolean(ref) && !isAlphaHttpUrl(ref))
+        : [];
+}
+function sourceUrlForRef(sources, refId) {
+    const match = sources.find((source) => source.refId === refId && typeof source.url === "string" && source.url);
+    return typeof match?.url === "string" ? match.url : undefined;
+}
 export function renderAlphaSearchResult(value) {
     const data = isObject(value) ? value : {};
     const parts = [];
     if (typeof data.content === "string")
         parts.push(data.content);
-    if (Array.isArray(data.sources) && data.sources.length)
-        parts.push(`来源：\n${data.sources.filter(isObject).map((source) => `- [${String(source.title ?? source.url ?? "")}](${String(source.url ?? "")})`).join("\n")}`);
+    const sources = Array.isArray(data.sources) ? data.sources.filter(isObject) : [];
+    const refs = opaqueRefList(data.refs);
+    if (refs.length) {
+        parts.push(`可继续操作的引用：\n${refs.map((ref) => {
+            const url = sourceUrlForRef(sources, ref);
+            return url ? `- opaqueRef=${ref} url=${url}` : `- opaqueRef=${ref}`;
+        }).join("\n")}`);
+    }
+    const links = Array.isArray(data.links)
+        ? data.links.filter((link) => isObject(link) && Number.isSafeInteger(link.id))
+        : [];
+    if (links.length) {
+        parts.push(`可点击链接：\n${links.map((link) => {
+            const bits = [`linkId=${String(link.id)}`];
+            if (typeof link.label === "string" && link.label)
+                bits.push(`label=${link.label}`);
+            if (typeof link.domain === "string" && link.domain)
+                bits.push(`domain=${link.domain}`);
+            if (typeof link.url === "string" && link.url)
+                bits.push(`url=${link.url}`);
+            return `- ${bits.join(" ")}`;
+        }).join("\n")}`);
+    }
+    const pdfRefs = opaqueRefList(data.pdfRefs);
+    if (pdfRefs.length)
+        parts.push(`PDF引用：\n${pdfRefs.map((ref) => `- opaqueRef=${ref}`).join("\n")}`);
+    if (sources.length)
+        parts.push(`来源：\n${sources.map((source) => `- [${String(source.title ?? source.url ?? "")}](${String(source.url ?? "")})`).join("\n")}`);
     if (Array.isArray(data.warnings) && data.warnings.length)
         parts.push(data.warnings.map((warning) => `警告：${String(warning)}`).join("\n"));
     parts.push(`检索时间：${String(data.retrievedAt ?? "")}`);
     return [{ type: "text", text: parts.filter(Boolean).join("\n\n") }];
 }
+export const ALPHA_STATEFUL_RETRY_MAX_ATTEMPTS = 1;
+const alphaSessionLocks = new Map();
+export function alphaSearchRetryOptions(maxResponseBytes) {
+    return {
+        maxAttempts: ALPHA_STATEFUL_RETRY_MAX_ATTEMPTS,
+        ...(typeof maxResponseBytes === "number" ? { maxResponseBytes } : {}),
+    };
+}
+export async function runWithAlphaSessionLock(sessionId, signal, task) {
+    if (typeof sessionId !== "string" || !sessionId)
+        throw failure("websearch_alpha requires a DSH session", "LCX_ALPHA_SESSION_REQUIRED");
+    let entry = alphaSessionLocks.get(sessionId);
+    if (!entry) {
+        entry = { mutex: new ServiceMutex(), users: 0 };
+        alphaSessionLocks.set(sessionId, entry);
+    }
+    entry.users += 1;
+    try {
+        return await entry.mutex.run(signal, task);
+    }
+    finally {
+        entry.users -= 1;
+        if (entry.users === 0 && alphaSessionLocks.get(sessionId) === entry)
+            alphaSessionLocks.delete(sessionId);
+    }
+}
+export async function fetchAlphaSearchJson(options) {
+    return runWithAlphaSessionLock(options.sessionId, options.signal, () => fetchJsonWithRetry(options.url, options.body, options.headers, options.signal, options.timeoutMs, alphaSearchRetryOptions(options.maxResponseBytes)));
+}
 function probeFailureState(error) {
     const detail = isObject(error) ? error : {};
     if ([404, 405].includes(detail.status) ||

package/lib/web-search-capability.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { ALPHA_PROBE_VERSION } from "./web-search-alpha.js";
+import { ALPHA_ACTIONS, ALPHA_PROBE_VERSION, ALPHA_SEARCH_PARAMETERS } from "./web-search-alpha.js";
 import { JsonStore } from "./json-store.js";
 const VERSION = 1;
 const CLASSIFICATIONS = new Set(["native", "command-capable", "emulated-search-only", "unsupported", "unknown"]);
@@ -46,6 +46,31 @@ export function alphaCapabilityUsable(record) {
     return validRecord(record) && record.probeVersion === ALPHA_PROBE_VERSION &&
         (record.classification === "native" || record.classification === "command-capable");
 }
+export function alphaActionState(record, action) {
+    if (!validRecord(record) || typeof action !== "string" || !action)
+        return undefined;
+    const state = record.actions[action];
+    return isActionState(state) ? state : undefined;
+}
+export function assertAlphaActionAllowed(record, action) {
+    if (alphaActionState(record, action) === "unsupported") {
+        throw Object.assign(new Error(`Alpha action is unsupported for this verified route: ${String(action)}`), { code: "LCX_ALPHA_ACTION_UNSUPPORTED" });
+    }
+}
+export function alphaAdvertisedActions(record) {
+    if (!validRecord(record))
+        return [...ALPHA_ACTIONS];
+    return ALPHA_ACTIONS.filter((action) => record.actions[action] !== "unsupported");
+}
+export function alphaSearchParametersFor(record) {
+    return {
+        ...ALPHA_SEARCH_PARAMETERS,
+        properties: {
+            ...ALPHA_SEARCH_PARAMETERS.properties,
+            action: { type: "string", enum: alphaAdvertisedActions(record) },
+        },
+    };
+}
 export class AlphaCapabilityStore {
     store;
     constructor(file) {