let turnCompletionLastActivityAt = Date.now();

let turnCompletionLastActivityReason = "startup";

let turnCompletionLastActivityDetails: Record<string, unknown> | undefined;

let turnAttemptLastProgressAt = Date.now();

let turnAttemptLastProgressReason = "startup";

let turnAttemptLastProgressDetails: Record<string, unknown> | undefined;

let activeAppServerTurnRequests = 0;

const activeOpenClawDynamicToolCallIds = new Set<string>();

const activeTurnItemIds = new Set<string>();

) {

return;

}

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

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

if (idleMs < turnAttemptIdleTimeoutMs) {

scheduleTurnAttemptIdleWatch();

return;

turnId,

idleMs,

timeoutMs: turnAttemptIdleTimeoutMs,

lastActivityReason: turnCompletionLastActivityReason,

...turnCompletionLastActivityDetails,

lastActivityReason: turnAttemptLastProgressReason,

...turnAttemptLastProgressDetails,

});

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

threadId: thread.threadId,

turnId,

idleMs,

timeoutMs: turnAttemptIdleTimeoutMs,

lastActivityReason: turnCompletionLastActivityReason,

...turnCompletionLastActivityDetails,

lastActivityReason: turnAttemptLastProgressReason,

...turnAttemptLastProgressDetails,

});

runAbortController.abort("turn_progress_idle_timeout");

};

) {

return;

}

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

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

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

turnAttemptIdleTimer = setTimeout(fireTurnAttemptIdleTimeout, delayMs);

turnAttemptIdleTimer.unref?.();

turnTerminalIdleTimer.unref?.();

}

function scheduleTurnProgressWatches() {

scheduleTurnAttemptIdleWatch();

scheduleTurnCompletionIdleWatch();

scheduleTurnTerminalIdleWatch();

}

const touchTurnCompletionActivity = (

reason: string,

options?: { arm?: boolean; details?: Record<string, unknown> },

options?: { arm?: boolean; details?: Record<string, unknown>; attemptProgress?: boolean },

) => {

turnCompletionLastActivityAt = Date.now();

turnCompletionLastActivityReason = reason;

turnCompletionLastActivityDetails = options?.details;

if (options?.attemptProgress) {

turnAttemptLastProgressAt = turnCompletionLastActivityAt;

turnAttemptLastProgressReason = reason;

turnAttemptLastProgressDetails = options.details;

}

emitTrustedDiagnosticEvent({

type: "run.progress",

runId: params.runId,

turnCompletionIdleWatchArmed = true;

turnCompletionIdleWatchPinnedByTerminalError = false;

}

scheduleTurnAttemptIdleWatch();

scheduleTurnCompletionIdleWatch();

scheduleTurnTerminalIdleWatch();

scheduleTurnProgressWatches();

};

const disarmTurnCompletionIdleWatch = () => {

if (isCurrentTurnNotification) {

touchTurnCompletionActivity(`notification:${notification.method}`, {

details: describeNotificationActivity(notification),

attemptProgress: true,

});

reportCodexExecutionNotification(notification);

}

activeAppServerTurnRequests += 1;

clearTurnCompletionIdleTimer();

disarmTurnAssistantCompletionIdleWatch();

touchTurnCompletionActivity(`request:${request.method}`);

let armCompletionWatchOnResponse = false;

let requestCountsAsTurnActivity = false;

try {

if (request.method === "account/chatgptAuthTokens/refresh") {

return refreshCodexAppServerAuthTokens({

}

if (request.method === "mcpServer/elicitation/request") {

armCompletionWatchOnResponse = true;

requestCountsAsTurnActivity = true;

return handleCodexAppServerElicitationRequest({

requestParams: request.params,

paramsForRun: params,

}

if (request.method === "item/tool/requestUserInput") {

armCompletionWatchOnResponse = true;

requestCountsAsTurnActivity = true;

return userInputBridge?.handleRequest({

id: request.id,

params: request.params,

if (request.method !== "item/tool/call") {

if (isCodexAppServerApprovalRequest(request.method)) {

armCompletionWatchOnResponse = true;

requestCountsAsTurnActivity = true;

return handleApprovalRequest({

method: request.method,

params: request.params,

return undefined;

}

armCompletionWatchOnResponse = true;

requestCountsAsTurnActivity = true;

turnCrossedToolHandoff = true;

activeOpenClawDynamicToolCallIds.add(call.callId);

trajectoryRecorder?.recordEvent("tool.call", {

return response as JsonValue;

} finally {

activeAppServerTurnRequests = Math.max(0, activeAppServerTurnRequests - 1);

touchTurnCompletionActivity(`request:${request.method}:response`, {

arm: armCompletionWatchOnResponse,

});

if (requestCountsAsTurnActivity) {

touchTurnCompletionActivity(`request:${request.method}:response`, {

arm: armCompletionWatchOnResponse,

attemptProgress: true,

});

} else {

scheduleTurnProgressWatches();

}

}

});

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

turnAttemptIdleWatchArmed = true;

turnTerminalIdleWatchArmed = true;

touchTurnCompletionActivity("turn:start", { arm: true });

touchTurnCompletionActivity("turn:start", { arm: true, attemptProgress: true });

const abortListener = () => {

const shouldRetireClient = timedOut;