// Agent step tests cover nested session handoff, transcript bookkeeping, and

// MCP runtime retirement after completed nested turns.

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

import type { CallGatewayOptions } from "../../gateway/call.js";

import { runAgentStep, testing } from "./agent-step.js";

});

it("retires bundle MCP runtime after successful nested agent steps", async () => {

// Nested steps disable automatic delivery and carry provenance so the reply

// returns through the message tool path instead of the channel.

const gatewayCalls: CallGatewayOptions[] = [];

testing.setDepsForTest({

callGateway: async <T = unknown>(opts: CallGatewayOptions): Promise<T> => {

// Cron tool tests cover schedule guidance, scoped job operations, delivery

// context inheritance, session routing, and agent id ownership.

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

const { callGatewayMock, extractDeliveryInfoMock } = vi.hoisted(() => ({

});

it("allows scoped isolated cron runs to remove the current job", async () => {

// Self-removal scope lets a cron-triggered run clean up its own schedule

// without granting broad cron mutation access.

const tool = createTestCronTool({ selfRemoveOnlyJobId: "job-current" });

await tool.execute("call-self-remove", {

// Music background tests cover task-run creation, progress recording, and

// completion delivery through announcement agents or direct fallback sends.

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

import { MUSIC_GENERATION_TASK_KIND } from "../music-generation-task-status.js";

import {

} = await import("./music-generate-background.js");

function getDeliveredInternalEvents(): Array<Record<string, unknown>> {

// Completion agents receive internal events; tests inspect them to keep the

// visible-reply media contract explicit.

const params = announceDeliveryMocks.deliverSubagentAnnouncement.mock.calls.at(0)?.[0] as

| { internalEvents?: unknown }

| undefined;

// Music generation tool tests cover provider selection, task lifecycle updates,

// duplicate guards, media persistence, and result delivery metadata.

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

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

import * as mediaStore from "../../media/store.js";

}));

const musicGenerateBackgroundMocks = vi.hoisted(() => ({

// Mirror the background lifecycle contract so tool tests can assert task-run

// effects without spawning detached completion workers.

musicGenerationTaskLifecycle: {

createTaskRun: (

params: Parameters<typeof musicGenerateBackground.createMusicGenerationTaskRun>[0],

// Nodes tool tests cover gateway-scoped node actions, media payload writing,

// numeric schema guardrails, and pairing approval scopes.

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

const gatewayMocks = vi.hoisted(() => ({

requiredApproveScopes?: string[];

commands?: string[];

}): void {

// Pairing approval is two-step by design: list pending requests under the

// operator scope, then approve with the request's required scopes.

gatewayMocks.callGatewayTool.mockImplementation(async (method, _opts, params, extra) => {

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

return {

// TTS tool tests cover guidance, speech runtime arguments, delivery metadata,

// timeout validation, and reply-directive defusing.

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

import * as ttsRuntime from "../../tts/tts.js";

import { createTtsTool } from "./tts-tool.js";

}

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

// Speech runtime args are the public handoff between the model-facing tool

// and provider-specific synthesis backends.

return requireRecord(textToSpeechSpy.mock.calls.at(-1)?.[0], "text-to-speech args");

}

// Web search tests cover model-facing schema limits, provider-specific time

// filters, unsupported filter errors, and scoped provider config merging.

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

import {

MAX_SEARCH_COUNT,

expect(merged?.brave).toEqual({ apiKey: "brave-test-key" });

expect(merged?.apiKey).toBe("brave-test-key");

// Injected provider detail is available to runtime validation but hidden

// from ordinary config serialization.

expect(Object.keys(merged ?? {})).toEqual(["provider", "apiKey"]);

expect(Object.getOwnPropertyDescriptor(merged, "brave")?.enumerable).toBe(false);

});

// Web tool runtime-context tests cover late-bound config snapshots and

// plugin-owner lookups for search/fetch provider selection.

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

import {

resolveWebFetchToolRuntimeContext,

}));

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

// Owner lookups are the evidence for whether runtime providers stay enabled

// or a configured plugin takes over the tool call.

const params = mocks.resolveManifestContractOwnerPluginId.mock.calls.at(-1)?.[0];

if (!params || typeof params !== "object") {

throw new Error("expected owner lookup params");

// Web readability tests cover plugin extractor dispatch, per-config resolver

// caching, and loader/extractor failure fallback.

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

const { resolvePluginWebContentExtractorsMock } = vi.hoisted(() => ({

});

it("reuses extractor resolution for repeated calls with the same config object", async () => {

// Extractor manifests are process-stable for a config snapshot; repeated

// reads should not re-run plugin discovery on the fetch hot path.

const config = {};

resolvePluginWebContentExtractorsMock.mockReturnValue([

{