expect(toolNameList(tools)).toContain("message");

});

it("preserves runtime-allowed message through local model lean filtering", () => {

const tools = createOpenClawCodingTools({

config: {

agents: {

defaults: {

experimental: {

localModelLean: true,

},

},

},

tools: { profile: "minimal" },

},

runtimeToolAllowlist: ["message"],

toolConstructionPlan: {

includeBaseCodingTools: false,

includeShellTools: false,

includeChannelTools: false,

includeOpenClawTools: true,

includePluginTools: false,

},

});

expect(toolNameList(tools)).toContain("message");

});

it("preserves forced message through local model lean filtering without runtime allowlist", () => {

const tools = createOpenClawCodingTools({

config: {

agents: {

defaults: {

experimental: {

localModelLean: true,

},

},

},

tools: { profile: "minimal" },

},

forceMessageTool: true,

toolConstructionPlan: {

includeBaseCodingTools: false,

includeShellTools: false,

includeChannelTools: false,

includeOpenClawTools: true,

includePluginTools: false,

},

});

expect(toolNameList(tools)).toContain("message");

});

it("preserves message-tool-only replies through local model lean filtering without runtime allowlist", () => {

const tools = createOpenClawCodingTools({

config: {

agents: {

defaults: {

experimental: {

localModelLean: true,

},

},

},

tools: { profile: "minimal" },

},

sourceReplyDeliveryMode: "message_tool_only",

toolConstructionPlan: {

includeBaseCodingTools: false,

includeShellTools: false,

includeChannelTools: false,

includeOpenClawTools: true,

includePluginTools: false,

},

});

expect(toolNameList(tools)).toContain("message");

});

it("preserves runtime allowlist groups containing message through restrictive profiles", () => {

for (const runtimeToolAllowlist of [["group:messaging"], ["group:openclaw"], ["*"]]) {

const tools = createOpenClawCodingTools({

import { listChannelAgentTools } from "./channel-tools.js";

import { shouldSuppressManagedWebSearchTool } from "./codex-native-web-search.js";

import { resolveImageSanitizationLimits } from "./image-sanitization.js";

import { filterLocalModelLeanTools } from "./local-model-lean.js";

import {

filterLocalModelLeanTools,

resolveLocalModelLeanPreserveToolNames,

} from "./local-model-lean.js";

import type { ModelAuthMode } from "./model-auth.js";

import { resolveOpenClawPluginToolsForOptions } from "./openclaw-plugin-tools.js";

import { createOpenClawTools } from "./openclaw-tools.js";

agentDir?: string;

modelCompat?: ModelCompatConfig;

suppressManagedWebSearch?: boolean;

runtimeToolAllowlist?: string[];

localModelLeanPreserveToolNames?: string[];

},

): AnyAgentTool[] {

let tools = toolsInput;

config: params?.config,

agentId: params?.agentId,

sessionKey: params?.sessionKey,

preserveToolNames: params?.localModelLeanPreserveToolNames ?? params?.runtimeToolAllowlist,

});

if (

const normalized = normalizeToolName(toolName);

return normalized === "*" || normalized === "message";

});

const localModelLeanPreserveToolNames = resolveLocalModelLeanPreserveToolNames({

toolNames: options?.runtimeToolAllowlist,

forceMessageTool: options?.forceMessageTool,

sourceReplyDeliveryMode: options?.sourceReplyDeliveryMode,

});

const runtimeProfileAlsoAllow = [

...(options?.forceMessageTool || options?.sourceReplyDeliveryMode === "message_tool_only"

? ["message"]

agentDir: options?.agentDir,

modelCompat: options?.modelCompat,

suppressManagedWebSearch: options?.suppressManagedWebSearch,

runtimeToolAllowlist: options?.runtimeToolAllowlist,

localModelLeanPreserveToolNames,

});

options?.recordToolPrepStage?.("model-provider-policy");

// Sender identity is carried for command/channel-action auth; tool visibility

import { runAgentEndSideEffects } from "../../harness/agent-end-side-effects.js";

import { resolveHeartbeatPromptForSystemPrompt } from "../../heartbeat-system-prompt.js";

import { resolveImageSanitizationLimits } from "../../image-sanitization.js";

import { filterLocalModelLeanTools, isLocalModelLeanEnabled } from "../../local-model-lean.js";

import {

filterLocalModelLeanTools,

isLocalModelLeanEnabled,

resolveLocalModelLeanPreserveToolNames,

} from "../../local-model-lean.js";

import { resolveModelAuthMode } from "../../model-auth.js";

import { resolveDefaultModelForAgent } from "../../model-selection.js";

import { supportsModelTools } from "../../model-tool-support.js";

]),

]

: toolsAllowWithForcedRuntimeTools;

const localModelLeanPreserveToolNames = resolveLocalModelLeanPreserveToolNames({

toolNames: effectiveToolsAllow,

forceMessageTool: params.forceMessageTool,

sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,

});

