formatPluginConfigIssue,

mapPluginConfigIssues,

} from "openclaw/plugin-sdk/extension-shared";

import { MAX_TIMER_TIMEOUT_SECONDS } from "openclaw/plugin-sdk/number-runtime";

import { z } from "zod";

type OpenShellPluginConfig = {

const DEFAULT_REMOTE_WORKSPACE_DIR = "/sandbox";

const DEFAULT_REMOTE_AGENT_WORKSPACE_DIR = "/agent";

const DEFAULT_TIMEOUT_MS = 120_000;

const MAX_OPEN_SHELL_TIMEOUT_SECONDS = 2_147_000;

const OPEN_SHELL_MANAGED_REMOTE_ROOTS = [

DEFAULT_REMOTE_WORKSPACE_DIR,

DEFAULT_REMOTE_AGENT_WORKSPACE_DIR,

).optional(),

timeoutSeconds: z

.number({

error: `timeoutSeconds must be a number between 1 and ${MAX_OPEN_SHELL_TIMEOUT_SECONDS}`,

error: `timeoutSeconds must be a number between 1 and ${MAX_TIMER_TIMEOUT_SECONDS}`,

})

.min(1, { error: "timeoutSeconds must be a number >= 1" })

.max(MAX_OPEN_SHELL_TIMEOUT_SECONDS, {

error: `timeoutSeconds must be a number <= ${MAX_OPEN_SHELL_TIMEOUT_SECONDS}`,

.max(MAX_TIMER_TIMEOUT_SECONDS, {

error: `timeoutSeconds must be a number <= ${MAX_TIMER_TIMEOUT_SECONDS}`,

})

.optional(),

});

import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";

import { describe, expect, it } from "vitest";

import {

DEFAULT_RESPONSE_TIMEOUT_MS,

resolveResponseTimeoutMs,

} from "./response-timeout.js";

import { DEFAULT_RESPONSE_TIMEOUT_MS, resolveResponseTimeoutMs } from "./response-timeout.js";

describe("resolveResponseTimeoutMs", () => {

it("falls back to the historical 5-minute floor when no timeouts configured", () => {

});

it("honors longer agents.defaults.timeoutSeconds", () => {

expect(

resolveResponseTimeoutMs({ agents: { defaults: { timeoutSeconds: 900 } } }),

).toBe(900_000);

expect(resolveResponseTimeoutMs({ agents: { defaults: { timeoutSeconds: 900 } } })).toBe(

900_000,

);

});

it("ignores agents.defaults.timeoutSeconds shorter than the historical floor", () => {

// Issue #85267: a configured 60s agent timeout must not undercut the

// historical 5-minute watchdog floor for previously-working setups.

expect(

resolveResponseTimeoutMs({ agents: { defaults: { timeoutSeconds: 60 } } }),

).toBe(DEFAULT_RESPONSE_TIMEOUT_MS);

expect(resolveResponseTimeoutMs({ agents: { defaults: { timeoutSeconds: 60 } } })).toBe(

DEFAULT_RESPONSE_TIMEOUT_MS,

);

});

it("honors models.providers.<id>.timeoutSeconds for slow local providers (#85267)", () => {

).toBe(DEFAULT_RESPONSE_TIMEOUT_MS);

});

it("clamps to MAX_SAFE_TIMEOUT_MS for absurd inputs", () => {

it("clamps to MAX_TIMER_TIMEOUT_MS for absurd inputs", () => {

const huge = resolveResponseTimeoutMs({

models: { providers: { ollama: { timeoutSeconds: 10_000_000 } } },

});

expect(huge).toBeLessThanOrEqual(2_147_000_000);

expect(huge).toBeLessThanOrEqual(MAX_TIMER_TIMEOUT_MS);

expect(huge).toBeGreaterThan(DEFAULT_RESPONSE_TIMEOUT_MS);

});

});

import {

finiteSecondsToTimerSafeMilliseconds,

MAX_TIMER_TIMEOUT_MS,

} from "openclaw/plugin-sdk/number-runtime";

/**

* QQBot outbound response watchdog timeout resolver.

*

* already configured:

* - `agents.defaults.timeoutSeconds`

* - `models.providers.<id>.timeoutSeconds` (max across configured providers)

* Take the maximum and clamp to `[DEFAULT_RESPONSE_TIMEOUT_MS, MAX_SAFE_TIMEOUT_MS]`.

* Take the maximum and clamp to `[DEFAULT_RESPONSE_TIMEOUT_MS, MAX_TIMER_TIMEOUT_MS]`.

* The default floor preserves the existing 5-minute guard for users

* that have not configured any longer ceiling — i.e. a no-op for

* typical cloud-model deployments.

*/

export const DEFAULT_RESPONSE_TIMEOUT_MS = 300_000;

/**

* Upper bound to keep the watchdog inside the safe `setTimeout` range

* (approximately 24.8 days). Mirrors `MAX_SAFE_TIMEOUT_MS` in

* `src/agents/embedded-agent-runner/run/llm-idle-timeout.ts`.

*/

const MAX_SAFE_TIMEOUT_MS = 2_147_000_000;

interface AgentsDefaultsLike {

timeoutSeconds?: unknown;

}

models?: ModelsBlockLike;

}

function positiveSecondsToMs(value: unknown): number | undefined {

if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {

return undefined;

}

return Math.floor(value * 1000);

}

/**

* Resolve the QQBot outbound response watchdog (ms).

*

* - the maximum `cfg.models.providers.<id>.timeoutSeconds` across

* configured providers, converted to ms

*

* Returns at most `MAX_SAFE_TIMEOUT_MS` so the chosen value is always

* Returns at most `MAX_TIMER_TIMEOUT_MS` so the chosen value is always

* a safe `setTimeout` argument.

*/

export function resolveResponseTimeoutMs(cfg: unknown): number {

const candidates: number[] = [DEFAULT_RESPONSE_TIMEOUT_MS];

const typed = (cfg ?? {}) as CfgShape;

const agentDefaultMs = positiveSecondsToMs(typed.agents?.defaults?.timeoutSeconds);

const agentDefaultMs = finiteSecondsToTimerSafeMilliseconds(

typed.agents?.defaults?.timeoutSeconds,

);

if (agentDefaultMs !== undefined) {

candidates.push(agentDefaultMs);

}

const providers = typed.models?.providers;

if (providers && typeof providers === "object") {

for (const entry of Object.values(providers)) {

const providerMs = positiveSecondsToMs(entry?.timeoutSeconds);

const providerMs = finiteSecondsToTimerSafeMilliseconds(entry?.timeoutSeconds);

if (providerMs !== undefined) {

candidates.push(providerMs);

}

}

}

const chosen = Math.max(...candidates);

return Math.min(chosen, MAX_SAFE_TIMEOUT_MS);

return Math.min(chosen, MAX_TIMER_TIMEOUT_MS);

}

import type { OpenClawConfig } from "../../config/types.openclaw.js";

import type { CompactResult, ContextEngine } from "../../context-engine/types.js";

import { withTimeout } from "../../node-host/with-timeout.js";

import { finiteSecondsToTimerSafeMilliseconds } from "../../shared/number-coercion.js";

export const EMBEDDED_COMPACTION_TIMEOUT_MS = 900_000;

const MAX_SAFE_TIMEOUT_MS = 2_147_000_000;

function createAbortError(signal: AbortSignal): Error {

const reason = "reason" in signal ? signal.reason : undefined;

if (reason instanceof Error) {

}

export function resolveCompactionTimeoutMs(cfg?: OpenClawConfig): number {

const raw = cfg?.agents?.defaults?.compaction?.timeoutSeconds;

if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) {

return Math.min(Math.floor(raw) * 1000, MAX_SAFE_TIMEOUT_MS);

}

return EMBEDDED_COMPACTION_TIMEOUT_MS;

return (

finiteSecondsToTimerSafeMilliseconds(cfg?.agents?.defaults?.compaction?.timeoutSeconds, {

floorSeconds: true,

}) ?? EMBEDDED_COMPACTION_TIMEOUT_MS

);

}

export async function compactWithSafetyTimeout<T>(

import type { AssistantMessageEventStream } from "openclaw/plugin-sdk/llm";

import { afterEach, describe, expect, it, vi } from "vitest";

import type { OpenClawConfig } from "../../../config/config.js";

import { MAX_TIMER_TIMEOUT_MS } from "../../../shared/number-coercion.js";

import {

DEFAULT_LLM_IDLE_TIMEOUT_MS,

resolveLlmIdleTimeoutMs,

});

it("disables the idle watchdog when an explicit run timeout disables timeouts", () => {

expect(resolveLlmIdleTimeoutMs({ runTimeoutMs: 2_147_000_000 })).toBe(0);

expect(resolveLlmIdleTimeoutMs({ runTimeoutMs: MAX_TIMER_TIMEOUT_MS })).toBe(0);

});

it("honors an explicit models.providers.<id>.timeoutSeconds for cloud providers (#77744, #78361)", () => {

it("caps provider request timeout at the max safe timeout", () => {

expect(

resolveLlmIdleTimeoutMs({ trigger: "cron", modelRequestTimeoutMs: 10_000_000_000 }),

).toBe(2_147_000_000);

).toBe(MAX_TIMER_TIMEOUT_MS);

});

it("ignores invalid provider request timeout values", () => {

import { DEFAULT_LLM_IDLE_TIMEOUT_SECONDS } from "../../../config/agent-timeout-defaults.js";

import type { OpenClawConfig } from "../../../config/types.openclaw.js";

import {

finiteSecondsToTimerSafeMilliseconds,

clampTimerTimeoutMs,

MAX_TIMER_TIMEOUT_MS,

} from "../../../shared/number-coercion.js";

import type { StreamFn } from "../../runtime/index.js";

import type { MutableAssistantMessageEventStream } from "../../stream-compat.js";

import { createStreamIteratorWrapper } from "../../stream-iterator-wrapper.js";

*/

export const DEFAULT_LLM_IDLE_TIMEOUT_MS = DEFAULT_LLM_IDLE_TIMEOUT_SECONDS * 1000;

/**

* Maximum safe timeout value (approximately 24.8 days).

*/

const MAX_SAFE_TIMEOUT_MS = 2_147_000_000;

/**

* Detects loopback / private-network / `.local` base URLs. Local providers

* (Ollama, LM Studio, llama.cpp) legitimately stay silent for many minutes

modelRequestTimeoutMs?: number;

model?: { baseUrl?: string; id?: string; provider?: string };

}): number {

const clampTimeoutMs = (valueMs: number) => Math.min(Math.floor(valueMs), MAX_SAFE_TIMEOUT_MS);

const clampTimeoutMs = (valueMs: number) => clampTimerTimeoutMs(valueMs) ?? 1;

const clampImplicitTimeoutMs = (valueMs: number) =>

clampTimeoutMs(Math.min(valueMs, DEFAULT_LLM_IDLE_TIMEOUT_MS));

const runTimeoutMs = params?.runTimeoutMs;

if (typeof runTimeoutMs === "number" && Number.isFinite(runTimeoutMs) && runTimeoutMs > 0) {

if (runTimeoutMs >= MAX_SAFE_TIMEOUT_MS) {

if (runTimeoutMs >= MAX_TIMER_TIMEOUT_MS) {

return 0;

}

}

const agentTimeoutSeconds = params?.cfg?.agents?.defaults?.timeoutSeconds;

const agentTimeoutMs =

typeof agentTimeoutSeconds === "number" &&

Number.isFinite(agentTimeoutSeconds) &&

agentTimeoutSeconds > 0

? agentTimeoutSeconds * 1000

: undefined;

const agentTimeoutMs = finiteSecondsToTimerSafeMilliseconds(agentTimeoutSeconds);

const timeoutBounds = [runTimeoutMs, agentTimeoutMs].filter(

(value): value is number =>

typeof value === "number" &&

Number.isFinite(value) &&

value > 0 &&

value < MAX_SAFE_TIMEOUT_MS,

value < MAX_TIMER_TIMEOUT_MS,

);

const modelRequestTimeoutMs = params?.modelRequestTimeoutMs;

import os from "node:os";

import path from "node:path";

import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";

import { MAX_TIMER_TIMEOUT_MS } from "../shared/number-coercion.js";

const FAKE_STARTTIME = 12345;

let testing: typeof import("./session-write-lock.js").testing;

it("clamps max hold for effectively no-timeout runs", () => {

expect(

resolveSessionLockMaxHoldFromTimeout({

timeoutMs: 2_147_000_000,

timeoutMs: MAX_TIMER_TIMEOUT_MS,

}),

).toBe(2_147_000_000);

).toBe(MAX_TIMER_TIMEOUT_MS);

});

it("cleans stale .jsonl lock files in sessions directories", async () => {

import path from "node:path";

import { createFileLockManager } from "../infra/file-lock-manager.js";

import { readGatewayProcessArgsSync as readProcessArgsSync } from "../infra/gateway-processes.js";

import { MAX_TIMER_TIMEOUT_MS } from "../shared/number-coercion.js";

import { getProcessStartTime, isPidAlive } from "../shared/pid-alive.js";

import { SessionWriteLockTimeoutError } from "./session-write-lock-error.js";

// A payload-less lock can be left behind if shutdown lands between open("wx")

// and the owner metadata write. Keep the grace short so 10s callers recover.

const ORPHAN_LOCK_PAYLOAD_GRACE_MS = 5_000;

const MAX_LOCK_HOLD_MS = 2_147_000_000;

type CleanupState = {

registered: boolean;

const minMs = resolvePositiveMs(params.minMs, DEFAULT_SESSION_WRITE_LOCK_MAX_HOLD_MS);

const timeoutMs = resolvePositiveMs(params.timeoutMs, minMs, { allowInfinity: true });

if (timeoutMs === Number.POSITIVE_INFINITY) {

return MAX_LOCK_HOLD_MS;

return MAX_TIMER_TIMEOUT_MS;

}

const graceMs = resolvePositiveMs(params.graceMs, DEFAULT_TIMEOUT_GRACE_MS);

return Math.min(MAX_LOCK_HOLD_MS, Math.max(minMs, timeoutMs + graceMs));

return Math.min(MAX_TIMER_TIMEOUT_MS, Math.max(minMs, timeoutMs + graceMs));

}

/**

import { deriveSessionChatTypeFromKey } from "../sessions/session-chat-type-shared.js";

import { isCronRunSessionKey, isCronSessionKey } from "../sessions/session-key-utils.js";

import { isNonTerminalAgentRunStatus } from "../shared/agent-run-status.js";

import { clampTimerTimeoutMs } from "../shared/number-coercion.js";

import { normalizeOptionalLowercaseString } from "../shared/string-coerce.js";

import { normalizeStringEntries, uniqueStrings } from "../shared/string-normalization.js";

import { mergeDeliveryContext, normalizeDeliveryContext } from "../utils/delivery-context.js";

import type { SpawnSubagentMode } from "./subagent-spawn.types.js";

const DEFAULT_SUBAGENT_ANNOUNCE_TIMEOUT_MS = 120_000;

const MAX_TIMER_SAFE_TIMEOUT_MS = 2_147_000_000;

type SubagentAnnounceDeliveryDeps = {

dispatchGatewayMethodInProcess: typeof dispatchGatewayMethodInProcess;

getRuntimeConfig: typeof getRuntimeConfig;

export function resolveSubagentAnnounceTimeoutMs(cfg: OpenClawConfig): number {

const configured = cfg.agents?.defaults?.subagents?.announceTimeoutMs;

if (typeof configured !== "number" || !Number.isFinite(configured)) {

return DEFAULT_SUBAGENT_ANNOUNCE_TIMEOUT_MS;

}

return Math.min(Math.max(1, Math.floor(configured)), MAX_TIMER_SAFE_TIMEOUT_MS);

return clampTimerTimeoutMs(configured) ?? DEFAULT_SUBAGENT_ANNOUNCE_TIMEOUT_MS;

}

export function isInternalAnnounceRequesterSession(sessionKey: string | undefined): boolean {

import { beforeEach, describe, expect, it, vi } from "vitest";

import { clampTimerTimeoutMs } from "../shared/number-coercion.js";

import { createSubagentAnnounceDeliveryRuntimeMock } from "./subagent-announce.test-support.js";

type GatewayCall = {

},

});

const timeoutMs =

typeof configOverride.agents?.defaults?.subagents?.announceTimeoutMs === "number" &&

Number.isFinite(configOverride.agents.defaults.subagents.announceTimeoutMs)

? Math.min(

Math.max(1, Math.floor(configOverride.agents.defaults.subagents.announceTimeoutMs)),

2_147_000_000,

)

: 120_000;

clampTimerTimeoutMs(configOverride.agents?.defaults?.subagents?.announceTimeoutMs) ?? 120_000;

const retryDelaysMs =

process.env.OPENCLAW_TEST_FAST === "1" ? [8, 16, 32] : [5_000, 10_000, 20_000];

let retryIndex = 0;

params.requesterOrigin,

resolveSubagentAnnounceTimeoutMs: (cfg: typeof configOverride) => {

const configured = cfg.agents?.defaults?.subagents?.announceTimeoutMs;

if (typeof configured !== "number" || !Number.isFinite(configured)) {

return 120_000;

}

return Math.min(Math.max(1, Math.floor(configured)), 2_147_000_000);

return clampTimerTimeoutMs(configured) ?? 120_000;

},

runAnnounceDeliveryWithRetry: async <T>(params: { run: () => Promise<T> }) => await params.run(),

}));