import { normalizeOptionalString } from "@openclaw/normalization-core/string-coerce";

import { Compile } from "typebox/compile";

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

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

import { logWarn } from "../logger.js";

import type { PluginManifestRegistry } from "../plugins/manifest-registry.js";

import { resolveGlobalSingleton } from "../shared/global-singleton.js";

},

(error: unknown) => {

clearTimeout(timer);

reject(toLintErrorObject(error, "Non-Error rejection"));

reject(toErrorObject(error, "Non-Error rejection"));

},

);

});

resolveSessionMcpRuntimeIdleTtlMs,

};

export { testing as __testing };

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

import { URL } from "node:url";

import { detectMime } from "@openclaw/media-core/mime";

import { isWindowsDrivePath } from "../infra/archive-path.js";

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

import {

canonicalPathFromExistingAncestor,

root as fsRoot,

firstRootEscapeError ??= error;

}

}

throw toLintErrorObject(

throw toErrorObject(

firstRootEscapeError ?? new Error("Path guard has no configured roots."),

"Non-Error thrown",

);

error.code = code;

return error;

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

*/

import { readResponseTextSnippet } from "@openclaw/media-core/read-response-with-limit";

import { normalizeLowercaseStringOrEmpty } from "@openclaw/normalization-core/string-coerce";

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

import { getEnvApiKey } from "../llm/env-api-keys.js";

import { calculateCost, clampThinkingLevel } from "../llm/model-utils.js";

import {

}

settled = true;

signal.removeEventListener("abort", onAbort);

reject(toLintErrorObject(error, "Non-Error rejection"));

reject(toErrorObject(error, "Non-Error rejection"));

},

);

});

return eventStream as ReturnType<StreamFn>;

};

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

import { createOutboundSendDeps, type CliDeps } from "../../cli/outbound-send-deps.js";

import type { SessionEntry } from "../../config/sessions.js";

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

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

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

import {

resolveAgentDeliveryPlanWithSessionRoute,

resolveAgentOutboundTarget,

};

if (strictPreDeliveryError) {

emitJsonEnvelope(deliveryStatus);

throw toLintErrorObject(strictPreDeliveryError, "Non-Error thrown");

throw toErrorObject(strictPreDeliveryError, "Non-Error thrown");

}

const deliveryPayloads = projectOutboundPayloadPlanForOutbound(outboundPayloadPlan);

deliveryStatus,

});

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

import { fileURLToPath, pathToFileURL } from "node:url";

import { Worker } from "node:worker_threads";

import { resolveTimerTimeoutMs } from "@openclaw/normalization-core/number-coercion";

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

import {

buildHistoryPrunePlan,

buildOversizedFallbackPlan,

}): Promise<CompactionPlanningWorkerValue> {

if (params.signal?.aborted) {

return Promise.reject(

toLintErrorObject(

toErrorObject(

params.signal.reason ?? new Error("compaction planning aborted"),

"Non-Error rejection",

),

settle(

() =>

reject(

toLintErrorObject(

toErrorObject(

params.signal?.reason ?? new Error("compaction planning aborted"),

"Non-Error rejection",

),

runCompactionPlanningWorker,

CompactionPlanningWorkerError,

};

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

resolveExpiresAtMsFromDurationMs,

} from "@openclaw/normalization-core/number-coercion";

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

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

import { resolveOpenClawPackageRootSync } from "../../infra/openclaw-root.js";

import { privateFileStoreSync } from "../../infra/private-file-store.js";

import { createSubsystemLogger } from "../../logging/subsystem.js";

const rejectOnce = (error: unknown) => {

if (!settled) {

settled = true;

reject(toLintErrorObject(error, "Non-Error rejection"));

reject(toErrorObject(error, "Non-Error rejection"));

}

};

const req = httpRequest(

let onAbort: (() => void) | undefined;

const abortPromise = new Promise<never>((_, reject) => {

if (params.signal!.aborted) {

reject(toLintErrorObject(params.signal!.reason, "Non-Error rejection"));

reject(toErrorObject(params.signal!.reason, "Non-Error rejection"));

return;

}

onAbort = () => reject(toLintErrorObject(params.signal!.reason, "Non-Error rejection"));

onAbort = () => reject(toErrorObject(params.signal!.reason, "Non-Error rejection"));

params.signal!.addEventListener("abort", onAbort, { once: true });

});

try {

},

} as const;

export { testing as __testing };

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

} from "../config/model-input.js";

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

import { emitFailoverEvent } from "../infra/diagnostic-events.js";

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

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

import { createSubsystemLogger } from "../logging/subsystem.js";

import { normalizePluginsConfig } from "../plugins/config-state.js";

import { getCurrentPluginMetadataSnapshot } from "../plugins/current-plugin-metadata-snapshot.js";

});

if (classifiedError) {

if (isTerminalAbort(params.abortSignal)) {

throw toLintErrorObject(classifiedError, "Non-Error thrown");

throw toErrorObject(classifiedError, "Non-Error thrown");

}

const preserveResultOnExhaustion =

classification &&

agentDir?: string;

}): never {

if (params.attempts.length <= 1 && params.lastError) {

throw toLintErrorObject(params.lastError, "Non-Error thrown");

throw toErrorObject(params.lastError, "Non-Error thrown");

}

if (params.attribution?.sessionId) {

});

}

export { testing as __testing };

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

import { Worker } from "node:worker_threads";

import { hashRuntimeConfigValue } from "../config/runtime-snapshot.js";

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

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

import {

listAgentIds,

resolveAgentDir,

resolve({ agents: [] });

return;

}

reject(toLintErrorObject(error, "Non-Error rejection"));

reject(toErrorObject(error, "Non-Error rejection"));

});

});

worker.once("exit", (code) => {

}

publishProviderAuthWarmSnapshot(snapshot);

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

resolvePositiveTimerTimeoutMs,

} from "@openclaw/normalization-core/number-coercion";

import type { ModelProviderLocalServiceConfig } from "../config/types.models.js";

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

import type { Model } from "../llm/types.js";

import { createSubsystemLogger } from "../logging/subsystem.js";

import {

},

(error: unknown) => {

cleanup();

reject(toLintErrorObject(error, "Non-Error rejection"));

reject(toErrorObject(error, "Non-Error rejection"));

},

);

});

): boolean {

return child.exitCode !== null || child.signalCode !== null;

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

import os from "node:os";

import path from "node:path";

import { resolveRootPath } from "../../infra/boundary-path.js";

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

import { parseSshTarget } from "../../infra/ssh-tunnel.js";

import { resolvePreferredOpenClawTmpDir } from "../../infra/tmp-openclaw-dir.js";

import { resolveUserPath } from "../../utils.js";

const fail = (error: unknown) => {

tar.kill("SIGKILL");

ssh.kill("SIGKILL");

reject(toLintErrorObject(error, "Non-Error rejection"));

reject(toErrorObject(error, "Non-Error rejection"));

};

tar.on("error", fail);

await fs.chmod(pathname, 0o600);

return pathname;

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}