});

});

it("passes the configured binding agent to plugin-owned Discord command sessions", async () => {

const cfg = createConfig();

const interaction = createInteraction();

const pluginSessionKey = "plugin-binding:openclaw-codex-app-server:dm";

discordNativeCommandTesting.setResolveDiscordNativeInteractionRouteState(async () => ({

...createConfiguredRouteState({

sessionKey: pluginSessionKey,

agentId: "main",

}),

configuredBinding: {

statefulTarget: {

kind: "stateful",

driverId: "codex",

sessionKey: pluginSessionKey,

agentId: "codex",

},

} as never,

}));

runtimeModuleMocks.getSessionEntry.mockReturnValue({

sessionId: "codex-session",

authProfileOverride: "openai-codex:owner@example.com",

updatedAt: Date.now(),

});

registerPairPlugin();

const command = await createPluginCommand({

cfg,

name: "pair",

});

const executeSpy = runtimeModuleMocks.executePluginCommand.mockResolvedValue({

text: "paired:now",

});

await (command as { run: (interaction: unknown) => Promise<void> }).run(

Object.assign(interaction, {

options: {

getString: () => "now",

getBoolean: () => null,

getFocused: () => "",

},

}) as unknown,

);

expectPluginCommandExecution({

mock: executeSpy,

commandName: "pair",

expected: {

agentId: "codex",

sessionKey: pluginSessionKey,

authProfileId: "openai-codex:owner@example.com",

},

});

expect(runtimeModuleMocks.getSessionEntry).toHaveBeenCalledWith({

agentId: "codex",

sessionKey: pluginSessionKey,

});

});

it("does not treat Discord DM allowlist users as scoped plugin command owners", async () => {

const cfg = {

channels: {

}

const messageThreadId = !isDirectMessage && isThreadChannel ? channelId : undefined;

const pluginThreadParentId = !isDirectMessage && isThreadChannel ? threadParentId : undefined;

const { effectiveRoute } = await getNativeRouteState();

const routeState = await getNativeRouteState();

const { effectiveRoute } = routeState;

const pluginCommandAgentId =

(isThreadChannel ? threadBindings.getByThreadId(rawChannelId)?.agentId : undefined) ||

routeState.configuredBinding?.statefulTarget.agentId ||

effectiveRoute.agentId;

const targetSessionEntry = nativeCommandRuntime.getSessionEntry({

agentId: effectiveRoute.agentId,

agentId: pluginCommandAgentId,

sessionKey: effectiveRoute.sessionKey,

});

const pluginReply = await nativeCommandRuntime.executePluginCommand({

channelId,

isAuthorizedSender: commandAuthorized,

senderIsOwner: senderIsCommandOwner,

agentId: pluginCommandAgentId,

sessionKey: effectiveRoute.sessionKey,

authProfileId: targetSessionEntry?.authProfileOverride,

commandBody: prompt,

channel: "telegram",

isAuthorizedSender: commandAuthorized,

senderIsOwner,

agentId: route.agentId,

sessionKey: targetSessionKey,

sessionId: sessionFileContext.sessionId,

sessionFile: sessionFileContext.sessionFile,

isAuthorizedSender: params.command.isAuthorizedSender,

senderIsOwner: params.command.senderIsOwner,

gatewayClientScopes: params.ctx.GatewayClientScopes,

agentId: params.agentId,

sessionKey: params.sessionKey,

sessionId: targetSessionEntry?.sessionId,

sessionFile: targetSessionEntry?.sessionFile,

isAuthorizedSender: command.isAuthorizedSender,

senderIsOwner: command.senderIsOwner,

gatewayClientScopes: params.ctx.GatewayClientScopes,

agentId: params.agentId,

sessionKey: params.sessionKey,

sessionId: targetSessionEntry?.sessionId,

sessionFile: targetSessionEntry?.sessionFile,

);

});

it("binds plugin-owned command sessions to the host-resolved agent", async () => {

const handler = async (ctx: {

runtimeContext?: {

llm?: {

complete: (params: {

messages: Array<{ role: "user"; content: string }>;

}) => Promise<unknown>;

};

};

}) => {

await ctx.runtimeContext?.llm?.complete({

messages: [{ role: "user", content: "summarize" }],

});

return { text: "ok" };

};

await executePluginCommand({

command: {

name: "runtimecheck",

description: "Demo command",

acceptsArgs: false,

handler,

pluginId: "demo-plugin",

},

channel: "discord",

senderId: "U123",

isAuthorizedSender: true,

agentId: "codex",

sessionKey: "plugin-binding:openclaw-codex-app-server:dm",

authProfileId: "openai-codex:owner@example.com",

commandBody: "/runtimecheck",

config: {} as never,

});

expect(completionMocks.prepareSimpleCompletionModelForAgent).toHaveBeenCalledWith(

expect.objectContaining({

agentId: "codex",

preferredProfile: "openai-codex:owner@example.com",

}),

);

});

it("normalizes undefined plugin command handler results to an empty reply payload", async () => {

const handler = async () => undefined as never;

function buildPluginCommandRuntimeContext(params: {

command: RegisteredPluginCommand;

config: OpenClawConfig;

agentId?: string;

sessionKey?: string;

authProfileId?: string;

}): PluginCommandContext["runtimeContext"] {

const sessionKey = params.sessionKey?.trim();

const agentId = resolveBoundAgentIdForSession({

config: params.config,

agentId: params.agentId,

sessionKey,

});

if (!sessionKey && !agentId) {

isAuthorizedSender: boolean;

senderIsOwner?: boolean;

gatewayClientScopes?: PluginCommandContext["gatewayClientScopes"];

/** Host-resolved agent authority for plugin-owned or non-agent-shaped session keys. */

agentId?: string;

sessionKey?: PluginCommandContext["sessionKey"];

sessionId?: PluginCommandContext["sessionId"];

sessionFile?: PluginCommandContext["sessionFile"];

runtimeContext: buildPluginCommandRuntimeContext({

command,

config,

agentId: params.agentId,

sessionKey: params.sessionKey,

authProfileId: params.authProfileId,

}),