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

package/lib/transport.js

@@ -1,81 +1,291 @@
-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));
 }
-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 timer = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        }, { 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 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 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 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 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)
+    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, MAX_ERROR_BYTES));
+                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 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 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 {
+        await reader.cancel().catch(() => undefined);
+    }
 }

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

@@ -0,0 +1,6 @@
+import type { ClientModuleLoaderTarget } from "@deepseek-ai/dsh-client-modules/client";
+declare global {
+    interface Window {
+        __ModuleLoader__: Pick<ClientModuleLoaderTarget, "load">;
+    }
+}

package/lib/types/compact-v2.d.ts

@@ -0,0 +1,104 @@
+import { buildCompactionResponsesBody } from "./responses-request.js";
+type HeaderMap = Record<string, string>;
+type CompactionItem = {
+    type: "compaction";
+    encrypted_content: string;
+};
+type FunctionCallItem = {
+    type: "function_call";
+    call_id: string;
+};
+type FunctionCallOutputItem = {
+    type: "function_call_output";
+    call_id: string;
+};
+type ValidatedOutputItem = CompactionItem | FunctionCallItem | FunctionCallOutputItem | {
+    type: string;
+};
+type CanonicalUsage = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    reasoningTokens?: number;
+};
+type GenerationControls = {
+    reasoningEffort?: unknown;
+    temperature?: unknown;
+    maxTokens?: unknown;
+};
+type GenerationEnvelope = {
+    reasoning?: {
+        effort: string;
+        summary: "auto";
+    };
+    include?: string[];
+    temperature?: number;
+    max_output_tokens?: number;
+};
+type NativeCompactionBodyOptions = GenerationControls & {
+    model: string;
+    modelDescriptor?: Exclude<Parameters<typeof buildCompactionResponsesBody>[0]["model"], string>;
+    input: unknown[];
+    tools?: unknown;
+    promptCacheKey?: string;
+    promptCacheRetention?: string;
+    cacheRetention?: "none" | "short" | "long";
+};
+type NativeCompactionRequestOptions = NativeCompactionBodyOptions & {
+    baseURL: string;
+    idempotencyKey?: string;
+    headers?: HeaderMap;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    maxAttempts?: number;
+    maxResponseBytes?: number;
+};
+type SseParseOptions = {
+    signal?: AbortSignal;
+    maxResponseBytes?: number;
+};
+type NativeCompactionResult = {
+    object: unknown;
+    id?: string;
+    output: ValidatedOutputItem[];
+    compaction: CompactionItem;
+    usage?: CanonicalUsage;
+};
+export declare const REMOTE_COMPACTION_V2_FEATURE = "remote_compaction_v2";
+/**
+ * @param {HeaderMap} [headers]
+ * @returns {HeaderMap}
+ */
+export declare function mergeFeatureHeader(headers?: HeaderMap): HeaderMap;
+/**
+ * @param {GenerationControls} [controls]
+ * @returns {GenerationEnvelope}
+ */
+export declare function responsesGenerationEnvelope(controls?: GenerationControls): GenerationEnvelope;
+/**
+ * @param {NativeCompactionBodyOptions} options
+ * @returns {NativeCompactionBody}
+ */
+export declare function buildNativeCompactionBody({ model, modelDescriptor, input, tools, promptCacheKey, promptCacheRetention, cacheRetention, reasoningEffort, temperature, maxTokens, }: NativeCompactionBodyOptions): {
+    [x: string]: unknown;
+} & {
+    model: string;
+    input: unknown[];
+    stream: boolean;
+    store: boolean;
+    tool_choice?: string;
+    parallel_tool_calls?: boolean;
+};
+/**
+ * Provider SSE events enter as unknown; response.completed remains authoritative.
+ * @param {Response} response
+ * @param {SseParseOptions} [options]
+ * @returns {Promise<NativeCompactionResult>}
+ */
+export declare function parseNativeCompactionSse(response: Response, options?: SseParseOptions): Promise<NativeCompactionResult>;
+/**
+ * @param {NativeCompactionRequestOptions} options
+ */
+export declare function requestNativeCompaction({ baseURL, model, modelDescriptor, input, tools, promptCacheKey, promptCacheRetention, cacheRetention, reasoningEffort, temperature, maxTokens, idempotencyKey, headers, signal, timeoutMs, maxAttempts, maxResponseBytes, }: NativeCompactionRequestOptions): Promise<NativeCompactionResult>;
+export {};

