}

}

function testModelDefinition(id: string): Model<Api> {

return {

id,

name: id,

reasoning: false,

input: ["text"],

cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },

contextWindow: 128_000,

maxTokens: 8192,

};

}

vi.mock("../plugins/setup-registry.js", async () => {

const { readFileSync } = await import("node:fs");

return {

}

});

it("reuses runtime auth availability for provider auth checks", () => {

const store = { version: 1 as const, profiles: {} };

const localNoKeyConfig = {

models: {

providers: {

vllm: {

api: "openai-completions",

baseUrl: "http://127.0.0.1:8000/v1",

models: [testModelDefinition("meta-llama/Meta-Llama-3-8B-Instruct")],

},

remote: {

api: "openai-completions",

baseUrl: "https://remote.example.com/v1",

models: [testModelDefinition("remote-model")],

},

},

},

} as OpenClawConfig;

expect(

hasAuthForModelProvider({

provider: "amazon-bedrock",

cfg: {} as OpenClawConfig,

env: {},

store,

}),

).toBe(true);

expect(

hasAuthForModelProvider({

provider: "vllm",

cfg: localNoKeyConfig,

env: {},

store,

}),

).toBe(true);

expect(

hasAuthForModelProvider({

provider: "remote",

cfg: localNoKeyConfig,

env: {},

store,

}),

).toBe(false);

});

it("hasAvailableAuthForProvider('google') accepts GOOGLE_API_KEY fallback", async () => {

await withEnvAsync(

{

},

};

const transformProviderSystemPrompt: Parameters<

typeof buildAttemptSystemPrompt

>[0]["transformProviderSystemPrompt"] = ({ context }) => context.systemPrompt;

describe("buildAttemptSystemPrompt", () => {

it("preserves bootstrap Project Context when a system prompt override is configured", () => {

const result = buildAttemptSystemPrompt({

isRawModelRun: false,

systemPromptOverrideText: "Custom override prompt.",

transformProviderSystemPrompt,

embeddedSystemPrompt: {

workspaceDir: "/tmp/openclaw",

reasoningTagHint: false,

it("omits system prompts for raw model probes", () => {

const result = buildAttemptSystemPrompt({

isRawModelRun: true,

transformProviderSystemPrompt,

embeddedSystemPrompt: {

workspaceDir: "/tmp/openclaw",

reasoningTagHint: false,

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

import { transformProviderSystemPrompt } from "../../../plugins/provider-runtime.js";

import type { ProviderTransformSystemPromptContext } from "../../../plugins/types.js";

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

import { buildEmbeddedSystemPrompt, createSystemPromptOverride } from "../system-prompt.js";

type EmbeddedSystemPromptParams = Parameters<typeof buildEmbeddedSystemPrompt>[0];

type ProviderSystemPromptTransform = (params: {

provider: string;

config?: OpenClawConfig;

workspaceDir: string;

context: ProviderTransformSystemPromptContext;

}) => string;

export type BuildAttemptSystemPromptParams = {

isRawModelRun: boolean;

systemPromptOverrideText?: string;

embeddedSystemPrompt: EmbeddedSystemPromptParams;

transformProviderSystemPrompt: ProviderSystemPromptTransform;

providerTransform: {

provider: string;

config?: OpenClawConfig;

const systemPrompt = params.isRawModelRun

? ""

: transformProviderSystemPrompt({

: params.transformProviderSystemPrompt({

provider: params.providerTransform.provider,

config: params.providerTransform.config,

workspaceDir: params.providerTransform.workspaceDir,

resolveEmbeddedAgentStreamFn,

resolveUnknownToolGuardThreshold,

shouldCreateBundleMcpRuntimeForAttempt,

shouldBuildCoreCodingToolsForAllowlist,

resolveAttemptToolPolicyMessageProvider,

resolvePromptBuildHookResult,

resolvePromptModeForSession,

applyEmbeddedAttemptToolsAllow(tools, [" cron ", "READ"]).map((tool) => tool.name),

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

});

it("keeps plugin-only allowlists on the shared tool policy path", () => {

const tools = [{ name: "memory_search" }, { name: "plugin_extra" }];

expect(shouldBuildCoreCodingToolsForAllowlist(["memory_search"])).toBe(false);

expect(

applyEmbeddedAttemptToolsAllow(tools, ["memory_search"]).map((tool) => tool.name),

).toEqual(["memory_search"]);

});

});

describe("buildEmbeddedAttemptToolRunContext", () => {

import {

resolveProviderSystemPromptContribution,

resolveProviderTextTransforms,

transformProviderSystemPrompt,

} from "../../../plugins/provider-runtime.js";

import { getPluginToolMeta } from "../../../plugins/tools.js";

import { isAcpSessionKey, isSubagentSessionKey } from "../../../routing/session-key.js";

"write",

]);

function shouldBuildCoreCodingToolsForAllowlist(toolsAllow?: string[]): boolean {

export function shouldBuildCoreCodingToolsForAllowlist(toolsAllow?: string[]): boolean {

if (!toolsAllow || toolsAllow.length === 0) {

return true;

}

const attemptSystemPrompt = buildAttemptSystemPrompt({

isRawModelRun,

systemPromptOverrideText,

transformProviderSystemPrompt,

embeddedSystemPrompt: {

workspaceDir: effectiveWorkspace,

defaultThinkLevel: params.thinkLevel,

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

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

import { migrateLegacyConfig } from "./legacy-config-migrate.js";

import { LEGACY_CONFIG_MIGRATIONS } from "./legacy-config-migrations.js";

function migrateLegacyConfigForTest(raw: unknown): {

});

describe("legacy migrate sandbox scope aliases", () => {

it("returns migrated config when unrelated plugin validation issues remain (#76798)", () => {

const res = migrateLegacyConfig({

agents: {

defaults: {

model: { primary: "openai/gpt-5.5" },

llm: { idleTimeoutSeconds: 120 },

},

},

plugins: {

entries: {

brave: {

enabled: true,

config: { webSearch: { mode: "definitely-invalid" } },

},

},

},

tools: { web: { search: { provider: "brave" } } },

});

expect(res.partiallyValid).toBe(true);

expect(res.changes).toContain(

"Removed agents.defaults.llm; model idle timeout now follows models.providers.<id>.timeoutSeconds.",

);

expect(res.changes).toContain(

"Migration applied; other validation issues remain — run doctor to review.",

);

expect(res.config?.agents?.defaults).toEqual({

model: { primary: "openai/gpt-5.5" },

});

expect(res.config?.tools?.web?.search?.provider).toBe("brave");

});

it("removes legacy agents.defaults.llm timeout config", () => {

const res = migrateLegacyConfigForTest({

agents: {