public let workspace: String?

public let model: [String: AnyCodable]?

public let agentruntime: [String: AnyCodable]?

public let thinkinglevels: [[String: AnyCodable]]?

public let thinkingoptions: [String]?

public let thinkingdefault: String?

public init(

id: String,

name: String?,

identity: [String: AnyCodable]?,

workspace: String?,

model: [String: AnyCodable]?,

agentruntime: [String: AnyCodable]?)

agentruntime: [String: AnyCodable]?,

thinkinglevels: [[String: AnyCodable]]? = nil,

thinkingoptions: [String]? = nil,

thinkingdefault: String? = nil)

{

self.id = id

self.name = name

self.identity = identity

self.workspace = workspace

self.model = model

self.agentruntime = agentruntime

self.thinkinglevels = thinkinglevels

self.thinkingoptions = thinkingoptions

self.thinkingdefault = thinkingdefault

}

private enum CodingKeys: String, CodingKey {

case workspace

case model

case agentruntime = "agentRuntime"

case thinkinglevels = "thinkingLevels"

case thinkingoptions = "thinkingOptions"

case thinkingdefault = "thinkingDefault"

}

}

import { Value } from "typebox/value";

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

import {

AgentsListResultSchema,

SkillsProposalInspectResultSchema,

ToolsEffectiveResultSchema,

} from "./agents-models-skills.js";

};

}

describe("AgentsListResultSchema", () => {

it("accepts resolved per-agent thinking metadata", () => {

const result = {

defaultId: "main",

mainKey: "main",

scope: "per-sender",

agents: [

{

id: "investment-master",

name: "Investment Master",

model: { primary: "deepseek/deepseek-v4-flash" },

thinkingLevels: [

{ id: "off", label: "off" },

{ id: "xhigh", label: "xhigh" },

],

thinkingOptions: ["off", "xhigh"],

thinkingDefault: "xhigh",

},

],

};

expect(Value.Check(AgentsListResultSchema, result)).toBe(true);

});

});

describe("ToolsEffectiveResultSchema", () => {

it("accepts runtime tool quarantine notices", () => {

const result = {

{ additionalProperties: false },

),

),

thinkingLevels: Type.Optional(

Type.Array(

Type.Object(

{

id: NonEmptyString,

label: NonEmptyString,

},

{ additionalProperties: false },

),

),

),

thinkingOptions: Type.Optional(Type.Array(NonEmptyString)),

thinkingDefault: Type.Optional(NonEmptyString),

},

{ additionalProperties: false },

);

["MessageActionParams", ["inboundTurnKind"]],

["CronRunLogEntry", ["errorReason", "failureNotificationDelivery"]],

["ExecApprovalRequestParams", ["requireDeliveryRoute", "suppressDelivery"]],

["AgentSummary", ["thinkingLevels", "thinkingOptions", "thinkingDefault"]],

];

const DEFAULTED_OPTIONAL_INIT_PARAMS: Record<string, Set<string>> = Object.fromEntries(

isConfiguredAgent,

updateAgentConfigEntry,

} from "./agents-config-mutations.js";

import type { GatewayRequestHandlers, RespondFn } from "./types.js";

import type { GatewayRequestContext, GatewayRequestHandlers, RespondFn } from "./types.js";

const BOOTSTRAP_FILE_NAMES = [

DEFAULT_AGENTS_FILENAME,

isWorkspaceSetupCompleted,

};

let loggedSlowAgentsListCatalog = false;

const AGENTS_LIST_MODEL_CATALOG_TIMEOUT_MS = 750;

async function loadOptionalAgentsListModelCatalog(

context: GatewayRequestContext,

): Promise<Awaited<ReturnType<GatewayRequestContext["loadGatewayModelCatalog"]>> | undefined> {

let timeout: NodeJS.Timeout | undefined;

const timedOut = Symbol("agents-list-model-catalog-timeout");

const timeoutPromise = new Promise<typeof timedOut>((resolve) => {

timeout = setTimeout(() => resolve(timedOut), AGENTS_LIST_MODEL_CATALOG_TIMEOUT_MS);

timeout.unref?.();

});

try {

const result = await Promise.race([

context.loadGatewayModelCatalog().catch(() => undefined),

timeoutPromise,

]);

if (result === timedOut) {

if (!loggedSlowAgentsListCatalog) {

loggedSlowAgentsListCatalog = true;

context.logGateway.debug(

`agents.list continuing without model catalog after ${AGENTS_LIST_MODEL_CATALOG_TIMEOUT_MS}ms`,

);

}

return undefined;

}

return Array.isArray(result) ? result : undefined;

} finally {

if (timeout) {

clearTimeout(timeout);

}

}

}

