@deepseek-harness-tui/dsh-tui 0.13.0 → 0.14.1

package/lib/types/backends/codex/session/input.js

@@ -0,0 +1,294 @@
+import { t } from '../../../i18n.js';
+import { errorText, rec, str } from '../narrow.js';
+import { CLIENT } from '../protocol/index.js';
+import { codexImageInputs } from './images.js';
+/** The model-facing input of a submission: every text block as its own
+ *  text input (the first is what the user typed), in block order. */
+export function userInputOf(input) {
+    const blocks = input.blocks ?? [{ type: 'text', text: input.text }];
+    const out = [];
+    for (const block of blocks) {
+        if (block.type === 'text' && typeof block.text === 'string' && block.text !== '')
+            out.push({ type: 'text', text: block.text, text_elements: [] });
+    }
+    if (out.length === 0)
+        out.push({ type: 'text', text: input.text, text_elements: [] });
+    return out;
+}
+export function createInputQueue(deps) {
+    /** The running turn (from its start answer or `turn/started`). */
+    let activeTurnId;
+    /** A `turn/start` in flight: resolves with the turn id (undefined = it failed). */
+    let starting;
+    /** Inputs not sent yet (the client follow-up queue). */
+    let queue = [];
+    /** Sent with `turn/start`, not yet claimed by their user message. */
+    const started = new Map();
+    /** Sent with `turn/steer`, not yet claimed. */
+    const steered = new Map();
+    /** Why the running turn is being cancelled (decides the fate of steers). */
+    let cancelCause;
+    let forceTimer;
+    let steerFallbackSaid = false;
+    /** The connection is down: nothing is sent until it is back. */
+    let offline = false;
+    /** The connection is gone FOR GOOD: submits fail fast instead of parking. */
+    let dead = false;
+    const snapshot = () => [
+        ...[...steered.values()].map(entry => ({ id: entry.id, text: entry.text, placement: 'steer' })),
+        ...queue.map(entry => ({ id: entry.id, text: entry.text, placement: entry.placement })),
+    ];
+    const pendingEvent = (change) => ({ type: 'pending.changed', items: snapshot(), ...change });
+    const clearForceTimer = () => {
+        if (forceTimer === undefined)
+            return;
+        deps.clock.clearTimeout(forceTimer);
+        forceTimer = undefined;
+    };
+    /** Send one input as a new turn. */
+    const startTurn = async (entry) => {
+        started.set(entry.id, entry);
+        let resolveStart;
+        starting = new Promise(resolve => { resolveStart = resolve; });
+        const overrides = deps.overrides();
+        try {
+            const answer = rec(await deps.call(CLIENT.turnStart, {
+                threadId: deps.threadId,
+                clientUserMessageId: entry.id,
+                input: entry.input,
+                ...overrides,
+            }));
+            const turnId = str(rec(answer?.turn)?.id);
+            if (turnId !== undefined && activeTurnId === undefined)
+                activeTurnId = turnId;
+            resolveStart(turnId ?? activeTurnId);
+            return { accepted: true };
+        }
+        catch (error) {
+            deps.startFailed?.(error, overrides);
+            started.delete(entry.id);
+            resolveStart(undefined);
+            const reason = t('codex-turn-start-failed', { err: errorText(error) });
+            deps.debug(`codex: turn/start failed (${errorText(error)})`);
+            deps.emit([pendingEvent({ discarded: [entry.id] })]);
+            return { accepted: false, reason };
+        }
+        finally {
+            starting = undefined;
+        }
+    };
+    /** Start the next queued input when the thread is idle. */
+    const drain = () => {
+        if (offline || deps.closed() || activeTurnId !== undefined || starting !== undefined)
+            return;
+        const next = queue.shift();
+        if (next === undefined)
+            return;
+        void startTurn(next).then(result => {
+            if (!result.accepted)
+                deps.emit([{ type: 'notice', level: 'error', text: result.reason ?? t('codex-turn-start-failed', { err: '' }) }]);
+            else
+                drain();
+        });
+    };
+    /** Join the running turn, or fall back to the queue. */
+    const steer = async (entry) => {
+        const turnId = activeTurnId ?? await starting;
+        if (turnId === undefined) {
+            queue.push(entry);
+            drain();
+            return { accepted: true };
+        }
+        steered.set(entry.id, entry);
+        try {
+            await deps.call(CLIENT.turnSteer, { threadId: deps.threadId, expectedTurnId: turnId, clientUserMessageId: entry.id, input: entry.input });
+            return { accepted: true };
+        }
+        catch (error) {
+            steered.delete(entry.id);
+            deps.debug(`codex: turn/steer refused (${errorText(error)}); queued as a follow-up`);
+            if (deps.closed())
+                throw error;
+            queue.push(entry);
+            if (!steerFallbackSaid) {
+                steerFallbackSaid = true;
+                deps.emit([{ type: 'notice', level: 'info', text: t('codex-steer-fallback') }]);
+            }
+            drain();
+            return { accepted: true };
+        }
+    };
+    const interrupt = async () => {
+        const turnId = activeTurnId ?? await starting;
+        if (turnId === undefined)
+            return true;
+        try {
+            await deps.call(CLIENT.turnInterrupt, { threadId: deps.threadId, turnId });
+        }
+        catch (error) {
+            deps.debug(`codex: turn/interrupt failed (${errorText(error)})`);
+            return false;
+        }
+        if (forceTimer === undefined) {
+            forceTimer = deps.clock.setTimeout(() => {
+                forceTimer = undefined;
+                if (activeTurnId !== turnId)
+                    return;
+                deps.emit([{ type: 'notice', level: 'warning', text: t('codex-cancel-forced') }]);
+                deps.forceClose();
+                onTurnCompleted(turnId, true);
+            }, deps.forceSettleMs);
+        }
+        return true;
+    };
+    /** The turn ended: settle unclaimed inputs, then start the next queued one. */
+    const onTurnCompleted = (turnId, interrupted) => {
+        if (turnId !== undefined && activeTurnId !== undefined && turnId !== activeTurnId)
+            return;
+        clearForceTimer();
+        activeTurnId = undefined;
+        const cause = cancelCause;
+        cancelCause = undefined;
+        const events = [];
+        // A turn/start whose user message never showed: it did not run.
+        if (started.size > 0) {
+            const ids = [...started.keys()];
+            started.clear();
+            events.push(pendingEvent({ discarded: ids }));
+        }
+        if (steered.size > 0) {
+            const leftover = [...steered.values()];
+            steered.clear();
+            if (!interrupted) {
+                // A completed turn records the input it had not taken yet.
+                events.push(pendingEvent({ claimed: leftover.map(entry => entry.id) }));
+            }
+            else if (cause === 'interrupt' || cause === 'switch' || cause === 'dispose') {
+                events.push(pendingEvent({ discarded: leftover.map(entry => entry.id) }));
+            }
+            else {
+                // Dropped by the interrupt (V6) but still wanted: run them next,
+                // after an input sent with `now` (the reason for the interrupt).
+                const urgent = queue.filter(entry => entry.urgent === true);
+                const rest = queue.filter(entry => entry.urgent !== true);
+                queue = [...urgent, ...leftover.map(entry => ({ ...entry, placement: 'followup' })), ...rest];
+            }
+        }
+        if (events.length > 0)
+            deps.emit(events);
+        drain();
+    };
+    return {
+        get activeTurnId() { return activeTurnId; },
+        /** Whether a turn runs or is being started. */
+        busy() { return activeTurnId !== undefined || starting !== undefined; },
+        async submit(input, placement, wireInput) {
+            if (deps.closed())
+                throw new Error(t('codex-session-closed'));
+            if (dead)
+                throw new Error(t('codex-connection-dead'));
+            if ((input.images ?? []).length === 0 && (input.blocks ?? []).some(block => block.type === 'image'))
+                throw new Error(t('codex-image-unreadable', { name: input.clientMessageId }));
+            const pictureInputs = await codexImageInputs(input.images ?? []);
+            if (deps.closed())
+                throw new Error(t('codex-session-closed'));
+            const entry = { id: input.clientMessageId, text: input.text, input: [...(wireInput ?? userInputOf(input)), ...pictureInputs], placement: placement === 'steer' ? 'steer' : 'followup' };
+            if (offline) {
+                queue.push(entry);
+                return { accepted: true };
+            }
+            if (activeTurnId === undefined && starting === undefined)
+                return startTurn(entry);
+            switch (placement) {
+                case 'steer':
+                    return steer(entry);
+                case 'now':
+                    queue.unshift({ ...entry, urgent: true });
+                    void interrupt();
+                    return { accepted: true };
+                default:
+                    queue.push(entry);
+                    return { accepted: true };
+            }
+        },
+        async cancel(cause) {
+            const covered = [...steered.keys(), ...queue.map(entry => entry.id)];
+            const busy = activeTurnId !== undefined || starting !== undefined;
+            if (cause !== 'user') {
+                const dropped = queue.map(entry => entry.id);
+                queue = [];
+                if (dropped.length > 0)
+                    deps.emit([pendingEvent({ discarded: dropped })]);
+            }
+            if (busy) {
+                cancelCause = cause;
+                const ok = await interrupt();
+                if (!ok) {
+                    // The turn goes on: its end must not be read as this cancel's.
+                    cancelCause = undefined;
+                    return { stillQueued: cause === 'user' ? covered : [...steered.keys()], outcome: 'failed' };
+                }
+            }
+            return cause === 'user'
+                ? { stillQueued: [...steered.keys(), ...queue.map(entry => entry.id)], outcome: 'confirmed' }
+                : { stillQueued: [], outcome: 'confirmed' };
+        },
+        /** Pull a queued input back before it is sent. */
+        remove(id) {
+            const index = queue.findIndex(entry => entry.id === id);
+            if (index === -1)
+                return false;
+            queue.splice(index, 1);
+            return true;
+        },
+        /** A user message carried this client id back: the input ran. */
+        claim(clientId) {
+            if (!started.delete(clientId) && !steered.delete(clientId))
+                return undefined;
+            return pendingEvent({ claimed: [clientId] });
+        },
+        onTurnStarted(turnId) {
+            activeTurnId = turnId;
+        },
+        onTurnCompleted,
+        /** Re-queue a rejection's reason as the next turn (D10). */
+        enqueueFollowup(id, text) {
+            queue.push({ id, text, input: [{ type: 'text', text, text_elements: [] }], placement: 'followup' });
+            drain();
+        },
+        /** The connection dropped: the running turn is gone, the queue stays. */
+        connectionLost() {
+            offline = true;
+            clearForceTimer();
+            activeTurnId = undefined;
+            const lost = [...started.keys(), ...steered.keys()];
+            started.clear();
+            steered.clear();
+            return lost.length === 0 ? [] : [pendingEvent({ discarded: lost })];
+        },
+        connectionRestored() {
+            offline = false;
+            dead = false;
+            drain();
+        },
+        /** The connection is gone for good: the parked queue is discarded (their
+         *  pending rows say so) and later submits fail fast instead of parking
+         *  forever behind an offline flag nothing will ever clear. */
+        permanentLoss() {
+            offline = false;
+            dead = true;
+            const dropped = queue.map(entry => entry.id);
+            queue = [];
+            return dropped.length === 0 ? [] : [pendingEvent({ discarded: dropped })];
+        },
+        /** Dispose: forget everything, stop the timer. */
+        close() {
+            clearForceTimer();
+            queue = [];
+            started.clear();
+            steered.clear();
+        },
+        /** Interrupt the running turn (best-effort, dispose path). */
+        interrupt,
+    };
+}

