const CODEX_DYNAMIC_TOOL_TIMEOUT_MS = 30_000;

const CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS = 60_000;

const CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS = 30 * 60_000;

const CODEX_STEER_ALL_DEBOUNCE_MS = 500;

type OpenClawCodingToolsOptions = NonNullable<

hookTimeoutSec?: number;

};

turnCompletionIdleTimeoutMs?: number;

turnTerminalIdleTimeoutMs?: number;

} = {},

): Promise<EmbeddedRunAttemptResult> {

const attemptStartedAt = Date.now();

const turnCompletionIdleTimeoutMs = resolveCodexTurnCompletionIdleTimeoutMs(

options.turnCompletionIdleTimeoutMs,

);

const turnTerminalIdleTimeoutMs = resolveCodexTurnTerminalIdleTimeoutMs(

options.turnTerminalIdleTimeoutMs,

);

let turnCompletionIdleTimer: ReturnType<typeof setTimeout> | undefined;

let turnCompletionIdleWatchArmed = false;

let turnTerminalIdleTimer: ReturnType<typeof setTimeout> | undefined;

let turnTerminalIdleWatchArmed = false;

let turnCompletionLastActivityAt = Date.now();

let turnCompletionLastActivityReason = "startup";

let activeAppServerTurnRequests = 0;

}

};

const clearTurnTerminalIdleTimer = () => {

if (turnTerminalIdleTimer) {

clearTimeout(turnTerminalIdleTimer);

turnTerminalIdleTimer = undefined;

}

};

const fireTurnCompletionIdleTimeout = () => {

if (

completed ||

runAbortController.abort("turn_completion_idle_timeout");

};

const fireTurnTerminalIdleTimeout = () => {

if (

completed ||

runAbortController.signal.aborted ||

!turnTerminalIdleWatchArmed ||

activeAppServerTurnRequests > 0

) {

return;

}

const idleMs = Math.max(0, Date.now() - turnCompletionLastActivityAt);

if (idleMs < turnTerminalIdleTimeoutMs) {

scheduleTurnTerminalIdleWatch();

return;

}

timedOut = true;

turnCompletionIdleTimedOut = true;

turnCompletionIdleTimeoutMessage =

"codex app-server turn idle timed out waiting for turn/completed";

projector?.markTimedOut();

trajectoryRecorder?.recordEvent("turn.terminal_idle_timeout", {

threadId: thread.threadId,

turnId,

idleMs,

timeoutMs: turnTerminalIdleTimeoutMs,

lastActivityReason: turnCompletionLastActivityReason,

});

embeddedAgentLog.warn("codex app-server turn idle timed out waiting for terminal event", {

threadId: thread.threadId,

turnId,

idleMs,

timeoutMs: turnTerminalIdleTimeoutMs,

lastActivityReason: turnCompletionLastActivityReason,

});

runAbortController.abort("turn_terminal_idle_timeout");

};

function scheduleTurnCompletionIdleWatch() {

clearTurnCompletionIdleTimer();

if (

turnCompletionIdleTimer.unref?.();

}

function scheduleTurnTerminalIdleWatch() {

clearTurnTerminalIdleTimer();

if (

completed ||

runAbortController.signal.aborted ||

!turnTerminalIdleWatchArmed ||

activeAppServerTurnRequests > 0

) {

return;

}

const elapsedMs = Math.max(0, Date.now() - turnCompletionLastActivityAt);

const delayMs = Math.max(1, turnTerminalIdleTimeoutMs - elapsedMs);

turnTerminalIdleTimer = setTimeout(fireTurnTerminalIdleTimeout, delayMs);

turnTerminalIdleTimer.unref?.();

}

const touchTurnCompletionActivity = (reason: string, options?: { arm?: boolean }) => {

turnCompletionLastActivityAt = Date.now();

turnCompletionLastActivityReason = reason;

if (options?.arm) {

turnCompletionIdleWatchArmed = true;

}

scheduleTurnCompletionIdleWatch();

scheduleTurnTerminalIdleWatch();

};

const emitLifecycleStart = () => {

}

completed = true;

clearTurnCompletionIdleTimer();

clearTurnTerminalIdleTimer();

resolveCompletion?.();

}

}

abort: () => runAbortController.abort("aborted"),

};

setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey);

turnTerminalIdleWatchArmed = true;

touchTurnCompletionActivity("turn:start");

const timeout = setTimeout(

userInputBridge?.cancelPending();

clearTimeout(timeout);

clearTurnCompletionIdleTimer();

clearTurnTerminalIdleTimer();

notificationCleanup();

requestCleanup();

nativeHookRelay?.unregister();

return Math.max(1, Math.floor(value));

}

function resolveCodexTurnTerminalIdleTimeoutMs(value: number | undefined): number {

if (value === undefined) {

return CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS;

}

if (!Number.isFinite(value)) {

return CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS;

}

return Math.max(1, Math.floor(value));

}

function readDynamicToolCallParams(

value: JsonValue | undefined,

): CodexDynamicToolCallParams | undefined {

export const __testing = {

CODEX_DYNAMIC_TOOL_TIMEOUT_MS,

CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS,

CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS,

buildCodexNativeHookRelayId,

filterToolsForVisionInputs,

handleDynamicToolCallWithTimeout,