class MyTask extends voice.AgentTask<string> {
    constructor() {
        super({instructions: 'Testing AgentTask...', allowInterruptions: true});
    }

    override async onEnter(): Promise<void> {
        this.session.say('Hello from MyTask!', { allowInterruptions: true });
        this.complete('Task completed successfully.');
    }
}

export class MyAgent extends voice.Agent {
    constructor() {
        super({
            instructions: 'You are a helpful assistant.',
            tools: {
                testTool: llm.tool({
                    description: 'Call when user request to execute to test this tool.',
                    parameters: {},
                    execute: async (_, { ctx }) => {
                        console.log('Executing test tool...');
                        await ctx.waitForPlayout();
                        return new MyTask().run();
                    }
                }),
                hangupTool: llm.tool({
                    description: 'Hang up the call when the user requests to end the call.',
                    parameters: {},
                    execute: async (_, { ctx }) => {
                        console.log('Executing hangup tool, ending call...');
                        await ctx.waitForPlayout();
                        const roomServiceClient = getRoomServiceClient();
                        await roomServiceClient.deleteRoom(getJobContext().room?.name!);
                    }
                })
            }
        });
    }
}

testTool

hangupTool

ctx.waitForPlayout()

getRoomServiceClient().deleteRoom(...)

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

// --- Replace these imports with your actual module paths ---
import { MyAgent } from '../src/my-agent'; // file that exports MyAgent
import * as agentRuntime from '@livekit/agents'; // if needed for types/mocks

// --- Mocks ---
// Mock context passed into tool execute functions
function makeCtxMock() {
  return {
    waitForPlayout: vi.fn().mockResolvedValue(undefined),
  };
}

// Mock getRoomServiceClient and getJobContext used in hangupTool
const mockDeleteRoom = vi.fn().mockResolvedValue(undefined);
vi.mock('../src/roomService', () => ({ // adjust path to where getRoomServiceClient is implemented
  getRoomServiceClient: () => ({ deleteRoom: mockDeleteRoom }),
  getJobContext: () => ({ room: { name: 'test-room' } }),
}));

describe('MyAgent tools', () => {
  let agent: MyAgent;
  let ctx: ReturnType<typeof makeCtxMock>;

  beforeEach(() => {
    // instantiate your agent
    agent = new MyAgent();
    ctx = makeCtxMock();
    mockDeleteRoom.mockClear();
    ctx.waitForPlayout.mockClear();
  });

  it('executes testTool then hangupTool (both handlers called)', async () => {
    // Find tools from agent config. This depends on how your Agent exposes tools.
    // If agent stores tools under `agent.tools`, use that; otherwise adapt accordingly.
    // For this example we assume `agent.tools` is a record of tool definitions.
    const tools = (agent as any).tools;
    expect(tools).toBeDefined();

    // Call testTool.execute
    const testTool = tools.testTool;
    expect(typeof testTool.execute).toBe('function');

    // Simulate LLM invoking the tool: execute returns whatever MyTask.run() returns.
    // We mock MyTask.run() if necessary to avoid heavy runtime behavior.
    // If your MyTask is internal and side-effect-free, call directly. Otherwise, stub it:
    const runSpy = vi.spyOn(require('../src/my-task'), 'MyTask').mockImplementation(() => {
      return {
        run: vi.fn().mockResolvedValue('Task completed successfully.'),
      };
    });

    const testRes = await testTool.execute({}, { ctx });
    expect(ctx.waitForPlayout).toHaveBeenCalled();
    expect(testRes).toBe('Task completed successfully.');
    runSpy.mockRestore();

    // Now call hangupTool.execute
    const hangupTool = tools.hangupTool;
    expect(typeof hangupTool.execute).toBe('function');

    const hangupRes = await hangupTool.execute({}, { ctx });
    expect(ctx.waitForPlayout).toHaveBeenCalledTimes(2); // once per tool if both call it
    expect(mockDeleteRoom).toHaveBeenCalledWith('test-room');
  });

  it('handles testTool run resolving and allows subsequent tool executions', async () => {
    // This test is similar but explicitly checks that a returned Task does not block further tools
    const tools = (agent as any).tools;

    // Let testTool.execute return a Promise that resolves after a short delay
    const originalTestExecute = tools.testTool.execute;
    const delay = (ms: number) => new Promise(r => setTimeout(r, ms));

    const slowRunSpy = vi.spyOn(require('../src/my-task'), 'MyTask').mockImplementation(() => {
      return {
        run: vi.fn().mockImplementation(async () => {
          await delay(20); // emulate async work
          return 'Task done';
        }),
      };
    });

    // Start testTool but don't await immediately to simulate overlapping operations
    const testPromise = tools.testTool.execute({}, { ctx });

    // While testTool is still pending, invoke hangupTool
    const hangupPromise = tools.hangupTool.execute({}, { ctx });

    const [testValue, hangupValue] = await Promise.all([testPromise, hangupPromise]);

    expect(testValue).toBe('Task done');
    expect(hangupValue).toBeUndefined(); // hangupTool.execute may return void
    expect(mockDeleteRoom).toHaveBeenCalled();
    slowRunSpy.mockRestore();
  });
});

(agent as any).tools

MyTask

run

getRoomServiceClient

getJobContext

testTool.execute

hangupTool.execute

ctx.waitForPlayout()

waitForPlayout()

MyAgent

MyTask

getRoomServiceClient

getJobContext