const shouldConstructTools =

toolConstructionPlan.constructTools ||

toolSearchControlsEnabledForRun ||

forceMessageTool: params.forceMessageTool,

enableHeartbeatTool: params.enableHeartbeatTool,

forceHeartbeatTool: params.forceHeartbeatTool,

runtimeToolAllowlist: effectiveToolsAllow,

authProfileStore: params.authProfileStore,

recordToolPrepStage: (name) => corePluginToolStages.mark(name),

onToolOutcome: params.onToolOutcome,

tools: [...tools, ...normalizedBundledTools],

config: params.config,

agentId: sessionAgentId,

preserveToolNames: localModelLeanPreserveToolNames,

});

const uncompactedToolSchemaProjection = filterRuntimeCompatibleTools(

projectedUncompactedEffectiveTools,

tools: toolSearch.tools,

config: params.config,

agentId: sessionAgentId,

preserveToolNames: localModelLeanPreserveToolNames,

});

const toolSearchSchemaProjection = filterRuntimeCompatibleTools(projectedToolSearchTools);

logRuntimeToolSchemaQuarantine({

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

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

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

import { filterLocalModelLeanTools, isLocalModelLeanEnabled } from "./local-model-lean.js";

import {

filterLocalModelLeanTools,

isLocalModelLeanEnabled,

resolveLocalModelLeanPreserveToolNames,

} from "./local-model-lean.js";

function tools(names: string[]): AnyAgentTool[] {

return names.map((name) => ({ name })) as AnyAgentTool[];

).toEqual(["read", "exec"]);

});

it("keeps explicitly preserved tools when lean mode is enabled", () => {

const cfg: OpenClawConfig = {

agents: {

defaults: {

experimental: {

localModelLean: true,

},

},

},

};

expect(

filterLocalModelLeanTools({

tools: tools(["read", "browser", "cron", "message", "exec"]),

config: cfg,

preserveToolNames: ["browser", "cron", "group:messaging"],

}).map((tool) => tool.name),

).toEqual(["read", "browser", "cron", "message", "exec"]);

});

it("adds reply-required message tools to lean preservation", () => {

expect(

resolveLocalModelLeanPreserveToolNames({

forceMessageTool: true,

}),

).toEqual(["message"]);

expect(

resolveLocalModelLeanPreserveToolNames({

sourceReplyDeliveryMode: "message_tool_only",

}),

).toEqual(["message"]);

expect(

resolveLocalModelLeanPreserveToolNames({

toolNames: ["group:messaging"],

forceMessageTool: true,

}),

).toEqual(["group:messaging", "message"]);

});

it("does not treat wildcard preservation as disabling lean mode", () => {

const cfg: OpenClawConfig = {

agents: {

defaults: {

experimental: {

localModelLean: true,

},

},

},

};

expect(

filterLocalModelLeanTools({

tools: tools(["read", "browser", "cron", "message", "exec"]),

config: cfg,

preserveToolNames: ["*"],

}).map((tool) => tool.name),

).toEqual(["read", "exec"]);

});

it("lets an agent opt out of an inherited global lean setting", () => {

const cfg: OpenClawConfig = {

agents: {

import { normalizeAgentId, parseAgentSessionKey } from "../routing/session-key.js";

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

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

import { expandToolGroups, normalizeToolName } from "./tool-policy.js";

const LOCAL_MODEL_LEAN_DENY_TOOL_NAMES = new Set(["browser", "cron", "message"]);

function resolvePreservedLocalModelLeanToolNames(names?: Iterable<string>): Set<string> {

if (!names) {

return new Set();

}

return new Set(

expandToolGroups([...names])

.map(normalizeToolName)

.filter((name) => name && name !== "*"),

);

}

export function resolveLocalModelLeanPreserveToolNames(params?: {

toolNames?: Iterable<string>;

forceMessageTool?: boolean;

sourceReplyDeliveryMode?: string;

}): string[] {

const names = [...(params?.toolNames ?? [])];

if (params?.forceMessageTool || params?.sourceReplyDeliveryMode === "message_tool_only") {

names.push("message");

}

return [...new Set(names)];

}

function resolveLocalModelLeanAgentId(params: {

config?: OpenClawConfig;

agentId?: string;

config?: OpenClawConfig;

agentId?: string;

sessionKey?: string;

preserveToolNames?: Iterable<string>;

}): AnyAgentTool[] {

if (!isLocalModelLeanEnabled(params)) {

return params.tools;

}

return params.tools.filter((tool) => !LOCAL_MODEL_LEAN_DENY_TOOL_NAMES.has(tool.name));

const preservedToolNames = resolvePreservedLocalModelLeanToolNames(params.preserveToolNames);

return params.tools.filter((tool) => {

const normalizedName = normalizeToolName(tool.name);

return (

preservedToolNames.has(normalizedName) ||

!LOCAL_MODEL_LEAN_DENY_TOOL_NAMES.has(normalizedName)

);

});

}