package/lib/types/backends/codex/session/plan-review.d.ts

@@ -0,0 +1,19 @@
+/** Client-side Plan implementation confirmation (official Codex TUI flow). */
+import type { QuestionAnswers } from '../../../agent/capabilities.js';
+import type { AgentEvent } from '../../../agent/events.js';
+import { PLAN_IMPLEMENTATION_PROMPT } from './prompts.js';
+interface PlanReviewDeps {
+    emit(events: readonly AgentEvent[]): void;
+    implement(): Promise<void>;
+    clearContext(plan: string): Promise<void>;
+    followup(text: string): Promise<void>;
+}
+export declare function createPlanReview(deps: PlanReviewDeps): {
+    offer(turnId: string, plan: string): void;
+    owns(id: string): boolean;
+    respond(id: string, answers: QuestionAnswers): void;
+    cancel(id: string): void;
+    withdraw: () => void;
+};
+export { PLAN_IMPLEMENTATION_PROMPT };
+//# sourceMappingURL=plan-review.d.ts.map

package/lib/types/backends/codex/session/plan-review.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-review.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/session/plan-review.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAG1D,OAAO,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAA;AAEzD,UAAU,cAAc;IACtB,IAAI,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI,CAAA;IACzC,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACtC;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc;kBASnC,MAAM,QAAQ,MAAM,GAAG,IAAI;aAchC,MAAM,GAAG,OAAO;gBACb,MAAM,WAAW,eAAe,GAAG,IAAI;eAWxC,MAAM,GAAG,IAAI;oBAjCL,IAAI;EAoC1B;AAED,OAAO,EAAE,0BAA0B,EAAE,CAAA"}

