Skip to content

Your always-on AI coworkers that move between text, calls, and Slack.

TypeScript
8.3 KB
Raw Blame
import { afterEach, expect, it, vi } from 'vitest';
import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { EventType, type RunAgentInput } from '@ag-ui/core';
import { lastValueFrom, toArray } from 'rxjs';
import { DotAgent } from '../src/server/dot-agent.js';
import {
  DEFAULT_AGENT_RUN_TIMEOUT_MS,
  agentRunTimeoutMsFromEnv,
} from '../src/server/platform-config.js';
import { Runner } from '../src/server/runner.js';
import { Store } from '../src/server/store.js';
import { WorkspaceStore } from '../src/server/workspace.js';

const composio = vi.hoisted(() => ({ session: vi.fn() }));
vi.mock('../src/server/composio.js', () => ({
  composioSession: composio.session,
}));

const resources: Array<{ close(): void }> = [];
function sharedStores() {
  const dir = mkdtempSync(join(tmpdir(), 'opendots-timeout-'));
  const path = join(dir, 'test.sqlite');
  const first = new Store(path);
  const second = new Store(path);
  resources.push(first, second, {
    close: () => rmSync(dir, { recursive: true, force: true }),
  });
  return { first, second };
}
afterEach(() => {
  vi.restoreAllMocks();
  composio.session.mockReset();
  vi.useRealTimers();
  resources.splice(0).forEach((resource) => resource.close());
});

it('uses 90 seconds by default and accepts a positive integer override', () => {
  expect(agentRunTimeoutMsFromEnv({})).toBe(DEFAULT_AGENT_RUN_TIMEOUT_MS);
  expect(agentRunTimeoutMsFromEnv({ AGENT_RUN_TIMEOUT_MS: ' 240000 ' })).toBe(
    240_000,
  );
});

it('rejects invalid timeout overrides at startup', () => {
  for (const value of ['0', '-1', '1.5', 'not-a-number', '2147483648'])
    expect(() =>
      agentRunTimeoutMsFromEnv({ AGENT_RUN_TIMEOUT_MS: value }),
    ).toThrow(/AGENT_RUN_TIMEOUT_MS/);
});

it('finishes an interactive turn when Composio startup stalls', async () => {
  vi.useFakeTimers();
  const store = new Store(':memory:');
  const workspace = new WorkspaceStore(':memory:', 'owner');
  resources.push(store, workspace);
  const dot = workspace.dots()[0];
  store.updateSettings({ appsAllowed: true });
  workspace.updateDot(dot.id, { ...dot, appsAllowed: true });
  workspace.bindThread('thread', dot.id, 'Timeout test');
  const agent = new DotAgent(
    store,
    workspace,
    {
      intelligenceKey: 'fixture',
      apiKey: 'fixture',
      model: 'custom-model',
      composioApiKey: 'fixture',
      baseUrl: 'https://unused.invalid/v1',
      runtimeUrl: '',
      voiceName: 'marin',
      slackUsers: [],
      agentRunTimeoutMs: 1_250,
    },
    dot.id,
  );
  const input: RunAgentInput = {
    threadId: 'thread',
    runId: 'run',
    state: {},
    context: [],
    messages: [{ id: 'user', role: 'user', content: 'Keep working.' }],
    tools: [],
    forwardedProps: {},
  };
  composio.session.mockReturnValue(new Promise(() => {}));

  const finished = lastValueFrom(agent.run(input).pipe(toArray()));
  await vi.advanceTimersByTimeAsync(1_251);
  const events = await finished;

  expect(events).toEqual([
    expect.objectContaining({
      type: EventType.RUN_ERROR,
      message: expect.stringContaining('1.25 second time limit'),
    }),
  ]);
  const signal = composio.session.mock.calls[0][4] as AbortSignal;
  expect(signal.aborted).toBe(true);
});

