@shuind/dsh-codex-harness 0.1.10 → 0.1.12

package/lib/types/index.d.ts

@@ -1,6 +1,15 @@
 /** Codex-compatible prompt overlay and core tools for a dsh agent preset. */
 import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
+import type { LlmCallConfig } from '@deepseek-ai/dsh-llm';
+declare module '@deepseek-ai/dsh-llm' {
+    interface LlmCallConfig {
+        /** Codex request context capacity override, in tokens. */
+        contextWindow?: number;
+        /** Provider-facing service tier, for example Responses `priority`. */
+        serviceTier?: string;
+    }
+}
 export declare const name = "codex";
 export declare const inject: string[];
 /** Configuration for the Codex shell result bridge. */
@@ -13,9 +22,32 @@ export interface Config {
     writeYieldTimeMs?: number;
     /** Maximum output retained in one canonical result, in UTF-8 bytes. */
     maxOutputBytes?: number;
+    /** Send GPT Responses requests with the native hosted web_search tool first. */
+    hostedWebSearch?: boolean;
+    /** Use the provider's /responses/compact endpoint before local compaction. */
+    remoteCompact?: boolean;
 }
 /** Runtime configuration schema for the Codex tool bridge. */
 export declare const Config: z<Config>;
+/** Live Codex-only request controls shared by the Web controls and agent layer. */
+export declare const CODEX_SETTINGS_NAMESPACE: import("@deepseek-ai/dsh-settings").SettingsNamespace;
+export interface CodexSettings {
+    /** Use the Responses priority service tier for GPT requests. */
+    fast: boolean;
+    /** Optional context capacity override, in tokens. */
+    contextWindow?: number;
+}
+export declare const CODEX_SETTINGS_SCHEMA: z<CodexSettings>;
+export interface CodexModelProfile {
+    id: string;
+    input?: string[];
+    reasoningEfforts?: false | Record<string, string | null>;
+    [key: string]: unknown;
+}
+/** Add Codex defaults without overwriting explicit user capabilities. */
+export declare function enrichCodexModel(model: CodexModelProfile): CodexModelProfile;
+/** Apply the live Codex controls to one agent request without leaking them to other routes. */
+export declare function applyCodexRequestSettings(request: LlmCallConfig, settings: CodexSettings): LlmCallConfig;
 /** Mount the Codex prompt/tool layer inside one fixed agent preset. */
 export declare function apply(ctx: Context, config?: Config): void;
 declare const _default: {

package/lib/types/index.js

@@ -1,17 +1,141 @@
 /** Codex-compatible prompt overlay and core tools for a dsh agent preset. */
 import z from '@deepseek-ai/schemastery';
+import { installSettingsSection, settingsNamespace } from '@deepseek-ai/dsh-settings';
 import { defineTool } from '@deepseek-ai/dsh-tools';
+import { CODEX_CONTEXT_MAX } from "./context.js";
 import { applyPatchHunks, parsePatch } from "./patch.js";
 import { renderExecResult, runExecCommand, runWriteStdin } from "./exec.js";
+import { hostedWebSearchStream, installHostedWebSearch, remoteCompactStream } from "./remote.js";
 export const name = 'codex';
-export const inject = ['tools', 'systemPrompt', 'shell', 'fs'];
+export const inject = ['tools', 'systemPrompt', 'shell', 'fs', 'llm', 'credentials', 'settings'];
 /** Runtime configuration schema for the Codex tool bridge. */
 export const Config = z.object({
     defaultYieldTimeMs: z.number().step(1).min(0).default(10_000),
     pollYieldTimeMs: z.number().step(1).min(0).default(5_000),
     writeYieldTimeMs: z.number().step(1).min(0).default(250),
     maxOutputBytes: z.number().step(1).min(1).default(64_000),
+    hostedWebSearch: z.boolean().default(true),
+    remoteCompact: z.boolean().default(true),
 });
+const LLM_PI_AI_SETTINGS = settingsNamespace('llm-pi-ai');
+/** Live Codex-only request controls shared by the Web controls and agent layer. */
+export const CODEX_SETTINGS_NAMESPACE = settingsNamespace('codex');
+export const CODEX_SETTINGS_SCHEMA = z.object({
+    fast: z.boolean().default(false),
+    contextWindow: z.number().step(1).min(1).max(CODEX_CONTEXT_MAX),
+});
+const CODEX_SETTINGS_ENTRY = { fast: false };
+const GPT_REASONING_EFFORTS = {
+    low: 'low',
+    medium: 'medium',
+    high: 'high',
+    xhigh: 'xhigh',
+    max: 'max',
+};
+function codexReasoningEfforts(configured) {
+    if (configured === false)
+        return false;
+    const filtered = configured === undefined
+        ? {}
+        : Object.fromEntries(Object.entries(configured).filter(([level]) => level !== 'off' && level !== 'minimal'));
+    return Object.keys(filtered).length === 0 ? GPT_REASONING_EFFORTS : filtered;
+}
+/** GPT model ids are the only models whose relay capabilities Codex fills in. */
+function isGptModel(id) {
+    return /(?:^|\/)(?:gpt|chatgpt)(?:[-_.]|\d|$)/i.test(id);
+}
+/** Add Codex defaults without overwriting explicit user capabilities. */
+export function enrichCodexModel(model) {
+    if (!isGptModel(model.id))
+        return model;
+    const input = model.input === undefined || model.input.length === 0
+        ? ['text', 'image']
+        : model.input;
+    const efforts = codexReasoningEfforts(model.reasoningEfforts);
+    if (input === model.input && efforts === model.reasoningEfforts)
+        return model;
+    return { ...model, input, reasoningEfforts: efforts };
+}
+/** The settings schema keys modelOverrides by id, so its values must not carry an id field. */
+function enrichCodexOverride(id, model) {
+    if (!isGptModel(id))
+        return model;
+    const enriched = enrichCodexModel({ ...model, id });
+    const { id: _id, ...withoutId } = enriched;
+    const inputMissing = model.input === undefined || model.input.length === 0;
+    const nextEfforts = codexReasoningEfforts(model.reasoningEfforts);
+    const reasoningChanged = JSON.stringify(nextEfforts) !== JSON.stringify(model.reasoningEfforts);
+    if (!inputMissing && !reasoningChanged)
+        return model;
+    return { ...withoutId, reasoningEfforts: nextEfforts };
+}
+/** Persist only missing GPT capabilities into the user's existing pi-ai model config. */
+async function enrichConfiguredGptModels(ctx) {
+    const settings = ctx.get('settings');
+    if (settings === undefined)
+        return;
+    const current = settings.get(LLM_PI_AI_SETTINGS);
+    if (current?.providers === undefined)
+        return;
+    const providers = {};
+    let changed = false;
+    for (const [provider, profile] of Object.entries(current.providers)) {
+        const models = profile.models;
+        const overrides = profile.modelOverrides;
+        const nextModels = Array.isArray(models) ? models.map(enrichCodexModel) : undefined;
+        const nextOverrides = overrides === undefined
+            ? undefined
+            : Object.fromEntries(Object.entries(overrides).map(([id, model]) => [id, enrichCodexOverride(id, model)]));
+        const modelsChanged = nextModels !== undefined && nextModels.some((model, index) => model !== models?.[index]);
+        const overridesChanged = nextOverrides !== undefined
+            && overrides !== undefined
+            && Object.entries(nextOverrides).some(([id, model]) => model !== overrides[id]);
+        if (modelsChanged || overridesChanged) {
+            changed = true;
+            providers[provider] = {
+                ...modelsChanged ? { models: nextModels } : {},
+                ...overridesChanged ? { modelOverrides: nextOverrides } : {},
+            };
+        }
+    }
+    if (changed)
+        await settings.update(LLM_PI_AI_SETTINGS, { providers });
+}
+/** Keep newly edited GPT model entries enriched while Codex mode is mounted. */
+function watchConfiguredGptModels(ctx) {
+    let tail = Promise.resolve();
+    const schedule = () => {
+        tail = tail.then(() => enrichConfiguredGptModels(ctx)).catch(error => {
+            ctx.logger.warn('codex: could not enrich configured GPT model capabilities');
+            ctx.logger.warn(error);
+        });
+    };
+    ctx.on('settings/document-updated', (ns) => {
+        if (ns === LLM_PI_AI_SETTINGS)
+            schedule();
+    });
+    schedule();
+}
+/** Install the optional settings source used by the request waterfall. */
+function installCodexSettings(ctx) {
+    let source = () => CODEX_SETTINGS_ENTRY;
+    installSettingsSection(ctx, CODEX_SETTINGS_NAMESPACE, CODEX_SETTINGS_SCHEMA, CODEX_SETTINGS_ENTRY, {
+        setSource: (current) => { source = current; },
+        onChange: () => { },
+    });
+    return { current: () => source() };
+}
+/** Apply the live Codex controls to one agent request without leaking them to other routes. */
+export function applyCodexRequestSettings(request, settings) {
+    const { contextWindow: _inheritedContextWindow, serviceTier: _inheritedServiceTier, ...withoutCodexControls } = request;
+    if (!isGptModel(request.model))
+        return withoutCodexControls;
+    return {
+        ...withoutCodexControls,
+        ...settings.contextWindow === undefined ? {} : { contextWindow: settings.contextWindow },
+        ...settings.fast ? { serviceTier: 'priority' } : {},
+    };
+}
 const CODEX_BASE_PROMPT = String.raw `You are Codex, based on {{model}}. You are running as a coding agent in dsh Web on a user's computer.
 
 ## General
@@ -308,10 +432,41 @@ export function apply(ctx, config = {}) {
         pollYieldTimeMs: config.pollYieldTimeMs ?? 5_000,
         writeYieldTimeMs: config.writeYieldTimeMs ?? 250,
         maxOutputBytes: config.maxOutputBytes ?? 64_000,
+        hostedWebSearch: config.hostedWebSearch ?? true,
+        remoteCompact: config.remoteCompact ?? true,
     };
     if (ctx.fs.sandboxMode !== undefined && ctx.get('sandboxPolicy') === undefined) {
         throw new Error('codex: a sandboxing filesystem requires ctx.sandboxPolicy');
     }
+    // The generic pi-ai plugin remains the owner of the user's configured
+    // provider routes. Codex adds only scoped transport behavior and capability
+    // metadata; failed remote operations continue through the generic path.
+    watchConfiguredGptModels(ctx);
+    const codexSettings = installCodexSettings(ctx);
+    // Keep these controls in the request config rather than mutating provider
+    // settings. That makes a change apply to the next step without rebuilding
+    // the user's model catalog, while the LLM service still freezes it per call.
+    ctx.on('agent/request', async (_payload, next) => {
+        const request = await next();
+        return applyCodexRequestSettings(request, codexSettings.current());
+    });
+    if ((resolved.hostedWebSearch || resolved.remoteCompact) && typeof ctx.effect === 'function') {
+        const disposeHostedWebSearch = installHostedWebSearch();
+        ctx.effect(() => disposeHostedWebSearch, 'codex: Responses transport wrapper');
+    }
+    if (resolved.hostedWebSearch || resolved.remoteCompact) {
+        ctx.on('llm/stream', ((options, next) => {
+            if (resolved.remoteCompact && options.purpose === 'compaction' && isGptModel(options.model)) {
+                return remoteCompactStream(ctx, options, next);
+            }
+            if ((resolved.hostedWebSearch || resolved.remoteCompact)
+                && options.purpose === undefined
+                && isGptModel(options.model)) {
+                return hostedWebSearchStream(next);
+            }
+            return next();
+        }));
+    }
     ctx.systemPrompt.section({ name: 'codex:base', order: 10, text: CODEX_BASE_PROMPT });
     registerExecTools(ctx, resolved);
     registerPatchTool(ctx);

package/lib/types/patch.js

@@ -1,20 +1,20 @@
 /** Parser and line-oriented applicator for Codex's `apply_patch` language. */
 /** The grammar sent to providers that support OpenAI custom grammar tools. */
-export const APPLY_PATCH_GRAMMAR = String.raw `start: begin_patch hunk+ end_patch
-begin_patch: "*** Begin Patch" LF
-end_patch: "*** End Patch" LF?
-hunk: add_hunk | delete_hunk | update_hunk
-add_hunk: "*** Add File: " filename LF add_line+
-delete_hunk: "*** Delete File: " filename LF
-update_hunk: "*** Update File: " filename LF change_move? change?
-filename: /(.+)/
-add_line: "+" /(.*)/ LF -> line
-change_move: "*** Move to: " filename LF
-change: (change_context | change_line)+ eof_line?
-change_context: ("@@" | "@@ " /(.+)/) LF
-change_line: ("+" | "-" | " ") /(.*)/ LF
-eof_line: "*** End of File" LF
-%import common.LF
+export const APPLY_PATCH_GRAMMAR = String.raw `start: begin_patch hunk+ end_patch
+begin_patch: "*** Begin Patch" LF
+end_patch: "*** End Patch" LF?
+hunk: add_hunk | delete_hunk | update_hunk
+add_hunk: "*** Add File: " filename LF add_line+
+delete_hunk: "*** Delete File: " filename LF
+update_hunk: "*** Update File: " filename LF change_move? change?
+filename: /(.+)/
+add_line: "+" /(.*)/ LF -> line
+change_move: "*** Move to: " filename LF
+change: (change_context | change_line)+ eof_line?
+change_context: ("@@" | "@@ " /(.+)/) LF
+change_line: ("+" | "-" | " ") /(.*)/ LF
+eof_line: "*** End of File" LF
+%import common.LF
 `;
 function invalid(message) {
     throw new Error(`apply_patch: ${message}`);

package/lib/types/remote.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm';
+export interface RemoteCodexConfig {
+    hostedWebSearch: boolean;
+    remoteCompact: boolean;
+}
+interface JsonObject {
+    [key: string]: unknown;
+}
+/** Convert a generic DSH Responses tool list to the hosted Codex variant. */
+export declare function addHostedWebSearch(body: JsonObject): JsonObject;
+/** Replace the text placeholder written by dsh-compaction-basic with the native item. */
+export declare function replaceRemoteCompactions(body: JsonObject): JsonObject;
+/** Enable the transport patch for this Codex plugin scope only. */
+export declare function installHostedWebSearch(): () => void;
+/** Iterate an existing DSH stream with the hosted-request context installed. */
+export declare function hostedWebSearchStream(next: () => AsyncIterable<StreamChunk>): AsyncIterable<StreamChunk>;
+/** Remote-first compaction waterfall with the existing DSH path as fallback. */
+export declare function remoteCompactStream(ctx: Context, options: GenerateOptions, next: () => AsyncIterable<StreamChunk>): AsyncIterable<StreamChunk>;
+export {};
+//# sourceMappingURL=remote.d.ts.map

package/lib/types/remote.js

@@ -0,0 +1,324 @@
+import { credentialRef } from '@deepseek-ai/dsh-credentials';
+import { AsyncLocalStorage } from 'node:async_hooks';
+const SETTINGS_NAMESPACE = 'llm-pi-ai';
+const REMOTE_COMPACTION_OPEN = '<codex-remote-compaction>';
+const REMOTE_COMPACTION_CLOSE = '</codex-remote-compaction>';
+const HOSTED_REQUESTS = new AsyncLocalStorage();
+let hostedPatchUsers = 0;
+let hostedPatchRestore;
+function isGptModel(model) {
+    return typeof model === 'string' && /(?:^|\/)(?:gpt|chatgpt)(?:[-_.]|\d|$)/i.test(model);
+}
+function settingsOf(ctx) {
+    const provider = ctx.get('settings');
+    return provider?.get?.(SETTINGS_NAMESPACE);
+}
+function profileOf(ctx, provider) {
+    return settingsOf(ctx)?.providers?.[provider];
+}
+function supportsResponses(profile, provider) {
+    return profile?.api === 'openai-responses'
+        || profile?.api === 'openai-codex-responses'
+        || (profile?.api === undefined && provider === 'openai');
+}
+function responsesEndpoint(baseURL, suffix) {
+    return `${baseURL.replace(/\/+$/, '')}/${suffix}`;
+}
+function hasHeader(headers, name) {
+    return Object.keys(headers ?? {}).some(key => key.toLowerCase() === name.toLowerCase());
+}
+async function apiHeaders(ctx, profile) {
+    const headers = { ...profile.headers, 'content-type': 'application/json' };
+    if (profile.apiKeyEnv !== undefined && !hasHeader(headers, 'authorization')) {
+        const credentials = ctx.get('credentials');
+        const resolved = await credentials?.resolve(credentialRef(profile.apiKeyEnv));
+        if (resolved?.value === undefined)
+            return undefined;
+        headers.authorization = `Bearer ${resolved.value}`;
+    }
+    return headers;
+}
+function isResponsesRequest(url) {
+    try {
+        const path = new URL(url).pathname.replace(/\/+$/, '');
+        return path.endsWith('/responses');
+    }
+    catch {
+        return url.replace(/\/+$/, '').endsWith('/responses');
+    }
+}
+function isWebSearchTool(tool) {
+    if (typeof tool !== 'object' || tool === null)
+        return false;
+    const value = tool;
+    if (value.name === 'web_search')
+        return true;
+    const fn = value.function;
+    return typeof fn === 'object' && fn !== null && fn.name === 'web_search';
+}
+function hasWebSearchTool(body) {
+    return Array.isArray(body.tools) && body.tools.some(isWebSearchTool);
+}
+/** Convert a generic DSH Responses tool list to the hosted Codex variant. */
+export function addHostedWebSearch(body) {
+    const tools = Array.isArray(body.tools) ? body.tools.filter(tool => !isWebSearchTool(tool)) : [];
+    tools.push({ type: 'web_search', external_web_access: true });
+    return { ...replaceRemoteCompactions(body), tools };
+}
+/** Replace the text placeholder written by dsh-compaction-basic with the native item. */
+export function replaceRemoteCompactions(body) {
+    if (!Array.isArray(body.input))
+        return body;
+    const input = body.input.map(item => {
+        if (typeof item !== 'object' || item === null)
+            return item;
+        const value = item;
+        const content = Array.isArray(value.content) ? value.content : [];
+        const marker = content.find(part => (typeof part === 'object'
+            && part !== null
+            && typeof part.text === 'string'
+            && String(part.text).includes(REMOTE_COMPACTION_OPEN)));
+        if (marker === undefined)
+            return item;
+        const text = String(marker.text);
+        const start = text.indexOf(REMOTE_COMPACTION_OPEN) + REMOTE_COMPACTION_OPEN.length;
+        const end = text.indexOf(REMOTE_COMPACTION_CLOSE, start);
+        if (end < start)
+            return item;
+        return {
+            type: 'compaction',
+            encrypted_content: text.slice(start, end),
+        };
+    });
+    return { ...body, input };
+}
+function hasRemoteCompaction(body) {
+    if (!Array.isArray(body.input))
+        return false;
+    return body.input.some(item => {
+        if (typeof item !== 'object' || item === null)
+            return false;
+        const content = item.content;
+        return Array.isArray(content) && content.some(part => (typeof part === 'object'
+            && part !== null
+            && typeof part.text === 'string'
+            && String(part.text).includes(REMOTE_COMPACTION_OPEN)));
+    });
+}
+function canPatchBody(body) {
+    return isGptModel(body.model)
+        && (hasWebSearchTool(body) || hasRemoteCompaction(body));
+}
+/**
+ * Install a scoped fetch shim for pi-ai's already-built Responses request.
+ * The generic DSH adapter remains the owner of auth, streaming, replay, and
+ * attachments; this shim changes only the hosted-tool portion of the wire body.
+ */
+function installGlobalHostedWebSearchPatch() {
+    const original = globalThis.fetch;
+    const patched = async (input, init) => {
+        if (!HOSTED_REQUESTS.getStore())
+            return original(input, init);
+        const request = new Request(input, init);
+        if (!isResponsesRequest(request.url))
+            return original(input, init);
+        let body;
+        try {
+            body = JSON.parse(await request.clone().text());
+        }
+        catch {
+            return original(input, init);
+        }
+        if (!canPatchBody(body))
+            return original(input, init);
+        const fallbackRequest = request.clone();
+        const headers = new Headers(request.headers);
+        headers.delete('content-length');
+        const hostedRequest = new Request(request, {
+            body: JSON.stringify(hasWebSearchTool(body) ? addHostedWebSearch(body) : replaceRemoteCompactions(body)),
+            headers,
+        });
+        try {
+            const hostedResponse = await original(hostedRequest);
+            // A rejected hosted-tool request is retried with the untouched request so
+            // dsh-tool-web can still produce the normal local function-tool path.
+            if (!hostedResponse.ok)
+                return original(fallbackRequest);
+            return hostedResponse;
+        }
+        catch {
+            // Network and transport failures must have the same fallback behavior as
+            // an HTTP rejection; the local function-tool path remains available.
+            return original(fallbackRequest);
+        }
+    };
+    globalThis.fetch = patched;
+    return () => {
+        if (globalThis.fetch === patched)
+            globalThis.fetch = original;
+    };
+}
+/** Enable the transport patch for this Codex plugin scope only. */
+export function installHostedWebSearch() {
+    hostedPatchUsers += 1;
+    hostedPatchRestore ??= installGlobalHostedWebSearchPatch();
+    return () => {
+        hostedPatchUsers = Math.max(0, hostedPatchUsers - 1);
+        if (hostedPatchUsers === 0) {
+            hostedPatchRestore?.();
+            hostedPatchRestore = undefined;
+        }
+    };
+}
+/** Iterate an existing DSH stream with the hosted-request context installed. */
+export function hostedWebSearchStream(next) {
+    return (async function* () {
+        const iterator = next()[Symbol.asyncIterator]();
+        let completed = false;
+        try {
+            while (true) {
+                const item = await HOSTED_REQUESTS.run(true, () => iterator.next());
+                if (item.done) {
+                    completed = true;
+                    return;
+                }
+                yield item.value;
+            }
+        }
+        finally {
+            if (!completed)
+                await iterator.return?.();
+        }
+    })();
+}
+function textOf(message) {
+    return message.content
+        .filter(block => block.type === 'text')
+        .map(block => block.text)
+        .join('');
+}
+function responsesInput(messages) {
+    const result = [];
+    for (const message of messages) {
+        const text = textOf(message);
+        if (message.role === 'assistant') {
+            if (text.length > 0)
+                result.push({
+                    type: 'message',
+                    role: 'assistant',
+                    content: [{ type: 'output_text', text }],
+                });
+            for (const block of message.content) {
+                if (block.type === 'tool-call') {
+                    result.push({
+                        type: 'function_call',
+                        call_id: block.id,
+                        name: block.name,
+                        arguments: block.arguments,
+                    });
+                }
+            }
+            continue;
+        }
+        const role = message.role === 'system' ? 'developer' : 'user';
+        if (text.length > 0)
+            result.push({
+                type: 'message',
+                role,
+                content: [{ type: 'input_text', text }],
+            });
+        for (const block of message.content) {
+            if (block.type !== 'tool-result')
+                continue;
+            result.push({
+                type: 'function_call_output',
+                call_id: block.toolCallId,
+                output: block.content.filter(item => item.type === 'text').map(item => item.text).join(''),
+            });
+        }
+    }
+    return result;
+}
+function responsesTools(tools) {
+    if (tools === undefined)
+        return undefined;
+    return tools.filter(tool => tool.name !== 'web_search').map(tool => ({
+        type: 'function',
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+    }));
+}
+function compactBody(options) {
+    const tools = responsesTools(options.tools);
+    const body = {
+        model: options.model,
+        // dsh-compaction-basic appends an instruction for its local summarizer.
+        // The hosted compact endpoint owns summarization and must not receive it.
+        input: responsesInput(options.messages.slice(0, -1)),
+        ...options.system === undefined ? {} : { instructions: options.system },
+        ...tools === undefined ? {} : { tools },
+        ...options.maxTokens === undefined ? {} : { max_output_tokens: options.maxTokens },
+        ...options.reasoningEffort === undefined ? {} : { reasoning: { effort: options.reasoningEffort } },
+    };
+    const compacted = replaceRemoteCompactions(body);
+    return options.tools?.some(tool => tool.name === 'web_search') ? addHostedWebSearch(compacted) : compacted;
+}
+function compactText(body) {
+    const output = Array.isArray(body.output) ? body.output : [];
+    const text = [];
+    for (const item of output) {
+        if (typeof item !== 'object' || item === null)
+            continue;
+        const value = item;
+        if (typeof value.encrypted_content === 'string')
+            text.push(value.encrypted_content);
+    }
+    const encrypted = text.join('\n\n').trim();
+    return encrypted.length === 0 ? '' : `${REMOTE_COMPACTION_OPEN}${encrypted}${REMOTE_COMPACTION_CLOSE}`;
+}
+async function remoteCompact(ctx, options) {
+    const profile = profileOf(ctx, options.provider);
+    if (!supportsResponses(profile, options.provider) || profile?.baseURL === undefined) {
+        throw new Error('Codex remote compaction requires an OpenAI Responses provider with baseURL');
+    }
+    const headers = await apiHeaders(ctx, profile);
+    if (headers === undefined)
+        throw new Error('Codex remote compaction has no configured API key');
+    const response = await fetch(responsesEndpoint(profile.baseURL, 'responses/compact'), {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(compactBody(options)),
+        ...options.signal === undefined ? {} : { signal: options.signal },
+    });
+    if (!response.ok)
+        throw new Error(`remote compaction returned HTTP ${response.status}`);
+    const body = await response.json();
+    const text = compactText(body);
+    if (text.length === 0)
+        throw new Error('remote compaction returned no compaction text');
+    return text;
+}
+/** Remote-first compaction waterfall with the existing DSH path as fallback. */
+export function remoteCompactStream(ctx, options, next) {
+    return (async function* () {
+        try {
+            const text = await remoteCompact(ctx, options);
+            yield { type: 'block-start', index: 0, blockType: 'text' };
+            yield { type: 'text-delta', index: 0, text };
+            yield { type: 'block-end', index: 0, block: { type: 'text', text } };
+            yield { type: 'usage', usage: { inputTokens: 0, outputTokens: 0 } };
+            yield { type: 'finish', reason: { kind: 'stop' } };
+        }
+        catch (error) {
+            if (options.signal?.aborted)
+                throw error;
+            ctx.logger.warn('codex: remote compaction failed; using dsh-compaction-basic fallback');
+            ctx.logger.warn(error);
+            // The local fallback still replays the marker through a later GPT
+            // Responses request, so it needs the same scoped wire context.
+            yield* hostedWebSearchStream(next);
+        }
+    })();
+}
+//# sourceMappingURL=remote.js.map