dsh-lcx-codex 0.4.2 → 0.4.3-pre.2

package/lib/types/web-search-alpha.d.ts

@@ -0,0 +1,286 @@
+import type { ContentBlock } from "@deepseek-ai/dsh-llm";
+export declare const ALPHA_ACTIONS: string[];
+export declare const ALPHA_SEARCH_PARAMETERS: {
+    type: "object";
+    properties: {
+        action: {
+            type: "string";
+            enum: string[];
+        };
+        query: {
+            type: "string";
+        };
+        domains: {
+            type: "array";
+            items: {
+                type: "string";
+            };
+        };
+        recency: {
+            type: "integer";
+        };
+        refId: {
+            type: "string";
+        };
+        lineNumber: {
+            type: "integer";
+        };
+        linkId: {
+            type: "integer";
+        };
+        pattern: {
+            type: "string";
+        };
+        pageNumber: {
+            type: "integer";
+        };
+        ticker: {
+            type: "string";
+        };
+        assetType: {
+            type: "string";
+            enum: string[];
+        };
+        market: {
+            type: "string";
+        };
+        location: {
+            type: "string";
+        };
+        start: {
+            type: "string";
+        };
+        duration: {
+            type: "integer";
+        };
+        fn: {
+            type: "string";
+            enum: string[];
+        };
+        league: {
+            type: "string";
+            enum: string[];
+        };
+        team: {
+            type: "string";
+        };
+        opponent: {
+            type: "string";
+        };
+        dateFrom: {
+            type: "string";
+        };
+        dateTo: {
+            type: "string";
+        };
+        numberOfGames: {
+            type: "integer";
+        };
+        locale: {
+            type: "string";
+        };
+        utcOffset: {
+            type: "string";
+        };
+        responseLength: {
+            type: "string";
+            enum: string[];
+        };
+    };
+    required: string[];
+    additionalProperties: false;
+};
+export declare const ALPHA_SEARCH_OUTPUT: {
+    type: "object";
+    properties: {
+        mode: {
+            type: "string";
+        };
+        action: {
+            type: "string";
+        };
+        capability: {
+            type: "string";
+        };
+        emulation: {
+            type: "string";
+        };
+        content: {
+            type: "string";
+        };
+        results: {
+            type: "array";
+            items: {
+                type: "object";
+            };
+        };
+        refs: {
+            type: "array";
+            items: {
+                type: "string";
+            };
+        };
+        sources: {
+            type: "array";
+            items: {
+                type: "object";
+            };
+        };
+        citations: {
+            type: "array";
+            items: {
+                type: "object";
+            };
+        };
+        outputBlocks: {
+            type: "array";
+            items: {
+                type: "object";
+            };
+        };
+        links: {
+            type: "array";
+            items: {
+                type: "object";
+            };
+        };
+        pdfRefs: {
+            type: "array";
+            items: {
+                type: "string";
+            };
+        };
+        domains: {
+            type: "array";
+            items: {
+                type: "string";
+            };
+        };
+        lineRange: {
+            type: "object";
+        };
+        requestId: {
+            type: "string";
+        };
+        responseId: {
+            type: "string";
+        };
+        retrievedAt: {
+            type: "string";
+        };
+        warnings: {
+            type: "array";
+            items: {
+                type: "string";
+            };
+        };
+    };
+    required: string[];
+    additionalProperties: false;
+};
+export declare const ALPHA_SCHEMA_FINGERPRINT: string;
+export declare const ALPHA_PROBE_VERSION = 12;
+type RecordValue = Record<string, unknown>;
+type AlphaAction = (typeof ALPHA_ACTIONS)[number];
+type NormalizedAlphaArgs = RecordValue & {
+    action: AlphaAction;
+};
+type AlphaResponse = {
+    output: string;
+    results?: unknown[];
+    id?: unknown;
+};
+type AlphaProbeValue = RecordValue & {
+    content?: unknown;
+    results?: unknown;
+    refs?: unknown;
+    links?: unknown;
+    pdfRefs?: unknown;
+    outputBlocks?: unknown;
+    sources?: unknown;
+};
+type AlphaInvoke = (args: RecordValue) => Promise<AlphaProbeValue>;
+export declare function normalizeAlphaSearchArgs(args: unknown): NormalizedAlphaArgs;
+export declare function alphaActionCommand(args: NormalizedAlphaArgs): Record<string, unknown>;
+export declare function buildAlphaSearchBody(args: NormalizedAlphaArgs, model: unknown, sessionId: string, externalWebAccess?: boolean, maxOutputTokens?: number): {
+    id: string;
+    model: unknown;
+    input: {
+        role: string;
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }[];
+    commands: Record<string, unknown>;
+    settings: {
+        allowed_callers: string[];
+        external_web_access: boolean;
+    };
+    max_output_tokens: number;
+};
+export declare function isPublicAlphaTarget(url: URL): boolean;
+export declare function isAlphaHttpUrl(value: unknown): value is string;
+export declare function isAlphaContinuationUrl(value: unknown): value is string;
+export declare function alphaRefRequiresStore(action: string, refId: unknown): boolean;
+export declare function parseAlphaSearchResponse(response: AlphaResponse, options: {
+    action: unknown;
+    capability: unknown;
+    requestId: unknown;
+    retrievedAt?: unknown;
+}): {
+    mode: string;
+    action: unknown;
+    capability: unknown;
+    emulation: string;
+    content: string;
+    results: unknown;
+    refs: string[];
+    sources: {
+        refId?: string;
+        snippet?: string;
+        title?: string;
+        url: string;
+    }[];
+    citations: {
+        refId?: string;
+        snippet?: string;
+        title?: string;
+        url: string;
+    }[];
+    outputBlocks: import("./web-run-output.js").WebRunBlock[];
+    links: import("./web-run-output.js").WebRunLink[];
+    pdfRefs: string[];
+    domains: string[];
+    lineRange?: {
+        first: number;
+        last: number;
+    } | undefined;
+    requestId: unknown;
+    responseId?: string | undefined;
+    retrievedAt: {};
+    warnings: string[];
+    refRecords: {
+        url?: string;
+        refId: string;
+    }[];
+};
+export declare function renderAlphaSearchResult(value: unknown): ContentBlock[];
+export declare function probeAlphaCapabilities({ invoke, schemaFingerprint, trustedNativeProvenance, actionProbes, clickProbeRef, screenshotProbeRef, }: {
+    invoke: AlphaInvoke;
+    schemaFingerprint: unknown;
+    trustedNativeProvenance?: boolean;
+    actionProbes?: Record<string, RecordValue>;
+    clickProbeRef?: unknown;
+    screenshotProbeRef?: unknown;
+}): Promise<{
+    classification: string;
+    actions: {
+        [k: string]: string;
+    };
+    probedAt: string;
+    schemaFingerprint: unknown;
+    probeVersion: number;
+    provenance: string;
+}>;
+export {};