package/lib/types/backends/codex/session/plan-review.js

@@ -0,0 +1,48 @@
+import { t } from '../../../i18n.js';
+import { errorText } from '../narrow.js';
+import { PLAN_IMPLEMENTATION_PROMPT } from './prompts.js';
+export function createPlanReview(deps) {
+    let pending;
+    const withdraw = () => {
+        if (pending === undefined)
+            return;
+        const id = pending.id;
+        pending = undefined;
+        deps.emit([{ type: 'question.settled', requestId: id }]);
+    };
+    return {
+        offer(turnId, plan) {
+            withdraw();
+            if (plan.trim() === '')
+                return;
+            const yes = t('codex-plan-yes');
+            const clear = t('codex-plan-clear');
+            const stay = t('codex-plan-stay');
+            const id = `codex-plan:${turnId}`;
+            pending = { id, plan, yes, clear, stay };
+            deps.emit([{ type: 'question.request', request: { requestId: id, questions: [{
+                                question: t('codex-plan-implement'), header: t('codex-mode-plan'), detail: plan,
+                                options: [{ label: yes }, { label: clear }, { label: stay }],
+                                intent: { kind: 'plan-review', approve: yes, approveAlso: [clear], decline: stay },
+                            }] } }]);
+        },
+        owns(id) { return pending?.id === id; },
+        respond(id, answers) {
+            if (pending?.id !== id)
+                return;
+            const current = pending;
+            const answer = answers.answers[0];
+            withdraw();
+            const selected = answer?.selected[0];
+            const action = selected === current.clear ? () => deps.clearContext(current.plan)
+                : selected === current.yes ? () => deps.implement()
+                    : answer?.custom?.trim() ? () => deps.followup(answer.custom.trim()) : undefined;
+            if (action !== undefined)
+                void action().catch(error => deps.emit([{ type: 'notice', level: 'error', key: 'codex-plan-action', text: t('codex-plan-action-failed', { error: errorText(error) }) }]));
+        },
+        cancel(id) { if (pending?.id === id)
+            withdraw(); },
+        withdraw,
+    };
+}
+export { PLAN_IMPLEMENTATION_PROMPT };

