expect(plan.resolvedModel).toBe(defaultModelRef);

expect(plan.initialSessionPatch.model).toBe(defaultModelRef);

expect(plan.initialSessionPatch.modelOverrideSource).toBe("auto");

expect(plan.initialSessionPatch.modelOverrideFallbackOriginProvider).toBeUndefined();

expect(plan.initialSessionPatch.modelOverrideFallbackOriginModel).toBeUndefined();

});

it("uses the target default provider for bare configured subagent models", () => {

const plan = expectOkPlan(

resolveSubagentModelAndThinkingPlan({

cfg: createConfig({

agents: {

defaults: {

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

subagents: { model: "gpt-5.4" },

},

},

}),

targetAgentId: "research",

}),

);

expect(plan.resolvedModel).toBe("gpt-5.4");

expect(plan.initialSessionPatch.modelOverrideFallbackOriginProvider).toBe("openai");

expect(plan.initialSessionPatch.modelOverrideFallbackOriginModel).toBe("gpt-5.4");

});

it("can resolve only explicit or configured subagent model selections", () => {

expect(plan.resolvedModel).toBe("minimax/MiniMax-M2.7");

expect(plan.initialSessionPatch.model).toBe("minimax/MiniMax-M2.7");

expect(plan.initialSessionPatch.modelOverrideSource).toBe("auto");

expect(plan.initialSessionPatch.modelOverrideFallbackOriginProvider).toBe("minimax");

expect(plan.initialSessionPatch.modelOverrideFallbackOriginModel).toBe("MiniMax-M2.7");

});

it("prefers target agent primary model over global default", () => {

expect(plan.resolvedModel).toBe("opencode/claude");

expect(plan.initialSessionPatch.model).toBe("opencode/claude");

expect(plan.initialSessionPatch.modelOverrideSource).toBe("auto");

expect(plan.initialSessionPatch.modelOverrideFallbackOriginProvider).toBe("opencode");

expect(plan.initialSessionPatch.modelOverrideFallbackOriginModel).toBe("claude");

});

it("uses config default timeout when agent omits runTimeoutSeconds", () => {

*/

import { formatThinkingLevels } from "../auto-reply/thinking.js";

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

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

import {

resolveDefaultModelForAgent,

resolveSubagentConfiguredModelSelection,

resolveSubagentSpawnModelSelection,

} from "./model-selection.js";

import { resolveSubagentThinkingOverride } from "./subagent-spawn-thinking.js";

/** Splits a provider/model ref while preserving model-only refs. */

}

const modelOverrideSource = params.modelOverride?.trim() ? "user" : "auto";

const resolvedModelRef = splitModelRef(resolvedModel);

const hasConfiguredAutoModel =

modelOverrideSource === "auto" &&

Boolean(

resolveSubagentConfiguredModelSelection({

cfg: params.cfg,

agentId: params.targetAgentId,

}),

);

const configuredModelRef = hasConfiguredAutoModel ? splitModelRef(resolvedModel) : undefined;

const modelOrigin = configuredModelRef?.model

? {

provider:

configuredModelRef.provider ??

resolveDefaultModelForAgent({

cfg: params.cfg,

agentId: params.targetAgentId,

}).provider,

model: configuredModelRef.model,

}

: undefined;

return {

status: "ok" as const,

? {

model: resolvedModel,

modelOverrideSource,

...(modelOverrideSource === "auto" &&

resolvedModelRef.provider &&

resolvedModelRef.model

...(modelOrigin

? {

// Auto-selected subagent models are real session overrides, not legacy

// auto-fallback recoveries. Persist self-origin metadata so the child

// run keeps its configured model instead of the legacy cleanup path

// discarding it before first execution.

modelOverrideFallbackOriginProvider: resolvedModelRef.provider,

modelOverrideFallbackOriginModel: resolvedModelRef.model,

// Config-selected models are session overrides, not legacy fallback residue.

// Self-origin metadata keeps cleanup from discarding them before first use.

modelOverrideFallbackOriginProvider: modelOrigin.provider,

modelOverrideFallbackOriginModel: modelOrigin.model,

}

: {}),

}

agents: {

defaults: {

workspace: os.tmpdir(),

subagents: { model: "minimax/MiniMax-M2.7" },

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

subagents: { model: "gpt-5.4" },

},

},

}),

expect(result.status).toBe("accepted");

const [, persistedEntry] = Object.entries(persistedStore ?? {})[0] ?? [];

expect(persistedEntry?.modelOverrideSource).toBe("auto");

expect(persistedEntry?.modelOverrideFallbackOriginProvider).toBe("minimax");

expect(persistedEntry?.modelOverrideFallbackOriginModel).toBe("MiniMax-M2.7");

expect(persistedEntry?.modelOverrideFallbackOriginProvider).toBe("openai");

expect(persistedEntry?.modelOverrideFallbackOriginModel).toBe("gpt-5.4");

});

});

entry.model = model;

entry.modelOverride = model;

entry.modelOverrideSource = patch.modelOverrideSource === "auto" ? "auto" : "user";

if (

typeof patch.modelOverrideFallbackOriginProvider === "string" &&

patch.modelOverrideFallbackOriginProvider.trim()

) {

entry.modelOverrideFallbackOriginProvider =

patch.modelOverrideFallbackOriginProvider.trim();

}

if (

typeof patch.modelOverrideFallbackOriginModel === "string" &&

patch.modelOverrideFallbackOriginModel.trim()

) {

entry.modelOverrideFallbackOriginModel = patch.modelOverrideFallbackOriginModel.trim();

const fallbackOriginProvider = normalizeOptionalString(

patch.modelOverrideFallbackOriginProvider,

);

const fallbackOriginModel = normalizeOptionalString(patch.modelOverrideFallbackOriginModel);

if (fallbackOriginProvider && fallbackOriginModel) {

entry.modelOverrideFallbackOriginProvider = fallbackOriginProvider;

entry.modelOverrideFallbackOriginModel = fallbackOriginModel;

}

if (provider) {

entry.modelProvider = provider;