package/lib/types/dsh-compat.d.ts

@@ -0,0 +1,78 @@
+import { Session, type SessionStore } from "@deepseek-ai/dsh-session";
+import type { ToolRuntime } from "@deepseek-ai/dsh-tools";
+import { ServiceMutex } from "./service-mutex.js";
+type CompatMethod = (this: object, agent: unknown, trigger: string, signal: AbortSignal) => Promise<unknown>;
+type PrunerMethod = (...args: unknown[]) => unknown;
+type MutableService = Record<PropertyKey, unknown>;
+interface CompactionService extends MutableService {
+    compactIfNeeded: CompatMethod;
+}
+export interface CompactionPatchRecord {
+    compaction: CompactionService;
+    original: CompatMethod;
+    wrapper: CompatMethod;
+    mutex: ServiceMutex;
+    lifecycle: AbortController;
+}
+export type CompactionPatchRecords = Map<object, CompactionPatchRecord>;
+export type CompactionPatchBehavior = (agent: unknown, trigger: string, signal: AbortSignal, callOriginal: (signal: AbortSignal) => Promise<unknown>) => Promise<unknown>;
+interface PrunerService extends MutableService {
+    pruneSession: unknown;
+}
+export interface PrunerPatchRecord {
+    pruner: PrunerService;
+    original: unknown;
+    replacement: PrunerMethod;
+}
+interface ConfigService extends MutableService {
+    config: unknown;
+}
+export interface ConfigPatchRecord {
+    service: ConfigService;
+    original: unknown;
+    installed: unknown;
+}
+export declare function agentSessionId(agent: unknown): string;
+export declare function agentUsesSession(agent: unknown, session: Session): boolean;
+export declare function sessionFromAgent(agent: unknown): Session | undefined;
+export declare function readAgentRouteState(agent: unknown): {
+    requestConfig: unknown;
+    options: unknown;
+    sessionId: string;
+};
+export declare function scopedToolRuntime(agent: unknown): Pick<ToolRuntime, "register"> | undefined;
+export declare function tokenMeterTotal(value: unknown, session: Session): number | undefined;
+export declare function sessionsService(ctx: unknown): Pick<SessionStore, "get"> | undefined;
+export declare function sessionFor(ctx: unknown, sessionId: string): Session | undefined;
+export declare function readWebSearchProvider(ctx: unknown): unknown;
+export declare function writeWebSearchProvider(ctx: unknown, providerId: unknown): boolean;
+export declare function contextService(ctx: unknown, name: string): unknown;
+export declare function resolveContextService(ctx: unknown, name: string): unknown;
+export declare function resolveScopedService(agent: unknown, name: string): unknown;
+export declare function resolveAgentService(ctx: unknown, agent: unknown, name: string): unknown;
+export declare function concreteService(value: unknown): unknown;
+export declare function compactionPatchCandidate(value: unknown, records: ReadonlyMap<object, CompactionPatchRecord>): Pick<CompactionPatchRecord, "compaction" | "original"> | undefined;
+export declare function installCompactionPatch(records: CompactionPatchRecords, candidate: Pick<CompactionPatchRecord, "compaction" | "original">, mutex: ServiceMutex, lifecycle: AbortController, behavior: CompactionPatchBehavior): boolean;
+export declare function restoreCompactionPatches(records: Map<object, CompactionPatchRecord>, entries?: Iterable<CompactionPatchRecord>): void;
+export declare function toolResultPrunerState(value: unknown): {
+    pruner: PrunerService | undefined;
+    original: unknown;
+};
+export declare function patchToolResultPruner(state: {
+    pruner: PrunerService | undefined;
+    original: unknown;
+}, replacement: PrunerMethod): PrunerPatchRecord | undefined;
+export declare function restoreToolResultPruner(record: PrunerPatchRecord | undefined): void;
+export declare function compactionConfigState(service: unknown): {
+    service: ConfigService | undefined;
+    original: unknown;
+};
+export declare function patchCompactionConfig(state: {
+    service: ConfigService | undefined;
+    original: unknown;
+}, createConfig: (originalConfig: unknown) => unknown): ConfigPatchRecord | undefined;
+export declare function restoreCompactionConfig(record: ConfigPatchRecord | undefined): void;
+export declare function patchVisibleWebSearchTimeout(agent: unknown, getTimeoutMs: () => number | undefined, patchedDefinitions: Map<MutableService, unknown>): void;
+export declare function refreshVisibleWebSearchTimeouts(patchedDefinitions: ReadonlyMap<MutableService, unknown>, timeoutMs: number | undefined): void;
+export declare function restoreVisibleWebSearchTimeouts(patchedDefinitions: Map<MutableService, unknown>): void;
+export {};