package/lib/types/backends/codex/session/prompts.d.ts

@@ -0,0 +1,7 @@
+/** Official Codex prompts, rust-v0.160.1, Apache-2.0.
+ * Sources: codex-rs/tui/assets/prompt_for_init_command.md and
+ * codex-rs/tui/src/chatwidget/plan_implementation.rs (openai/codex). */
+export declare const CODEX_INIT_PROMPT = "Generate a file named AGENTS.md that serves as a contributor guide for this repository.\nBefore writing, check whether AGENTS.md already exists in the current working directory. If it does, do not overwrite or modify it.\nYour goal is to produce a clear, concise, and well-structured document with descriptive headings and actionable explanations for each section.\nFollow the outline below, but adapt as needed \u2014 add sections if relevant, and omit those that do not apply to this project.\n\nDocument Requirements\n\n- Title the document \"Repository Guidelines\".\n- Use Markdown headings (#, ##, etc.) for structure.\n- Keep the document concise. 200-400 words is optimal.\n- Keep explanations short, direct, and specific to this repository.\n- Provide examples where helpful (commands, directory paths, naming patterns).\n- Maintain a professional, instructional tone.\n\nRecommended Sections\n\nProject Structure & Module Organization\n\n- Outline the project structure, including where the source code, tests, and assets are located.\n\nBuild, Test, and Development Commands\n\n- List key commands for building, testing, and running locally (e.g., npm test, make build).\n- Briefly explain what each command does.\n\nCoding Style & Naming Conventions\n\n- Specify indentation rules, language-specific style preferences, and naming patterns.\n- Include any formatting or linting tools used.\n\nTesting Guidelines\n\n- Identify testing frameworks and coverage requirements.\n- State test naming conventions and how to run tests.\n\nCommit & Pull Request Guidelines\n\n- Summarize commit message conventions found in the project\u2019s Git history.\n- Outline pull request requirements (descriptions, linked issues, screenshots, etc.).\n\n(Optional) Add other sections if relevant, such as Security & Configuration Tips, Architecture Overview, or Agent-Specific Instructions.\n";
+export declare const PLAN_IMPLEMENTATION_PROMPT = "Implement the plan.";
+export declare const PLAN_CLEAR_CONTEXT_PREFIX = "A previous agent produced the plan below to accomplish the user's task. Implement the plan in a fresh context. Treat the plan as the source of user intent, re-read files as needed, and carry the work through implementation and verification.";
+//# sourceMappingURL=prompts.d.ts.map

