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

package/lib/transport.js

@@ -1,81 +1,321 @@
-const DEFAULT_TIMEOUT_MS = 300_000
-const DEFAULT_MAX_BYTES = 8 * 1024 * 1024
-
+const DEFAULT_TIMEOUT_MS = 300_000;
+const DEFAULT_MAX_BYTES = 8 * 1024 * 1024;
+const MAX_ERROR_BYTES = 512 * 1024;
+function errorFacts(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
 export function abortIfNeeded(signal) {
-  if (signal?.aborted) throw signal.reason ?? Object.assign(new Error('request aborted'), { code: 'LCX_ABORTED' })
+    if (signal?.aborted)
+        throw (signal.reason ??
+            Object.assign(new Error("request aborted"), { code: "LCX_ABORTED" }));
+}
+function makeError(message, code, extra = {}) {
+    const error = new Error(message);
+    error.code = code;
+    Object.assign(error, extra);
+    return error;
+}
+function retryableStatus(status) {
+    return (status === 408 ||
+        status === 409 ||
+        status === 425 ||
+        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 makeError(message, code, extra = {}) { const error = new Error(message); error.code = code; Object.assign(error, extra); return error }
-function retryableStatus(status) { return status === 408 || status === 409 || status === 425 || status === 429 || (status >= 500 && status <= 599) }
 function retryAfterFromHeaders(headers) {
-  const rawMillis = headers?.get?.('retry-after-ms'); const millis = Number(rawMillis); if (rawMillis !== null && rawMillis !== undefined && rawMillis !== '' && Number.isFinite(millis) && millis >= 0) return Math.min(millis, 30_000)
-  const retryAfter = headers?.get?.('retry-after'); if (retryAfter) { const seconds = Number(retryAfter); if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1000, 30_000); const date = Date.parse(retryAfter); if (!Number.isNaN(date)) return Math.min(Math.max(0, date - Date.now()), 30_000) }
-  return undefined
+    const rawMillis = headers?.get?.("retry-after-ms");
+    const millis = Number(rawMillis);
+    if (rawMillis !== null &&
+        rawMillis !== undefined &&
+        rawMillis !== "" &&
+        Number.isFinite(millis) &&
+        millis >= 0)
+        return Math.min(millis, 30_000);
+    const retryAfter = headers?.get?.("retry-after");
+    if (retryAfter) {
+        const seconds = Number(retryAfter);
+        if (Number.isFinite(seconds) && seconds >= 0)
+            return Math.min(seconds * 1000, 30_000);
+        const date = Date.parse(retryAfter);
+        if (!Number.isNaN(date))
+            return Math.min(Math.max(0, date - Date.now()), 30_000);
+    }
+    return undefined;
 }
 function delayFromHeaders(headers, attempt) {
-  const retryAfter = retryAfterFromHeaders(headers)
-  if (retryAfter !== undefined) return retryAfter
-  return Math.min(10_000, 500 * 2 ** Math.max(0, attempt - 1))
+    const retryAfter = retryAfterFromHeaders(headers);
+    if (retryAfter !== undefined)
+        return retryAfter;
+    return Math.min(10_000, 500 * 2 ** Math.max(0, attempt - 1));
 }
-async function sleep(ms, signal) { if (ms <= 0) return; await new Promise((resolve, reject) => { if (signal?.aborted) return reject(signal.reason); const timer = setTimeout(resolve, ms); signal?.addEventListener('abort', () => { clearTimeout(timer); reject(signal.reason) }, { once: true }) }) }
-function combinedSignal(signal, timeoutMs) { if (!(Number.isFinite(timeoutMs) && timeoutMs > 0)) return signal; const timeout = AbortSignal.timeout(timeoutMs); return signal ? AbortSignal.any([signal, timeout]) : timeout }
-async function readLimited(response, maxBytes = DEFAULT_MAX_BYTES) { const buffer = new Uint8Array(await response.arrayBuffer()); if (buffer.byteLength > maxBytes) throw makeError(`response exceeds ${maxBytes} bytes`, 'LCX_RESPONSE_TOO_LARGE', { status: response.status }); return new TextDecoder().decode(buffer) }
-
-export async function fetchJsonWithRetry(url, body, headers = {}, signal, timeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
-  const maxAttempts = Math.max(1, Math.min(6, Number(options.maxAttempts ?? 3))); const maxResponseBytes = options.maxResponseBytes ?? DEFAULT_MAX_BYTES; let last
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    abortIfNeeded(signal)
+async function sleep(ms, signal) {
+    if (ms === undefined || ms <= 0)
+        return;
+    await new Promise((resolve, reject) => {
+        if (signal?.aborted)
+            return reject(signal.reason);
+        const onAbort = () => {
+            clearTimeout(timer);
+            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) {
+    if (!(typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0))
+        return signal;
+    const timeout = AbortSignal.timeout(timeoutMs);
+    return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+async function readLimited(response, maxBytes = DEFAULT_MAX_BYTES) {
+    if (!response.body)
+        return "";
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let bytes = 0;
+    let text = "";
     try {
-      const requestSignal = combinedSignal(signal, timeoutMs)
-      const response = await fetch(url, { method: 'POST', headers: { 'content-type': 'application/json', accept: 'application/json', ...headers }, body: JSON.stringify(body), signal: requestSignal, redirect: 'error' })
-      const text = await readLimited(response, maxResponseBytes)
-      if (!response.ok) {
-        const retryable = retryableStatus(response.status)
-        const providerRetryAfterMs = retryAfterFromHeaders(response.headers)
-        const error = makeError(`HTTP ${response.status}`, retryable ? 'LCX_HTTP_RETRYABLE' : 'LCX_HTTP_ERROR', { status: response.status, retryable, requestId: response.headers.get('x-request-id') ?? response.headers.get('request-id') ?? undefined, ...(providerRetryAfterMs === undefined ? {} : { providerRetryAfterMs }) })
-        if (!error.retryable || attempt >= maxAttempts) throw error; last = error; await sleep(delayFromHeaders(response.headers, attempt), signal); continue
-      }
-      let parsed
-      try { parsed = text ? JSON.parse(text) : {} } catch (cause) { throw makeError(`invalid JSON response from ${url}`, 'LCX_INVALID_JSON', { status: response.status, cause }) }
-      return parsed
-    } catch (error) {
-      if (signal?.aborted) throw signal.reason ?? error
-      const retryable = error?.retryable === true || error?.code === 'LCX_HTTP_RETRYABLE' || error instanceof TypeError || ['ECONNRESET','ECONNREFUSED','ETIMEDOUT','EAI_AGAIN','UND_ERR_CONNECT_TIMEOUT'].includes(error?.code)
-      if (!retryable || attempt >= maxAttempts) { if (attempt >= maxAttempts && retryable) throw makeError(`request failed after ${maxAttempts} attempts`, 'LCX_RETRY_EXHAUSTED', { cause: error, retryable: true }); throw error }
-      last = error; await sleep(Math.min(10_000, 500 * 2 ** (attempt - 1)), signal)
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                return text + decoder.decode();
+            bytes += value.byteLength;
+            if (bytes > maxBytes)
+                throw makeError(`response exceeds ${maxBytes} bytes`, "LCX_RESPONSE_TOO_LARGE", { status: response.status });
+            text += decoder.decode(value, { stream: true });
+        }
+    }
+    finally {
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // Cleanup must not replace the read/size error.
+        }
+        reader.releaseLock();
     }
-  }
-  throw last ?? makeError('request failed', 'LCX_REQUEST_FAILED')
 }
-
-export async function fetchSseWithRetry(url, body, headers = {}, signal, timeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
-  const maxAttempts = Math.max(1, Math.min(6, Number(options.maxAttempts ?? 3))); let last
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    abortIfNeeded(signal)
-    try {
-      const requestSignal = combinedSignal(signal, timeoutMs)
-      const response = await fetch(url, { method: 'POST', headers: { 'content-type': 'application/json', accept: 'text/event-stream', ...headers }, body: JSON.stringify(body), signal: requestSignal, redirect: 'error' })
-      if (!response.ok) {
-        await readLimited(response, Math.min(options.maxResponseBytes ?? DEFAULT_MAX_BYTES, 512 * 1024))
-        const retryable = retryableStatus(response.status); const providerRetryAfterMs = retryAfterFromHeaders(response.headers); const error = makeError(`HTTP ${response.status}`, retryable ? 'LCX_HTTP_RETRYABLE' : 'LCX_HTTP_ERROR', { status: response.status, retryable, requestId: response.headers.get('x-request-id') ?? response.headers.get('request-id') ?? undefined, ...(providerRetryAfterMs === undefined ? {} : { providerRetryAfterMs }) })
-        if (!retryable || attempt >= maxAttempts) throw error; last = error; await sleep(delayFromHeaders(response.headers, attempt), signal); continue
-      }
-      if (typeof options.consume === 'function') return await options.consume(response, { requestSignal }); return response
-    } catch (error) {
-      if (signal?.aborted) throw signal.reason ?? error
-      const retryable = error?.retryable === true || error?.code === 'LCX_HTTP_RETRYABLE' || error instanceof TypeError || ['ECONNRESET','ECONNREFUSED','ETIMEDOUT','EAI_AGAIN','UND_ERR_CONNECT_TIMEOUT'].includes(error?.code)
-      if (!retryable || attempt >= maxAttempts) { if (attempt >= maxAttempts && retryable) throw makeError(`request failed after ${maxAttempts} attempts`, 'LCX_RETRY_EXHAUSTED', { cause: error, retryable: true }); throw error }
-      last = error; await sleep(Math.min(10_000, 500 * 2 ** (attempt - 1)), signal)
+export async function fetchJsonWithRetry(url, body, headers = {}, signal, timeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
+    const maxAttempts = Math.max(1, Math.min(6, Number(options.maxAttempts ?? 3)));
+    const maxResponseBytes = options.maxResponseBytes ?? DEFAULT_MAX_BYTES;
+    let last;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        abortIfNeeded(signal);
+        try {
+            const requestSignal = combinedSignal(signal, timeoutMs);
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    accept: "application/json",
+                    ...headers,
+                },
+                body: JSON.stringify(body),
+                signal: requestSignal,
+                redirect: "error",
+            });
+            const text = await readLimited(response, response.ok ? maxResponseBytes : Math.min(maxResponseBytes, MAX_ERROR_BYTES));
+            if (!response.ok) {
+                const quota = isQuotaError(text);
+                const retryable = !quota && retryableStatus(response.status);
+                const providerRetryAfterMs = retryAfterFromHeaders(response.headers);
+                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") ??
+                        response.headers.get("request-id") ??
+                        undefined,
+                    ...(providerRetryAfterMs === undefined
+                        ? {}
+                        : { providerRetryAfterMs }),
+                });
+                if (!error.retryable || attempt >= maxAttempts)
+                    throw error;
+                last = error;
+                await sleep(delayFromHeaders(response.headers, attempt), signal);
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = text ? JSON.parse(text) : {};
+            }
+            catch (cause) {
+                throw makeError(`invalid JSON response from ${url}`, "LCX_INVALID_JSON", { status: response.status, cause });
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw signal.reason ?? error;
+            const details = errorFacts(error);
+            const retryable = details.retryable === true ||
+                details.code === "LCX_HTTP_RETRYABLE" ||
+                error instanceof TypeError ||
+                [
+                    "ECONNRESET",
+                    "ECONNREFUSED",
+                    "ETIMEDOUT",
+                    "EAI_AGAIN",
+                    "UND_ERR_CONNECT_TIMEOUT",
+                ].includes(details.code ?? "");
+            if (!retryable || attempt >= maxAttempts) {
+                if (attempt >= maxAttempts && retryable)
+                    throw makeError(`request failed after ${maxAttempts} attempts`, "LCX_RETRY_EXHAUSTED", { cause: error, retryable: true });
+                throw error;
+            }
+            last = error;
+            await sleep(Math.min(10_000, 500 * 2 ** (attempt - 1)), signal);
+        }
     }
-  }
-  throw last ?? makeError('request failed', 'LCX_REQUEST_FAILED')
+    throw last ?? makeError("request failed", "LCX_REQUEST_FAILED");
+}
+export async function fetchSseWithRetry(url, body, headers = {}, signal, timeoutMs, options = {}) {
+    const requestTimeoutMs = timeoutMs ??
+        (options.applyDefaultTimeout === false ? undefined : DEFAULT_TIMEOUT_MS);
+    const maxAttempts = Math.max(1, Math.min(6, Number(options.maxAttempts ?? 3)));
+    let last;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        abortIfNeeded(signal);
+        try {
+            const requestSignal = combinedSignal(signal, requestTimeoutMs);
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    accept: "text/event-stream",
+                    ...headers,
+                },
+                body: JSON.stringify(body),
+                signal: requestSignal,
+                redirect: "error",
+            });
+            if (!response.ok) {
+                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}`, quota ? "LCX_INSUFFICIENT_QUOTA" : retryable ? "LCX_HTTP_RETRYABLE" : "LCX_HTTP_ERROR", {
+                    status: response.status,
+                    retryable,
+                    requestId: response.headers.get("x-request-id") ??
+                        response.headers.get("request-id") ??
+                        undefined,
+                    ...(providerRetryAfterMs === undefined
+                        ? {}
+                        : { providerRetryAfterMs }),
+                });
+                if (!retryable || attempt >= maxAttempts)
+                    throw error;
+                last = error;
+                await sleep(delayFromHeaders(response.headers, attempt), signal);
+                continue;
+            }
+            if (typeof options.consume === "function")
+                return await options.consume(response, { requestSignal });
+            return response;
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw signal.reason ?? error;
+            const details = errorFacts(error);
+            const retryable = details.retryable === true ||
+                details.code === "LCX_HTTP_RETRYABLE" ||
+                error instanceof TypeError ||
+                [
+                    "ECONNRESET",
+                    "ECONNREFUSED",
+                    "ETIMEDOUT",
+                    "EAI_AGAIN",
+                    "UND_ERR_CONNECT_TIMEOUT",
+                ].includes(details.code ?? "");
+            if (!retryable || attempt >= maxAttempts) {
+                if (attempt >= maxAttempts && retryable)
+                    throw makeError(`request failed after ${maxAttempts} attempts`, "LCX_RETRY_EXHAUSTED", { cause: error, retryable: true });
+                throw error;
+            }
+            last = error;
+            await sleep(Math.min(10_000, 500 * 2 ** (attempt - 1)), signal);
+        }
+    }
+    throw last ?? makeError("request failed", "LCX_REQUEST_FAILED");
 }
-
 export async function consumeSse(response, onEvent, options = {}) {
-  if (!response?.body) throw makeError('SSE response has no body', 'LCX_INVALID_SSE')
-  const maxBytes = options.maxResponseBytes ?? DEFAULT_MAX_BYTES; const reader = response.body.getReader(); const decoder = new TextDecoder(); let pending = ''; let dataLines = []; let bytes = 0
-  const dispatch = () => { if (dataLines.length === 0) return; const data = dataLines.join('\n'); dataLines = []; if (data === '[DONE]') return; let event; try { event = JSON.parse(data) } catch (cause) { throw makeError('malformed SSE JSON', 'LCX_INVALID_SSE', { cause }) } onEvent(event) }
-  try {
-    while (true) { abortIfNeeded(options.signal); const { done, value } = await reader.read(); if (done) break; bytes += value.byteLength; if (bytes > maxBytes) throw makeError(`SSE response exceeds ${maxBytes} bytes`, 'LCX_RESPONSE_TOO_LARGE'); pending += decoder.decode(value, { stream: true }); let newline; while ((newline = pending.indexOf('\n')) >= 0) { const line = pending.slice(0, newline).replace(/\r$/u, ''); pending = pending.slice(newline + 1); if (line === '') dispatch(); else if (!line.startsWith(':') && line.startsWith('data:')) dataLines.push(line.slice(5).replace(/^ /u, '')) } }
-    pending += decoder.decode(); if (pending.startsWith('data:')) dataLines.push(pending.slice(5).replace(/^ /u, '')); dispatch()
-  } finally { await reader.cancel().catch(() => undefined) }
+    if (!response.body)
+        throw makeError("SSE response has no body", "LCX_INVALID_SSE");
+    const maxBytes = options.maxResponseBytes ?? DEFAULT_MAX_BYTES;
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let pending = "";
+    let dataLines = [];
+    let bytes = 0;
+    const dispatch = () => {
+        if (dataLines.length === 0)
+            return;
+        const data = dataLines.join("\n");
+        dataLines = [];
+        if (data === "[DONE]")
+            return;
+        let event;
+        try {
+            event = JSON.parse(data);
+        }
+        catch (cause) {
+            throw makeError("malformed SSE JSON", "LCX_INVALID_SSE", { cause });
+        }
+        onEvent(event);
+    };
+    try {
+        while (true) {
+            abortIfNeeded(options.signal);
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            bytes += value.byteLength;
+            if (bytes > maxBytes)
+                throw makeError(`SSE response exceeds ${maxBytes} bytes`, "LCX_RESPONSE_TOO_LARGE");
+            pending += decoder.decode(value, { stream: true });
+            let newline;
+            while ((newline = pending.indexOf("\n")) >= 0) {
+                const line = pending.slice(0, newline).replace(/\r$/u, "");
+                pending = pending.slice(newline + 1);
+                if (line === "")
+                    dispatch();
+                else if (!line.startsWith(":") && line.startsWith("data:"))
+                    dataLines.push(line.slice(5).replace(/^ /u, ""));
+            }
+        }
+        pending += decoder.decode();
+        if (pending.startsWith("data:"))
+            dataLines.push(pending.slice(5).replace(/^ /u, ""));
+        dispatch();
+    }
+    finally {
+        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

@@ -0,0 +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/types/index.d.ts

@@ -0,0 +1,83 @@
+import z from "@deepseek-ai/schemastery";
+import type { Context } from "@deepseek-ai/cordis";
+import "@deepseek-ai/dsh-agent";
+import "@deepseek-ai/dsh-tools";
+import "@deepseek-ai/dsh-web";
+export declare const name = "lcx-codex";
+export declare const inject: string[];
+type ConfigInput = {
+    supportsLongCacheRetention?: unknown;
+    supportsExplicitPromptCacheMode?: unknown;
+    alphaCapabilityPath?: unknown;
+    alphaRefPath?: unknown;
+    alphaProfile?: unknown;
+    alphaGroup?: unknown;
+    alphaMaxOutputTokens?: unknown;
+    webSearchProvider?: unknown;
+    webMaxResults?: unknown;
+    timeoutMs?: unknown;
+    maxResponseBytes?: unknown;
+    maxAttempts?: unknown;
+    maxRequestImageBytes?: unknown;
+    requestImagePixelBudget?: unknown;
+    requestImageMaxBytes?: unknown;
+    portableReplayMaxChars?: unknown;
+    nativeRetentionTokenBudget?: unknown;
+    assistantRetentionTokenReserve?: unknown;
+    assistantRetentionPerMessageTokenCap?: unknown;
+};
+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 function compactionPressureBand(totalTokens: number, contextWindow: number, policy: {
+    auto: number;
+    emergency: number;
+}): {
+    ratioPercent: number;
+    band: string;
+};
+export declare function apply(ctx: HostContext, configInput?: ConfigInput): void;
+export declare namespace apply {
+    export { inject };
+    export { Config };
+}
+export default apply;