package/lib/types/dsh-responses.d.ts

@@ -0,0 +1,82 @@
+import { requestImageHandleText, type Message } from "@deepseek-ai/dsh-llm";
+import type { Context } from "@deepseek-ai/cordis";
+import type { ResponseInputItem } from "openai/resources/responses/responses.js";
+type ImageAttachmentRef = Parameters<typeof requestImageHandleText>[0];
+import type { Model as PiModel, Tool as PiToolValue } from "@earendil-works/pi-ai";
+declare const DEFAULT_MAX_REQUEST_IMAGE_BYTES: number;
+declare const DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET: number;
+declare const DEFAULT_REQUEST_IMAGE_MAX_BYTES: number;
+export { DEFAULT_MAX_REQUEST_IMAGE_BYTES, DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET, DEFAULT_REQUEST_IMAGE_MAX_BYTES, };
+type WireRecord = Record<string, unknown>;
+type ImageSupport = "supported" | "unsupported" | "unknown";
+type PiTool = PiToolValue;
+type DshContext = Pick<Context, "attachments" | "llm" | "fs">;
+type ImageOptions = {
+    imageSupport: ImageSupport;
+    signal?: AbortSignal;
+    maxRequestImageBytes: number;
+    requestImagePixelBudget: number;
+    requestImageMaxBytes: number;
+};
+type SerializeOptions = Partial<ImageOptions> & {
+    route?: unknown;
+    model?: unknown;
+    responsesCompat?: unknown;
+    systemPrompt?: unknown;
+    includeSystemPrompt?: boolean;
+    onReplayDegrade?: unknown;
+    tools?: PiTool[];
+};
+type ReplayBlock = WireRecord & {
+    type: "text" | "reasoning" | "tool-call";
+};
+type ReplayResponse = WireRecord & {
+    kind: "pi-ai";
+    version: 2;
+    api: string;
+    provider: string;
+    model: string;
+    stopReason: "stop" | "length" | "toolUse" | "error" | "aborted";
+};
+export declare function responseInputItems(value: unknown): ResponseInputItem[];
+export declare function resolveModelImageSupport(ctx: DshContext | undefined, route: {
+    provider?: unknown;
+    model?: unknown;
+}, signal?: AbortSignal): Promise<ImageSupport>;
+export declare function readDshPiReplayState(value: unknown): {
+    response: ReplayResponse;
+    blocks: ReplayBlock[];
+};
+export declare function resolvePiResponsesModel(options: {
+    imageSupport: unknown;
+    route?: unknown;
+    model?: unknown;
+    responsesCompat?: unknown;
+}): {
+    id: string;
+    name: string;
+    api: string;
+    provider: string;
+    baseUrl: string;
+    reasoning: boolean;
+    input: any[];
+    cost: {};
+    contextWindow: number;
+    maxTokens: number;
+    compat?: {
+        [x: string]: unknown;
+    } | undefined;
+};
+export declare function serializeDshMessages(messages: readonly Message[], ctx: DshContext | undefined, options?: SerializeOptions): Promise<{
+    input: import("openai/resources/responses/responses.js").ResponseInput;
+    imageMap: Map<string, import("@deepseek-ai/dsh-attachment").ImageAttachmentRef>;
+    tools: import("openai/resources/responses/responses.js").Tool[] | undefined;
+    model: PiModel<"openai-responses">;
+    grammarToolInputProperties: ReadonlyMap<string, string>;
+    deferredToolsMode: string | undefined;
+}>;
+export declare function responsesTools(tools: readonly PiTool[] | undefined): any[] | undefined;
+export declare function persistNativeImageReferences(output: readonly unknown[], imageMap: ReadonlyMap<string, ImageAttachmentRef>): unknown[];
+export declare function hydrateNativeImageReferences(output: unknown, ctx: DshContext | undefined, options?: Partial<ImageOptions> & {
+    imageMap?: unknown;
+}): Promise<unknown[]>;