export const testing = {

setDepsForTests(

overrides: Partial<{

}

export const agentsHandlers: GatewayRequestHandlers = {

"agents.list": ({ params, respond, context }) => {

"agents.list": async ({ params, respond, context }) => {

if (!validateAgentsListParams(params)) {

respond(

false,

}

const cfg = context.getRuntimeConfig();

const result = listAgentsForGateway(cfg);

const modelCatalog = await loadOptionalAgentsListModelCatalog(context);

const result = listAgentsForGateway(cfg, modelCatalog);

respond(true, result, undefined);

},

"agents.create": async ({ params, respond, context }) => {

const ops = result.agents.find((agent) => agent.id === "ops");

expect(ops?.model).toEqual({ primary: "anthropic/claude-opus-4-6" });

});

test("listAgentsForGateway reports per-agent thinking defaults from the agent model", () => {

const cfg = {

session: { mainKey: "main" },

agents: {

defaults: {

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

thinkingDefault: "off",

},

list: [

{ id: "main", default: true },

{

id: "investment-master",

model: { primary: "deepseek/deepseek-v4-flash" },

thinkingDefault: "xhigh",

},

],

},

} as OpenClawConfig;

const result = listAgentsForGateway(cfg);

const agent = result.agents.find((row) => row.id === "investment-master");

expect(agent?.model).toEqual({ primary: "deepseek/deepseek-v4-flash" });

expect(agent?.thinkingDefault).toBe("xhigh");

expect(agent?.thinkingLevels?.map((level) => level.id)).toEqual(

expect.arrayContaining(["off", "minimal", "low", "medium", "high", "xhigh"]),

);

expect(agent?.thinkingOptions).toEqual(agent?.thinkingLevels?.map((level) => level.label));

});

test("listAgentsForGateway uses the model catalog for per-agent thinking metadata", () => {

const cfg = {

session: { mainKey: "main" },

agents: {

defaults: {

model: { primary: "local/custom-reasoner" },

},

list: [{ id: "main", default: true }],

},

} as OpenClawConfig;

const result = listAgentsForGateway(cfg, [

{ provider: "local", id: "custom-reasoner", name: "Custom Reasoner", reasoning: true },

]);

const agent = result.agents.find((row) => row.id === "main");

expect(agent?.thinkingDefault).toBe("medium");

expect(agent?.thinkingLevels?.map((level) => level.id)).toContain("medium");

});

});

describe("resolveSessionModelRef", () => {

};

}

export function listAgentsForGateway(cfg: OpenClawConfig): {

export function listAgentsForGateway(

cfg: OpenClawConfig,

modelCatalog?: ModelCatalogEntry[],

): {

defaultId: string;

mainKey: string;

scope: SessionScope;

const meta = configuredById.get(id);

const model = resolveGatewayAgentModel(cfg, id);

const resolvedModel = resolveDefaultModelForAgent({ cfg, agentId: id });

const thinkingLevels = listThinkingLevelOptions(

resolvedModel.provider,

resolvedModel.model,

modelCatalog,

);

return Object.assign(

{

id,

sessionKey: resolveAgentMainSessionKey({ cfg, agentId: id }),

acpRuntime: false,

}),

thinkingLevels,

thinkingOptions: thinkingLevels.map((level) => level.label),

thinkingDefault: resolveGatewaySessionThinkingDefault({

cfg,

provider: resolvedModel.provider,

model: resolvedModel.model,

agentId: id,

modelCatalog,

}),

},

model ? { model } : {},

);

import type {

GatewayAgentRuntime,

GatewayAgentRow as SharedGatewayAgentRow,

GatewayThinkingLevelOption,

SessionsListResultBase,

SessionsPatchResultBase,

} from "../shared/session-types.js";

thinkingDefault?: string;

};

type GatewayThinkingLevelOption = {

id: string;

label: string;

};

export type SessionRunStatus = "running" | "done" | "failed" | "killed" | "timeout";

type SubagentRunState = "active" | "interrupted" | "historical";

source: "env" | "agent" | "defaults" | "model" | "provider" | "implicit" | "session-key";

};

export type GatewayThinkingLevelOption = {

id: string;

label: string;

};

export type GatewayAgentRow = {

id: string;

name?: string;

identity?: GatewayAgentIdentity;

workspace?: string;

model?: GatewayAgentModel;

agentRuntime?: GatewayAgentRuntime;

thinkingLevels?: GatewayThinkingLevelOption[];

thinkingOptions?: string[];

thinkingDefault?: string;

};

export type SessionsListResultBase<TDefaults, TRow> = {

};

}

function sessionModelMatchesDefaults(

row: SessionsListResult["sessions"][number] | undefined,

defaults: SessionsListResult["defaults"] | undefined,

): boolean {

return (

(!row?.modelProvider || row.modelProvider === defaults?.modelProvider) &&

(!row?.model || row.model === defaults?.model)

);

}

function buildThinkingOptions(

levels: readonly GatewayThinkingLevelOption[],

currentOverride: string,

typeof persisted === "string" && persisted.trim()

? (normalizeThinkLevel(persisted) ?? persisted.trim())

: "";

const defaults = state.sessionsResult?.defaults;

const { provider, model } = resolveThinkingTargetModel(state);

const levels = resolveThinkingLevelOptions(

activeRow,

state.sessionsResult?.defaults,

defaults,

provider,

model,

state.chatModelCatalog ?? [],

);

const defaultFromSessionDefaults =

(!activeRow || sessionModelMatchesDefaults(activeRow, defaults)) && defaults?.thinkingDefault

? defaults.thinkingDefault

: undefined;

const defaultLevel =

activeRow?.thinkingDefault ??

state.sessionsResult?.defaults?.thinkingDefault ??

defaultFromSessionDefaults ??

(provider && model

? resolveThinkingDefaultForModel({

provider,