it('does not start the inner agent after Composio startup is cancelled', async () => {
  const store = new Store(':memory:');
  const workspace = new WorkspaceStore(':memory:', 'owner');
  resources.push(store, workspace);
  const dot = workspace.dots()[0];
  store.updateSettings({ appsAllowed: true });
  workspace.updateDot(dot.id, { ...dot, appsAllowed: true });
  workspace.bindThread('thread', dot.id, 'Cancellation test');
  const agent = new DotAgent(
    store,
    workspace,
    {
      intelligenceKey: 'fixture',
      apiKey: 'fixture',
      model: 'custom-model',
      composioApiKey: 'fixture',
      baseUrl: 'https://unused.invalid/v1',
      runtimeUrl: '',
      voiceName: 'marin',
      slackUsers: [],
    },
    dot.id,
  );
  let resolveSession!: (session: unknown) => void;
  composio.session.mockReturnValue(
    new Promise((resolve) => {
      resolveSession = resolve;
    }),
  );
  const network = vi.spyOn(globalThis, 'fetch');
  const finished = lastValueFrom(
    agent
      .run({
        threadId: 'thread',
        runId: 'run',
        state: {},
        context: [],
        messages: [{ id: 'user', role: 'user', content: 'Keep working.' }],
        tools: [],
        forwardedProps: {},
      })
      .pipe(toArray()),
  );

  const tools = vi.fn().mockResolvedValue([]);
  agent.abortRun();
  resolveSession({ tools });
  await finished;

  expect(tools).not.toHaveBeenCalled();
  expect(network).not.toHaveBeenCalled();
});

it('uses the configured timeout for scheduled/background runs', async () => {
  vi.useFakeTimers();
  const store = new Store(':memory:');
  resources.push(store);
  let signal: AbortSignal | undefined;
  const runner = new Runner(
    store,
    { mode: 'sample', baseUrl: '' },
    (_claim, _memories, runSignal) =>
      new Promise((_resolve, reject) => {
        signal = runSignal;
        runSignal.addEventListener('abort', () => reject(runSignal.reason), {
          once: true,
        });
      }),
    1_250,
  );
  store.createTask('Long-running task');
  const pending = runner.tick();
  await vi.advanceTimersByTimeAsync(1_251);
  await pending;
  expect(signal?.aborted).toBe(true);
  expect(store.tasks()[0].status).toBe('failed');
});

it('completes a longer background run after another worker checks the old lease deadline', async () => {
  vi.useFakeTimers();
  const { first, second } = sharedStores();
  const result = {
    text: 'Finished after 200 seconds',
    sources: [],
    sample: true,
  };
  let signal: AbortSignal | undefined;
  const runner = new Runner(
    first,
    { mode: 'sample', baseUrl: '' },
    (_claim, _memories, runSignal) =>
      new Promise((resolve, reject) => {
        signal = runSignal;
        const timer = setTimeout(() => resolve(result), 200_000);
        runSignal.addEventListener(
          'abort',
          () => {
            clearTimeout(timer);
            reject(runSignal.reason);
          },
          { once: true },
        );
      }),
    240_000,
  );
  const competingExecute = vi.fn().mockResolvedValue(result);
  const competing = new Runner(
    second,
    { mode: 'sample', baseUrl: '' },
    competingExecute,
  );
  const task = first.createTask('Long-running task');
  const pending = runner.tick();
  const lease = first.task(task.id)?.lease;
  try {
    await vi.advanceTimersByTimeAsync(180_001);
    await competing.tick();
    expect(second.task(task.id)?.status).toBe('running');
    expect(second.task(task.id)?.lease).toBe(lease);
    expect(signal?.aborted).toBe(false);
    expect(competingExecute).not.toHaveBeenCalled();

    await vi.advanceTimersByTimeAsync(20_000);
    await pending;
    expect(second.task(task.id)?.status).toBe('completed');
    expect(second.detail(task.id)?.runs).toEqual([
      expect.objectContaining({ status: 'completed', result }),
    ]);
  } finally {
    runner.stop();
    competing.stop();
    await pending;
  }
});

it('still times out a longer background run after another worker checks its lease', async () => {
  vi.useFakeTimers();
  const { first, second } = sharedStores();
  let signal: AbortSignal | undefined;
  const runner = new Runner(
    first,
    { mode: 'sample', baseUrl: '' },
    (_claim, _memories, runSignal) =>
      new Promise((_resolve, reject) => {
        signal = runSignal;
        runSignal.addEventListener('abort', () => reject(runSignal.reason), {
          once: true,
        });
      }),
    240_000,
  );
  const competing = new Runner(second, { mode: 'sample', baseUrl: '' });
  const task = first.createTask('Long-running task');
  const pending = runner.tick();
  try {
    await vi.advanceTimersByTimeAsync(180_001);
    await competing.tick();
    expect(second.task(task.id)?.status).toBe('running');
    expect(signal?.aborted).toBe(false);

    await vi.advanceTimersByTimeAsync(60_000);
    await pending;
    expect(signal?.aborted).toBe(true);
    expect(second.task(task.id)?.status).toBe('failed');
    expect(second.detail(task.id)?.runs).toEqual([
      expect.objectContaining({
        status: 'failed',
        error: 'Research exceeded the 240 second time limit.',
      }),
    ]);
  } finally {
    runner.stop();
    competing.stop();
    await pending;
  }
});