profiles: Record<string, Record<string, unknown>>;

};

const persistedProfile = persisted.profiles["openai-codex:default"];

expect(persistedProfile).toMatchObject({

type: "oauth",

provider: "openai-codex",

oauthRef: {

source: "openclaw-credentials",

provider: "openai-codex",

id: expect.any(String),

},

});

expect(persistedProfile?.type).toBe("oauth");

expect(persistedProfile?.provider).toBe("openai-codex");

const oauthRef = persistedProfile?.oauthRef as

| { source?: string; provider?: string; id?: unknown }

| undefined;

expect(oauthRef?.source).toBe("openclaw-credentials");

expect(oauthRef?.provider).toBe("openai-codex");

expect(typeof oauthRef?.id).toBe("string");

expect(persistedProfile).not.toHaveProperty("access");

expect(persistedProfile).not.toHaveProperty("refresh");

expect(persistedProfile).not.toHaveProperty("idToken");

contextKey: "exec:run-cron",

trusted: false,

});

expect(requestHeartbeatMock).toHaveBeenCalledWith(

expect.objectContaining({

coalesceMs: 0,

reason: "exec-event",

sessionKey: "agent:ops:primary",

}),

);

expect(requestHeartbeatMock).toHaveBeenCalledTimes(1);

const [[heartbeatParams]] = requestHeartbeatMock.mock.calls as unknown as Array<

[{ coalesceMs?: number; reason?: string; sessionKey?: string }]

>;

expect(heartbeatParams.coalesceMs).toBe(0);

expect(heartbeatParams.reason).toBe("exec-event");

expect(heartbeatParams.sessionKey).toBe("agent:ops:primary");

});

it("routes global-scope cron-run events to the global queue and preserves the agent wake target", () => {

contextKey: "exec:run-global",

trusted: false,

});

expect(requestHeartbeatMock).toHaveBeenCalledWith(

expect.objectContaining({

agentId: "ops",

coalesceMs: 0,

reason: "exec-event",

}),

);

expect(requestHeartbeatMock).toHaveBeenCalledTimes(1);

const [[heartbeatParams]] = requestHeartbeatMock.mock.calls as unknown as Array<

[{ agentId?: string; coalesceMs?: number; reason?: string }]

>;

expect(heartbeatParams.agentId).toBe("ops");

expect(heartbeatParams.coalesceMs).toBe(0);

expect(heartbeatParams.reason).toBe("exec-event");

expect(requestHeartbeatMock.mock.calls[0]?.[0]).not.toHaveProperty("sessionKey");

});

expect(result).toEqual({ text: "Codex side answer." });

expect(codexSideQuestionMock).toHaveBeenCalledTimes(1);

expect(codexSideQuestionMock.mock.calls[0]?.[0]).toMatchObject({

provider: "openai",

model: "gpt-5.5",

question: DEFAULT_QUESTION,

sessionId: "session-1",

agentId: "main",

workspaceDir: "/tmp/workspace",

authProfileId: "openai-codex:work",

});

const [[sideQuestionParams]] = codexSideQuestionMock.mock.calls as unknown as Array<

[

{

provider?: string;

model?: string;

question?: string;

sessionId?: string;

agentId?: string;

workspaceDir?: string;

authProfileId?: string;

},

]

>;

expect(sideQuestionParams.provider).toBe("openai");

expect(sideQuestionParams.model).toBe("gpt-5.5");

expect(sideQuestionParams.question).toBe(DEFAULT_QUESTION);

expect(sideQuestionParams.sessionId).toBe("session-1");

expect(sideQuestionParams.agentId).toBe("main");

expect(sideQuestionParams.workspaceDir).toBe("/tmp/workspace");

expect(sideQuestionParams.authProfileId).toBe("openai-codex:work");

expect(codexSideQuestionMock.mock.calls[0]?.[0].sessionFile).toContain("session-1.jsonl");

expect(streamSimpleMock).not.toHaveBeenCalled();

expect(registerProviderStreamForModelMock).not.toHaveBeenCalled();

const beforePromptBuildCalls = hookRunner.runBeforePromptBuild.mock.calls as unknown as Array<

[unknown, unknown]

>;

expect(beforePromptBuildCalls[0]?.[0]).toMatchObject({

prompt: "latest ask",

});

const promptBuildParams = beforePromptBuildCalls[0]?.[0] as { prompt?: string } | undefined;

expect(promptBuildParams?.prompt).toBe("latest ask");

} finally {

fs.rmSync(dir, { recursive: true, force: true });

}

const normalized = normalizeProviders({ providers, agentDir });

expect(normalized?.google?.models).toHaveLength(1);

expect(normalized?.google?.models?.[0]).toMatchObject({

id: "gemini-3.1-pro-preview",

name: "Pinned Gemini",

contextWindow: 12345,

maxTokens: 2048,

reasoning: false,

cost: { input: 1, output: 2, cacheRead: 3, cacheWrite: 4 },

});

const model = normalized?.google?.models?.[0];

expect(model?.id).toBe("gemini-3.1-pro-preview");

expect(model?.name).toBe("Pinned Gemini");

expect(model?.contextWindow).toBe(12345);

expect(model?.maxTokens).toBe(2048);

expect(model?.reasoning).toBe(false);

expect(model?.cost).toEqual({ input: 1, output: 2, cacheRead: 3, cacheWrite: 4 });

} finally {

await fs.rm(agentDir, { recursive: true, force: true });

}

expect(createOpenClawToolsMock).not.toHaveBeenCalled();

expect(resolvePluginToolsSpy).toHaveBeenCalledTimes(1);

expect(resolvePluginToolsSpy.mock.calls[0]?.[0].options).toMatchObject({

modelProvider: "openrouter",

modelId: "openrouter/auto",

});

const pluginToolOptions = resolvePluginToolsSpy.mock.calls[0]?.[0].options;

expect(pluginToolOptions?.modelProvider).toBe("openrouter");

expect(pluginToolOptions?.modelId).toBe("openrouter/auto");

} finally {

resolvePluginToolsSpy.mockRestore();

}

},

);

expect(mocks.callGateway).toHaveBeenCalledWith(

expect.objectContaining({

method: "plugins.sessionAction",

scopes: ["operator.approvals"],

}),

);

expect(mocks.callGateway).toHaveBeenCalledTimes(1);

const [[callParams]] = mocks.callGateway.mock.calls as unknown as Array<

[{ method?: string; scopes?: string[] }]

>;

expect(callParams.method).toBe("plugins.sessionAction");

expect(callParams.scopes).toEqual(["operator.approvals"]);

});

it("falls back to broad scopes when a plugin session action is not locally registered", async () => {

},

);

expect(mocks.callGateway).toHaveBeenCalledWith(

expect.objectContaining({

method: "plugins.sessionAction",

scopes: [

"operator.admin",

"operator.read",

"operator.write",

"operator.approvals",

"operator.pairing",

"operator.talk.secrets",

],

}),

);

expect(mocks.callGateway).toHaveBeenCalledTimes(1);

const [[callParams]] = mocks.callGateway.mock.calls as unknown as Array<

[{ method?: string; scopes?: string[] }]

>;

expect(callParams.method).toBe("plugins.sessionAction");

expect(callParams.scopes).toEqual([

"operator.admin",

"operator.read",

"operator.write",

"operator.approvals",

"operator.pairing",

"operator.talk.secrets",

]);

});

it("allows explicit scope overrides for dynamic callers", async () => {