Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

6.3 KB
Raw Blame
/** @vitest-environment jsdom */
import type { IssueResult } from '@core/agent-session/AgentSession';
import type { PendingInteraction } from '@service-agent-fold/generated/types';
import type { AgentAction } from '@service-agent-harness/generated/schemas';
import { err, ok } from 'neverthrow';
import { createRoot, createSignal } from 'solid-js';
import { describe, expect, it, vi } from 'vitest';
import type { InteractionResponse } from '../context/interaction';
import { createInteractionController } from './create-interaction-controller';

const permission = {
  kind: 'permission',
  requestId: 7,
  turn: 0,
  toolCall: 'tool',
  options: [{ id: 'once', name: 'Allow once', kind: 'allow_once' }],
} satisfies PendingInteraction;
const question = {
  kind: 'elicitation',
  requestId: '7',
  turn: 0,
  toolCall: null,
  message: 'Which colour?',
  request: {
    kind: 'form',
    schema: { title: null, description: null, properties: [], required: [] },
  },
} satisfies PendingInteraction;
const approval = {
  ...permission,
  answer: { kind: 'selected', optionId: 'once' },
} satisfies InteractionResponse;
const answer = {
  ...question,
  answer: { action: 'accept', content: { colour: 'teal' } },
} satisfies InteractionResponse;
const accepted: IssueResult = ok({ actionId: 'accepted', status: 'sent' });

function setup() {
  const [sessionId, setSessionId] = createSignal<string | undefined>(
    'session-a'
  );
  const [pending, setPending] = createSignal<PendingInteraction[]>([
    permission,
    question,
  ]);
  const [canEdit, setCanEdit] = createSignal<boolean | undefined>(true);
  const issue = vi.fn<
    (action: AgentAction) => Promise<IssueResult> | undefined
  >(() => Promise.resolve(accepted));
  const onFailure = vi.fn();
  const { controller, dispose } = createRoot((dispose) => ({
    controller: createInteractionController({
      sessionId,
      pending,
      canEdit,
      issue,
      onFailure,
    }),
    dispose,
  }));
  return {
    controller,
    dispose,
    issue,
    onFailure,
    setSessionId,
    setPending,
    setCanEdit,
  };
}

describe('interaction responses', () => {
  it('preserves each response type and numeric versus string request ids', async () => {
    const { controller, issue, dispose } = setup();
    expect(await controller.respond(approval)).toBe(true);
    expect(await controller.respond(answer)).toBe(true);
    expect(issue.mock.calls.map(([action]) => action)).toEqual([
      { type: 'respondToPermission', requestId: 7, answer: approval.answer },
      { type: 'respondElicitation', requestId: '7', ...answer.answer },
    ]);
    dispose();
  });

  it.each([approval, answer])(
    'deduplicates an in-flight $kind response',
    async (response) => {
      const { controller, issue, dispose } = setup();
      const first = controller.respond(response);
      expect(controller.answering(response)).toBe(true);
      expect(await controller.respond(response)).toBe(false);
      expect(issue).toHaveBeenCalledTimes(1);
      expect(await first).toBe(true);
      expect(controller.answering(response)).toBe(false);
      dispose();
    }
  );

  it.each([false, undefined])(
    'requires loaded edit access (%s)',
    async (canEdit) => {
      const { controller, issue, setCanEdit, dispose } = setup();
      setCanEdit(canEdit);
      expect(controller.canAnswer()).toBe(false);
      expect(await controller.respond(approval)).toBe(false);
      expect(await controller.respond(answer)).toBe(false);
      expect(issue).not.toHaveBeenCalled();
      dispose();
    }
  );

  it('rejects dead requests and ids reused by a later turn', async () => {
    const { controller, issue, setPending, dispose } = setup();
    setPending([
      { ...permission, turn: 1 },
      { ...question, turn: 1 },
    ]);
    expect(await controller.respond(approval)).toBe(false);
    expect(await controller.respond(answer)).toBe(false);
    setPending([]);
    expect(await controller.respond({ ...approval, turn: 1 })).toBe(false);
    expect(issue).not.toHaveBeenCalled();
    dispose();
  });

  it('does not confuse numeric ids with string ids of the same kind', async () => {
    const { controller, issue, setPending, dispose } = setup();
    setPending([{ ...permission, requestId: '7' }]);
    expect(await controller.respond(approval)).toBe(false);
    expect(await controller.respond({ ...approval, requestId: '7' })).toBe(
      true
    );
    expect(issue).toHaveBeenCalledTimes(1);
    dispose();
  });

  it('reports a stale response once and allows a retry after refusal', async () => {
    const { controller, issue, onFailure, dispose } = setup();
    issue.mockResolvedValueOnce(
      err([{ code: 'CONFLICT', message: 'answered' }])
    );
    expect(await controller.respond(approval)).toBe(false);
    expect(onFailure).toHaveBeenCalledExactlyOnceWith(
      'The agent is no longer waiting on that request'
    );
    expect(await controller.respond(approval)).toBe(true);
    dispose();
  });

  it('releases answers after a network error or a disappearing session', async () => {
    const { controller, issue, onFailure, setSessionId, dispose } = setup();
    issue.mockRejectedValueOnce(new Error('network'));
    expect(await controller.respond(answer)).toBe(false);
    expect(controller.answering(answer)).toBe(false);
    expect(onFailure).toHaveBeenCalledExactlyOnceWith(
      "Couldn't send your answer"
    );
    issue.mockReturnValueOnce(undefined);
    expect(await controller.respond(answer)).toBe(false);
    expect(onFailure).toHaveBeenCalledTimes(1);
    setSessionId(undefined);
    expect(await controller.respond(approval)).toBe(false);
    expect(issue).toHaveBeenCalledTimes(2);
    dispose();
  });

  it('keeps in-flight answers scoped to the session that issued them', async () => {
    const { controller, issue, setSessionId, dispose } = setup();
    const releases: ((result: IssueResult) => void)[] = [];
    issue.mockImplementation(
      () => new Promise((resolve) => releases.push(resolve))
    );
    const first = controller.respond(approval);
    setSessionId('session-b');
    expect(controller.answering(approval)).toBe(false);
    const second = controller.respond(approval);
    releases[0](accepted);
    await first;
    expect(controller.answering(approval)).toBe(true);
    releases[1](accepted);
    await second;
    expect(controller.answering(approval)).toBe(false);
    dispose();
  });
});