import { collectConfiguredModelRefs } from "@openclaw/model-catalog-core/configured-model-refs";

import { isCanonicalDottedDecimalIPv4, isLoopbackIpAddress } from "@openclaw/net-policy/ip";

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

import { sanitizeForLog } from "../../packages/terminal-core/src/ansi.js";

import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agents/agent-scope.js";

import { isPathInside } from "../infra/path-guards.js";

import { planManifestModelCatalogSuppressions } from "../model-catalog/index.js";

import { findDuplicateAgentDirs, formatDuplicateAgentDirError } from "./agent-dirs.js";

import { appendAllowedValuesHint, summarizeAllowedValues } from "./allowed-values.js";

import { GENERATED_BUNDLED_CHANNEL_CONFIG_METADATA } from "./bundled-channel-config-metadata.generated.js";

import { collectChannelSchemaMetadata } from "./channel-config-metadata.js";

import { collectChannelSchemaMetadataWithOwnership } from "./channel-config-metadata.js";

import { shouldSuppressMissingCodexPluginDiagnostics } from "./codex-plugin-diagnostics.js";

import { materializeRuntimeConfig } from "./materialize.js";

import type { OpenClawConfig, ConfigValidationIssue } from "./types.js";

return `${baseLocal}.${errorPath}`;

};

const formatChannelConfigIssueMessage = (message: string, pluginId?: string): string => {

const safePluginId = pluginId ? sanitizeForLog(pluginId).trim() : "";

if (safePluginId) {

return `invalid config for plugin ${safePluginId}: ${message}`;

}

return formatRawChannelConfigIssueMessage(message);

};

type RegistryInfo = {

registry: PluginManifestRegistry;

knownIds?: Set<string>;

string,

{

schema?: Record<string, unknown>;

pluginId?: string;

}

>;

};

string,

{

schema?: Record<string, unknown>;

pluginId?: string;

}

> => {

const info = ensureRegistry();

(entry) => [entry.channelId, { schema: entry.schema }] as const,

),

);

for (const entry of collectChannelSchemaMetadata(info.registry)) {

for (const entry of collectChannelSchemaMetadataWithOwnership(info.registry)) {

const current = info.channelSchemas.get(entry.id);

if (entry.configSchema) {

info.channelSchemas.set(entry.id, { schema: entry.configSchema });

info.channelSchemas.set(entry.id, {

schema: entry.configSchema,

pluginId: entry.schemaPluginOrigin === "bundled" ? undefined : entry.schemaPluginId,

});

continue;

}

if (!current) {

continue;

}

const channelSchema = ensureChannelSchemas().get(trimmed)?.schema;

if (!channelSchema) {

const channelSchema = ensureChannelSchemas().get(trimmed);

if (!channelSchema?.schema) {

continue;

}

const result = validateJsonSchemaValue({

schema: channelSchema,

schema: channelSchema.schema,

cacheKey: `channel:${trimmed}`,

value: config.channels[trimmed],

applyDefaults: true, // Always apply defaults for AJV schema validation;

error.path === "<root>" ? `channels.${trimmed}` : `channels.${trimmed}.${error.path}`;

issues.push({

path: pathResult,

message: formatRawChannelConfigIssueMessage(error.message),

message: formatChannelConfigIssueMessage(error.message, channelSchema.pluginId),

allowedValues: error.allowedValues,

allowedValuesHiddenCount: error.allowedValuesHiddenCount,

});