// Verifies OpenClaw-owned tool hooks preserve adjusted params and telemetry.

import type { AgentTool } from "openclaw/plugin-sdk/agent-core";

import {

installOpenClawOwnedToolHooks,

type ToolExecutionEndEvent = Parameters<typeof handleToolExecutionEnd>[1];

function createToolHandlerCtx(): ToolHandlerContext {

// Minimal embedded-agent tool handler context used to drive start/end events.

return {

params: {

runId: "run-contract",

async function waitForAfterToolCall(hooks: {

afterToolCall: { mock: { calls: unknown[][] } };

}): Promise<[Record<string, unknown>, Record<string, unknown>]> {

// after_tool_call fires asynchronously after the execution-end event is processed.

await vi.waitFor(() => {

expect(hooks.afterToolCall).toHaveBeenCalledTimes(1);

});

// Verifies agents_list reports only subagents visible to the requester.

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

import { createPerSenderSessionConfig } from "./test-helpers/session-config.js";

import { createAgentsListTool } from "./tools/agents-list-tool.js";

type AgentConfig = NonNullable<NonNullable<typeof configOverride.agents>["list"]>[number];

function setConfigWithAgentList(agentList: AgentConfig[]) {

// Each test gets a fresh per-sender session config plus its agent list.

configOverride = {

session: createPerSenderSessionConfig(),

agents: {

}

function readAgentList(result: unknown) {

// Tool results expose the machine-readable agent list in details.

return (result as { details?: { agents?: Array<{ id: string; configured?: boolean }> } })

.details?.agents;

}

// Verifies OpenClaw plugin tools are resolved with browser/runtime context.

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

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

import { resetConfigRuntimeState, setRuntimeConfigSnapshot } from "../config/config.js";

}));

function firstResolvePluginToolsParams(): Record<string, unknown> {

// Captures the plugin runtime contract passed from OpenClaw tool resolution.

const call = hoisted.resolvePluginTools.mock.calls[0];

if (!call) {

throw new Error("Expected plugin tool resolution");

});

it("does not pass a stale active snapshot as plugin runtime config for a resolved run config", () => {

// Resolved run config must win over any process-global runtime snapshot.

const staleSourceConfig = {

plugins: {

allow: ["old-plugin"],

// Verifies node camera/photo tool payloads, media URLs, and vision gating.

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

import {

readFileUtf8AndCleanup,

}

function getNodesTool(options?: { modelHasVision?: boolean; allowMediaInvokeCommands?: boolean }) {

// Tests vary only model vision capability and media invoke permission.

return createNodesTool({

...(options?.modelHasVision !== undefined ? { modelHasVision: options.modelHasVision } : {}),

...(options?.allowMediaInvokeCommands !== undefined

params?: Record<string, unknown>;

},

) {

// Node command payloads are nested under the gateway node.invoke params object.

const record = requireRecord(invokeParams, "node.invoke params");

expect(record.command).toBe(expected.command);

if (expected.nodeId !== undefined) {

onInvoke?: (invokeParams: unknown) => GatewayMockResult | Promise<GatewayMockResult>;

invokePayload?: unknown;

}) {

// Most camera tests need node.list followed by one node.invoke command.

callGateway.mockImplementation(async ({ method, params: invokeParams }: GatewayCall) => {

if (method === "node.list") {

return mockNodeList({ commands: params.commands, remoteIp: params.remoteIp });

// Shared registration assertions for optional media-generation OpenClaw tools.

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

import { collectPresentOpenClawTools } from "./openclaw-tools.registration.js";

import { textResult, type AnyAgentTool } from "./tools/common.js";

function stubAgentTool(name: string): AnyAgentTool {

// Registration tests only need a structurally valid tool.

return {

label: name,

name,

// Verifies image-generation tool registration through the shared generation harness.

import { describeOpenClawGenerationToolRegistration } from "./openclaw-tools.generation.test-support.js";

describeOpenClawGenerationToolRegistration({