package/lib/types/backends/codex/session/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/session/prompts.ts"],"names":[],"mappings":"AAAA;;wEAEwE;AACxE,eAAO,MAAM,iBAAiB,k2DAyC7B,CAAA;AAED,eAAO,MAAM,0BAA0B,wBAAwB,CAAA;AAC/D,eAAO,MAAM,yBAAyB,qPAAqP,CAAA"}

package/lib/types/backends/codex/session/prompts.js

@@ -0,0 +1,47 @@
+/** Official Codex prompts, rust-v0.160.1, Apache-2.0.
+ * Sources: codex-rs/tui/assets/prompt_for_init_command.md and
+ * codex-rs/tui/src/chatwidget/plan_implementation.rs (openai/codex). */
+export const CODEX_INIT_PROMPT = `Generate a file named AGENTS.md that serves as a contributor guide for this repository.
+Before writing, check whether AGENTS.md already exists in the current working directory. If it does, do not overwrite or modify it.
+Your goal is to produce a clear, concise, and well-structured document with descriptive headings and actionable explanations for each section.
+Follow the outline below, but adapt as needed — add sections if relevant, and omit those that do not apply to this project.
+
+Document Requirements
+
+- Title the document "Repository Guidelines".
+- Use Markdown headings (#, ##, etc.) for structure.
+- Keep the document concise. 200-400 words is optimal.
+- Keep explanations short, direct, and specific to this repository.
+- Provide examples where helpful (commands, directory paths, naming patterns).
+- Maintain a professional, instructional tone.
+
+Recommended Sections
+
+Project Structure & Module Organization
+
+- Outline the project structure, including where the source code, tests, and assets are located.
+
+Build, Test, and Development Commands
+
+- List key commands for building, testing, and running locally (e.g., npm test, make build).
+- Briefly explain what each command does.
+
+Coding Style & Naming Conventions
+
+- Specify indentation rules, language-specific style preferences, and naming patterns.
+- Include any formatting or linting tools used.
+
+Testing Guidelines
+
+- Identify testing frameworks and coverage requirements.
+- State test naming conventions and how to run tests.
+
+Commit & Pull Request Guidelines
+
+- Summarize commit message conventions found in the project’s Git history.
+- Outline pull request requirements (descriptions, linked issues, screenshots, etc.).
+
+(Optional) Add other sections if relevant, such as Security & Configuration Tips, Architecture Overview, or Agent-Specific Instructions.
+`;
+export const PLAN_IMPLEMENTATION_PROMPT = 'Implement the plan.';
+export const PLAN_CLEAR_CONTEXT_PREFIX = `A previous agent produced the plan below to accomplish the user's task. Implement the plan in a fresh context. Treat the plan as the source of user intent, re-read files as needed, and carry the work through implementation and verification.`;

package/lib/types/backends/codex/session/session.d.ts

@@ -0,0 +1,12 @@
+import type { AgentSession } from '../../../agent/session.js';
+import { type Rec } from '../narrow.js';
+import type { CodexSessionDeps, OpenedThread } from './state.js';
+/** The thread facts of a `thread/start` / `thread/resume` answer. */
+export declare function openedThread(response: Rec, fallbackCwd: string): OpenedThread;
+/** A JSON-RPC failure of the open as a user-facing sentence (C0 V15). */
+export declare function openFailureText(error: unknown, threadId: string | undefined): string;
+/** Open (create or resume) a thread and wrap it as a session. Throws a
+ *  user-facing sentence when the thread cannot be opened; the hub retain is
+ *  released then. */
+export declare function openCodexSession(deps: CodexSessionDeps): Promise<AgentSession>;
+//# sourceMappingURL=session.d.ts.map

package/lib/types/backends/codex/session/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/session/session.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAc,YAAY,EAAoD,MAAM,2BAA2B,CAAA;AAI3H,OAAO,EAAuC,KAAK,GAAG,EAAE,MAAM,cAAc,CAAA;AAwB5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAOhE,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,GAAG,YAAY,CAkB7E;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAKpF;AAED;;qBAEqB;AACrB,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAwrBpF"}