c401cd3450f1737bc92418cfea301d20b54b7fbef9e6049834acc01af338e538 config-baseline.channel.json

7731a0b93cb335b56fac4c807447ba659fea51ea7a6cd844dc0ef5616669ee75 config-baseline.plugin.json

- `agent.wait` default: 30s (just the wait). `timeoutMs` param overrides.

- Agent runtime: `agents.defaults.timeoutSeconds` default 172800s (48 hours); enforced in `runEmbeddedPiAgent` abort timer.

- Cron runtime: isolated agent-turn `timeoutSeconds` is owned by cron. The scheduler starts that timer when execution begins, aborts the underlying run at the configured deadline, then runs bounded cleanup before recording the timeout so a stale child session cannot keep the lane stuck.

- Model idle timeout: OpenClaw aborts a model request when no response chunks arrive before the idle window. `models.providers.<id>.timeoutSeconds` extends this idle watchdog for slow local/self-hosted providers; otherwise OpenClaw uses `agents.defaults.timeoutSeconds` when configured, capped at 120s by default. Cron-triggered runs with no explicit model or agent timeout disable the idle watchdog and rely on the cron outer timeout.

- Provider HTTP request timeout: `models.providers.<id>.timeoutSeconds` applies to that provider's model HTTP fetches, including connect, headers, body, SDK request timeout, total guarded-fetch abort handling, and model stream idle watchdog. Use this for slow local/self-hosted providers such as Ollama before raising the whole agent runtime timeout.

- If commands seem stuck, enable verbose logs and look for “queued for …ms” lines to confirm the queue is draining.

- If you need queue depth, enable verbose logs and watch for queue timing lines.

- Codex app-server runs that accept a turn and then stop emitting progress are interrupted by the Codex adapter so the active session lane can release instead of waiting for the outer run timeout.

- `enabled`: master toggle for instrumentation output (default: `true`).

- `flags`: array of flag strings enabling targeted log output (supports wildcards like `"telegram.*"` or `"*"`).

- `otel.enabled`: enables the OpenTelemetry export pipeline (default: `false`). For the full configuration, signal catalog, and privacy model, see [OpenTelemetry export](/gateway/opentelemetry).

- `otel.endpoint`: collector URL for OTel export.

- `otel.tracesEndpoint` / `otel.metricsEndpoint` / `otel.logsEndpoint`: optional signal-specific OTLP endpoints. When set, they override `otel.endpoint` for that signal only.

type Delivery = { kind: string; text?: string };

const deliveries: Delivery[] = [];

const projector = createAcpReplyProjector({

cfg: createCfg(cfgOverrides),

deliveries.push({ kind, text: payload.text });

return true;

},

});

return { deliveries, projector };

describe("createAcpReplyProjector", () => {

it("coalesces text deltas into bounded block chunks", async () => {

const { deliveries, projector } = createProjectorHarness();

payload: ReplyPayload,

meta?: AcpProjectedDeliveryMeta,

) => Promise<boolean>;

provider?: string;

accountId?: string;

}): AcpReplyProjector {

};

const onEvent = async (event: AcpRuntimeEvent): Promise<void> => {

if (event.type === "text_delta") {

if (event.stream && event.stream !== "output") {

return;

applyMediaUnderstanding: vi.fn(async (_params: unknown) => undefined),

const sessionMetaMocks = vi.hoisted(() => ({

readAcpSessionEntry: vi.fn<

(params: { sessionKey: string; cfg?: OpenClawConfig }) => AcpSessionStoreEntry | null

sessionMetaMocks.readAcpSessionEntry(params),

vi.mock("./dispatch-acp-transcript.runtime.js", () => ({

persistAcpDispatchTranscript: (params: unknown) =>

transcriptMocks.persistAcpDispatchTranscript(params),

ttsMocks.resolveTtsConfig.mockReturnValue({ mode: "final" });

mediaUnderstandingMocks.applyMediaUnderstanding.mockReset();

mediaUnderstandingMocks.applyMediaUnderstanding.mockResolvedValue(undefined);

sessionMetaMocks.readAcpSessionEntry.mockReset();

sessionMetaMocks.readAcpSessionEntry.mockReturnValue(null);

transcriptMocks.persistAcpDispatchTranscript.mockClear();

expect(onReplyStart).toHaveBeenCalledTimes(1);

});

it("does not start reply lifecycle for empty ACP prompt", async () => {

setReadyAcpResolution();

const onReplyStart = vi.fn();

import type { TtsAutoMode } from "../../config/types.tts.js";

import { logVerbose } from "../../globals.js";

import { emitAgentEvent } from "../../infra/agent-events.js";

import { formatErrorMessage } from "../../infra/errors.js";

import { generateSecureUuid } from "../../infra/secure-random.js";

import { prefixSystemMessage } from "../../infra/system-message.js";

import { resolveAgentIdFromSessionKey } from "../../routing/session-key.js";

import {

normalizeLowercaseStringOrEmpty,

}

const canonicalSessionKey = acpResolution.sessionKey;

const acpAgentId = resolveAgentIdFromSessionKey(canonicalSessionKey);

let queuedFinal = false;

const delivery = createAcpDispatchDeliveryCoordinator({

cfg: params.cfg,

shouldSendToolSummaries: params.shouldSendToolSummaries,

deliver: delivery.deliver,

provider: params.ctx.Surface ?? params.ctx.Provider,

accountId: effectiveDispatchAccountId,

});

diagnosticMocks.logMessageQueued.mockReset();

diagnosticMocks.logMessageProcessed.mockReset();

diagnosticMocks.logSessionStateChange.mockReset();

agentEventMocks.emitAgentEvent.mockReset();

agentEventMocks.onAgentEvent.mockReset().mockImplementation(() => () => {});

setNoAbort();