package/lib/types/web-search-capability.d.ts

@@ -0,0 +1,26 @@
+import { JsonStore } from "./json-store.js";
+declare const VERSION = 1;
+type Classification = "native" | "command-capable" | "emulated-search-only" | "unsupported" | "unknown";
+type ActionState = "supported" | "unsupported" | "unknown";
+type Provenance = "trusted-native" | "unavailable";
+export interface AlphaCapabilityRecord {
+    classification: Classification;
+    actions: Record<string, ActionState>;
+    probedAt: string;
+    schemaFingerprint: string;
+    probeVersion?: number;
+    provenance?: Provenance;
+}
+interface CapabilityData {
+    version: typeof VERSION;
+    capabilities: Record<string, AlphaCapabilityRecord>;
+}
+export declare function alphaCapabilityFingerprint(config: Record<string, unknown>): string;
+export declare function alphaCapabilityUsable(record: unknown): boolean;
+export declare class AlphaCapabilityStore {
+    readonly store: JsonStore<CapabilityData>;
+    constructor(file: string);
+    get(fingerprint: string): AlphaCapabilityRecord | undefined;
+    put(fingerprint: unknown, record: unknown): void;
+}
+export {};

package/lib/types/web-search-hosted.d.ts

@@ -0,0 +1,246 @@
+import type { ContentBlock } from "@deepseek-ai/dsh-llm";
+type SearchContextSize = "low" | "medium" | "high";
+type ReturnTokenBudget = "default" | "unlimited";
+type SearchContentType = "text" | "image";
+interface UserLocation {
+    country?: string;
+    city?: string;
+    region?: string;
+    timezone?: string;
+}
+interface ImageSettings {
+    maxResults?: number;
+    caption?: boolean;
+}
+interface HostedSearchArgs {
+    query: string;
+    searchContextSize?: SearchContextSize;
+    allowedDomains?: string[];
+    blockedDomains?: string[];
+    userLocation?: UserLocation;
+    externalWebAccess?: boolean;
+    returnTokenBudget?: ReturnTokenBudget;
+    searchContentTypes?: SearchContentType[];
+    imageSettings?: ImageSettings;
+}
+interface Source {
+    url: string;
+    title?: string;
+    snippet?: string;
+    publishedAt?: string;
+    refId?: string;
+}
+interface ImageResult {
+    imageUrl: string;
+    thumbnailUrl?: string;
+    sourceWebsiteUrl?: string;
+    caption?: string;
+}
+export declare const HOSTED_SEARCH_PARAMETERS: {
+    type: "object";
+    properties: {
+        query: {
+            type: "string";
+            description: string;
+        };
+        searchContextSize: {
+            type: "string";
+            enum: string[];
+        };
+        allowedDomains: {
+            type: "array";
+            items: {
+                type: "string";
+            };
+        };
+        blockedDomains: {
+            type: "array";
+            items: {
+                type: "string";
+            };
+        };
+        userLocation: {
+            type: "object";
+            properties: {
+                country: {
+                    type: "string";
+                };
+                city: {
+                    type: "string";
+                };
+                region: {
+                    type: "string";
+                };
+                timezone: {
+                    type: "string";
+                };
+            };
+            additionalProperties: false;
+        };
+        externalWebAccess: {
+            type: "boolean";
+        };
+        returnTokenBudget: {
+            type: "string";
+            enum: string[];
+        };
+        searchContentTypes: {
+            type: "array";
+            items: {
+                type: "string";
+                enum: string[];
+            };
+        };
+        imageSettings: {
+            type: "object";
+            properties: {
+                maxResults: {
+                    type: "integer";
+                };
+                caption: {
+                    type: "boolean";
+                };
+            };
+            additionalProperties: false;
+        };
+    };
+    required: string[];
+    additionalProperties: false;
+};
+export declare const HOSTED_SEARCH_OUTPUT: {
+    type: "object";
+    properties: {
+        mode: {
+            type: "string";
+            enum: string[];
+        };
+        action: {
+            type: "string";
+        };
+        emulation: {
+            type: "string";
+            enum: string[];
+        };
+        content: {
+            type: "string";
+        };
+        sources: {
+            type: "array";
+            items: {
+                type: "object";
+            };
+        };
+        citations: {
+            type: "array";
+            items: {
+                type: "object";
+            };
+        };
+        images: {
+            type: "array";
+            items: {
+                type: "object";
+            };
+        };
+        warnings: {
+            type: "array";
+            items: {
+                type: "string";
+            };
+        };
+        outputBlocks: {
+            type: "array";
+            items: {
+                type: "object";
+            };
+        };
+        domains: {
+            type: "array";
+            items: {
+                type: "string";
+            };
+        };
+        lineRange: {
+            type: "object";
+        };
+        requestId: {
+            type: "string";
+        };
+        responseId: {
+            type: "string";
+        };
+        retrievedAt: {
+            type: "string";
+        };
+        truncated: {
+            type: "boolean";
+        };
+    };
+    required: string[];
+    additionalProperties: false;
+};
+export declare function normalizeHostedSearchArgs(args: unknown): HostedSearchArgs;
+export declare function buildHostedSearchBody(args: HostedSearchArgs, model: unknown, options?: {
+    promptCacheKey?: string;
+}): {
+    model: unknown;
+    input: {
+        role: string;
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }[];
+    tools: {
+        type: string;
+        search_context_size?: SearchContextSize | undefined;
+        filters?: {
+            allowed_domains?: string[] | undefined;
+            blocked_domains?: string[] | undefined;
+        } | undefined;
+        user_location?: {
+            country?: string;
+            city?: string;
+            region?: string;
+            timezone?: string;
+            type: string;
+        } | undefined;
+        external_web_access?: boolean | undefined;
+        return_token_budget?: ReturnTokenBudget | undefined;
+        search_content_types?: SearchContentType[] | undefined;
+        image_settings?: {
+            max_results?: number | undefined;
+            caption?: boolean | undefined;
+        } | undefined;
+    }[];
+    tool_choice: string;
+    include: string[];
+    stream: boolean;
+    store: boolean;
+    prompt_cache_key?: string | undefined;
+};
+export declare function parseHostedSearchResponse(response: unknown, requestId: string, maxResults?: number, retrievedAt?: string): {
+    mode: string;
+    action: string;
+    emulation: string;
+    content: string;
+    sources: {
+        url: string;
+        title?: string | undefined;
+    }[];
+    citations: Source[];
+    images: ImageResult[];
+    warnings: string[];
+    outputBlocks: import("./web-run-output.js").WebRunBlock[];
+    domains: string[];
+    lineRange?: {
+        first: number;
+        last: number;
+    } | undefined;
+    requestId: string;
+    responseId?: string | undefined;
+    retrievedAt: string;
+    truncated: boolean;
+};
+export declare function renderHostedSearchResult(value: unknown): ContentBlock[];
+export {};

package/lib/types/web-search-ref-store.d.ts

@@ -0,0 +1,22 @@
+import { JsonStore } from "./json-store.js";
+declare const VERSION = 1;
+interface RefRecord {
+    refId: string;
+    url?: string;
+}
+interface SessionRecord {
+    routeFingerprint: string;
+    updatedAt: string;
+    refs: Record<string, RefRecord>;
+}
+interface RefStoreData {
+    version: typeof VERSION;
+    sessions: Record<string, SessionRecord>;
+}
+export declare class AlphaRefStore {
+    readonly store: JsonStore<RefStoreData>;
+    constructor(file: string);
+    record(sessionId: unknown, routeFingerprint: unknown, refs: unknown): void;
+    assertUsable(sessionId: unknown, routeFingerprint: unknown, refId: unknown): RefRecord;
+}
+export {};