* sessions. Keeps runtime tool filtering tied to canonical config, session

* provenance, and inherited sub-agent capabilities.

*/

import { normalizeProviderId } from "@openclaw/model-catalog-core/provider-id";

import {

normalizeLowercaseStringOrEmpty,

normalizeOptionalLowercaseString,

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

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

import {

normalizeUniqueSingleOrTrimmedStringList,

uniqueStrings,

import { normalizeMessageChannel } from "../utils/message-channel.js";

import { resolveAgentConfig, resolveAgentIdFromSessionKey } from "./agent-scope.js";

import type { AnyAgentTool } from "./agent-tools.types.js";

import { resolveProviderToolPolicy } from "./provider-tool-policy.js";

import { pickSandboxToolPolicy } from "./sandbox-tool-policy.js";

import type { SandboxToolPolicy } from "./sandbox.js";

import {

resolveToolProfilePolicy,

} from "./tool-policy.js";

export { resolveProviderToolPolicy };

/**

* Tools always denied for sub-agents regardless of depth.

* These are system-level or interactive tools that sub-agents should never use.

return tools.filter((tool) => isToolAllowedByPolicyName(tool.name, policy));

}

type ToolPolicyConfig = {

allow?: string[];

alsoAllow?: string[];

deny?: string[];

profile?: string;

};

function normalizeProviderKey(value: string): string {

const normalized = normalizeLowercaseStringOrEmpty(value);

const slashIndex = normalized.indexOf("/");

if (slashIndex <= 0) {

return normalizeProviderId(normalized);

}

const provider = normalizeProviderId(normalized.slice(0, slashIndex));

const modelId = normalized.slice(slashIndex + 1);

return modelId ? `${provider}/${modelId}` : provider;

}

function isCanonicalProviderKey(value: string): boolean {

return normalizeLowercaseStringOrEmpty(value) === normalizeProviderKey(value);

}

function buildProviderToolPolicyLookup(

entries: Array<[string, ToolPolicyConfig]>,

): Map<string, ToolPolicyConfig> {

const lookup = new Map<

string,

{

canonical: boolean;

value: ToolPolicyConfig;

}

>();

for (const [key, value] of entries) {

const normalized = normalizeProviderKey(key);

if (!normalized) {

continue;

}

const canonical = isCanonicalProviderKey(key);

const existing = lookup.get(normalized);

// Alias and canonical keys can normalize to the same provider. Prefer the

// canonical entry so mixed legacy/canonical configs do not depend on

// Object.entries insertion order.

if (!existing || (canonical && !existing.canonical)) {

lookup.set(normalized, { canonical, value });

}

}

const resolved = new Map<string, ToolPolicyConfig>();

for (const [key, entry] of lookup) {

resolved.set(key, entry.value);

}

return resolved;

}

function collectUniqueStrings(values: Array<string | null | undefined>): string[] {

return normalizeUniqueSingleOrTrimmedStringList(values);

}

});

}

/** Resolve model/provider-scoped tool policy from canonical provider keys. */

export function resolveProviderToolPolicy(params: {

byProvider?: Record<string, ToolPolicyConfig>;

modelProvider?: string;

modelId?: string;

}): ToolPolicyConfig | undefined {

const provider = params.modelProvider?.trim();

if (!provider || !params.byProvider) {

return undefined;

}

const entries = Object.entries(params.byProvider);

if (entries.length === 0) {

return undefined;

}

const lookup = buildProviderToolPolicyLookup(entries);

const normalizedProvider = normalizeProviderKey(provider);

const rawModelId = normalizeOptionalLowercaseString(params.modelId);

// Model IDs can contain provider-like prefixes (for example OpenRouter refs);

// keep them inside the selected provider scope instead of treating them as a

// byProvider override.

const fullModelId = rawModelId ? `${normalizedProvider}/${rawModelId}` : undefined;

const candidates = [...(fullModelId ? [fullModelId] : []), normalizedProvider];

for (const key of candidates) {

const match = lookup.get(key);

if (match) {

return match;

}

}

return undefined;

}

function resolveExplicitProfileAlsoAllow(tools?: OpenClawConfig["tools"]): string[] | undefined {

return Array.isArray(tools?.alsoAllow) ? tools.alsoAllow : undefined;

}