Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

18.0 KB
Raw Blame
import { describe, expect, it } from 'vitest';

import type { VaultRequest, WorkbenchMessage } from '@/context/ApiContext';
import {
  isVaultApprovalRequest,
  vaultApprovalNeedsPasskey,
  placeVaultProvisionRequests,
  vaultRequestType,
} from './vaultRequestPlacement';

const message = (
  id: string,
  createdAt: string,
  author = 'agent',
  deliveredAt: string | null = null,
): WorkbenchMessage => ({
  id,
  scope_id: null,
  session_id: 'ses_test',
  platform: 'avibe',
  author,
  type: author === 'agent' ? 'result' : 'user',
  source: author,
  author_id: null,
  author_name: null,
  native_message_id: null,
  parent_native_message_id: null,
  text: id,
  content: {},
  metadata: {},
  created_at: createdAt,
  updated_at: createdAt,
  delivered_at: deliveredAt,
  read_at: null,
});

const request = (
  id: string,
  type: string,
  createdAt: string,
  messageId: string | null = null,
  requester: unknown = {},
): VaultRequest => ({
  id,
  request_type: type,
  secret_name: 'API_KEY',
  requester,
  delivery: {},
  status: 'pending',
  message_id: messageId,
  created_at: createdAt,
  decided_at: null,
  expires_at: null,
});

const orderedMessage = (
  idSuffix: string,
  orderAt: string,
  createdAt: string,
  author = 'agent',
): WorkbenchMessage => {
  const microseconds = Math.floor(Date.parse(orderAt) * 1_000);
  return message(`msg_${microseconds.toString(16).padStart(15, '0')}${idSuffix}`, createdAt, author);
};

const microsecondMessage = (
  idSuffix: string,
  microsecondsAfterSecond: number,
  author = 'agent',
): WorkbenchMessage => {
  const secondStart = Date.parse('2026-07-30T10:00:00Z') * 1_000;
  return message(
    `msg_${(secondStart + microsecondsAfterSecond).toString(16).padStart(15, '0')}${idSuffix}`,
    '2026-07-30T10:00:00Z',
    author,
  );
};

describe('vaultRequestType', () => {
  it('keeps provision separate from access and sign approvals', () => {
    expect(vaultRequestType(request('p', 'provision', '2026-07-30T10:00:00Z'))).toBe('provision');
    expect(isVaultApprovalRequest(request('a', 'access', '2026-07-30T10:00:00Z'))).toBe(true);
    expect(isVaultApprovalRequest(request('s', 'sign', '2026-07-30T10:00:00Z'))).toBe(true);
    expect(vaultRequestType(request('d', 'delete', '2026-07-30T10:00:00Z'))).toBe('delete');
    expect(isVaultApprovalRequest(request('d', 'delete', '2026-07-30T10:00:00Z'))).toBe(true);
    expect(vaultApprovalNeedsPasskey({ ...request('d', 'delete', '2026-07-30T10:00:00Z'), card: { request_type: 'delete', protection: 'protected' } })).toBe(false);
    expect(isVaultApprovalRequest(request('p', 'provision', '2026-07-30T10:00:00Z'))).toBe(false);
  });
});

describe('placeVaultProvisionRequests', () => {
  const messages = [
    message('user-before', '2026-07-30T09:59:00Z', 'user'),
    message('agent-owner', '2026-07-30T10:00:10Z'),
    message('agent-later', '2026-07-30T10:01:00Z'),
  ];

  it('uses an explicit Agent message anchor when one is present', () => {
    const placed = placeVaultProvisionRequests(
      messages,
      [request('p', 'provision', '2026-07-30T10:00:00Z', 'agent-later')],
    );

    expect(placed.byMessageId.get('agent-later')?.map((item) => item.id)).toEqual(['p']);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('keeps an unresolved explicit reply id out of the transcript', () => {
    const placed = placeVaultProvisionRequests(
      [message('unrelated-reply', '2026-07-30T10:01:00Z')],
      [request('missing-reply', 'provision', '2026-07-30T10:00:00Z', 'trimmed-reply')],
    );

    expect(placed.byMessageId).toEqual(new Map());
    expect(placed.awaitingReply).toEqual([]);
  });

  it('anchors legacy requests to the first Agent reply after creation', () => {
    const placed = placeVaultProvisionRequests(
      messages,
      [request('p', 'provision', '2026-07-30T10:00:00Z')],
    );

    expect(placed.byMessageId.get('agent-owner')?.map((item) => item.id)).toEqual(['p']);
    expect(placed.byMessageId.has('agent-later')).toBe(false);
  });

  it('keeps a nonterminal Agent output eligible to own its request card', () => {
    const output = { ...message('agent-output', '2026-07-30T10:00:10Z'), type: 'output' };
    const placed = placeVaultProvisionRequests(
      [output],
      [request('p', 'provision', '2026-07-30T10:00:00Z', output.id)],
    );

    expect(placed.byMessageId.get(output.id)?.map((item) => item.id)).toEqual(['p']);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('skips interim narration when inferring the request owner', () => {
    const interim = { ...message('agent-interim', '2026-07-30T10:00:05Z'), type: 'interim' };
    const reply = message('agent-reply', '2026-07-30T10:00:10Z');
    const placed = placeVaultProvisionRequests(
      [message('user-before', '2026-07-30T09:59:00Z', 'user'), interim, reply],
      [request('p', 'provision', '2026-07-30T10:00:00Z')],
    );

    expect(placed.byMessageId.get(reply.id)?.map((item) => item.id)).toEqual(['p']);
    expect(placed.byMessageId.has(interim.id)).toBe(false);
  });

  it('does not infer an unrelated detached completion as the request owner', () => {
    const detached = {
      ...message('background-completion', '2026-07-30T10:00:05Z'),
      metadata: { detached: true, turn_id: 'turn-background' },
    };
    const current = {
      ...message('current-reply', '2026-07-30T10:00:10Z'),
      metadata: { turn_id: 'turn-current' },
    };
    const placed = placeVaultProvisionRequests(
      [message('user-before', '2026-07-30T09:59:00Z', 'user'), detached, current],
      [request('p', 'provision', '2026-07-30T10:00:00Z')],
    );

    expect(placed.byMessageId.has(detached.id)).toBe(false);
    expect(placed.byMessageId.get(current.id)?.map((item) => item.id)).toEqual(['p']);
  });

  it('accepts a detached completion only when request provenance matches', () => {
    const detached = {
      ...message('background-completion', '2026-07-30T10:00:05Z'),
      metadata: { detached: true, turn_id: 'turn-background' },
    };
    const placed = placeVaultProvisionRequests(
      [detached],
      [
        request(
          'p',
          'provision',
          '2026-07-30T10:00:00Z',
          null,
          { turn_id: 'turn-background' },
        ),
      ],
    );

    expect(placed.byMessageId.get(detached.id)?.map((item) => item.id)).toEqual(['p']);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('uses the message id clock when the reply shares the request second', () => {
    const sameSecondMessages = [
      orderedMessage('11111111', '2026-07-30T10:00:00.100Z', '2026-07-30T10:00:00Z', 'user'),
      orderedMessage('22222222', '2026-07-30T10:00:00.800Z', '2026-07-30T10:00:00Z'),
    ];
    const placed = placeVaultProvisionRequests(sameSecondMessages, [
      request('p', 'provision', '2026-07-30T10:00:00.500Z'),
    ]);

    expect(placed.byMessageId.get(sameSecondMessages[1].id)?.map((item) => item.id)).toEqual(['p']);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('does not round a request back onto an earlier reply in the same millisecond', () => {
    const earlierInput = microsecondMessage('11111111', 100_000, 'user');
    const earlierReply = microsecondMessage('22222222', 500_100);
    const ownerReply = microsecondMessage('33333333', 500_950);
    const placed = placeVaultProvisionRequests([earlierInput, earlierReply, ownerReply], [
      request('p', 'provision', '2026-07-30T10:00:00.500900Z'),
    ]);

    expect(placed.byMessageId.has(earlierReply.id)).toBe(false);
    expect(placed.byMessageId.get(ownerReply.id)?.map((item) => item.id)).toEqual(['p']);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('does not cross a later user or harness input-turn boundary', () => {
    for (const boundaryKind of ['user', 'harness'] as const) {
      const origin = orderedMessage('11111111', '2026-07-30T10:00:00.100Z', '2026-07-30T10:00:00Z', 'user');
      const boundary = orderedMessage('22222222', '2026-07-30T10:00:00.700Z', '2026-07-30T10:00:00Z', boundaryKind);
      if (boundaryKind === 'harness') boundary.type = 'harness';
      const unrelated = orderedMessage('33333333', '2026-07-30T10:00:00.900Z', '2026-07-30T10:00:00Z');
      const placed = placeVaultProvisionRequests([origin, boundary, unrelated], [
        request(`p-${boundaryKind}`, 'provision', '2026-07-30T10:00:00.500Z'),
      ]);

      expect([...placed.byMessageId]).toEqual([]);
      expect(placed.awaitingReply).toEqual([]);
    }
  });

  it('uses an available turn identity before the timestamp fallback', () => {
    const identifiedMessages = messages.map((item) => item.id === 'agent-later'
      ? { ...item, metadata: { turn_id: 'turn-owner' } }
      : item);
    const placed = placeVaultProvisionRequests(identifiedMessages, [
      request('p', 'provision', '2026-07-30T10:00:00Z', null, { turn_id: 'turn-owner' }),
    ]);

    expect(placed.byMessageId.get('agent-later')?.map((item) => item.id)).toEqual(['p']);
    expect(placed.byMessageId.has('agent-owner')).toBe(false);
  });

  it('uses the requester input message when the request was persisted after its reply', () => {
    const source = message('source-user', '2026-07-30T10:00:00Z', 'user');
    const reply = message('owner-reply', '2026-07-30T10:01:00Z', 'agent');
    const placed = placeVaultProvisionRequests(
      [source, reply],
      [request('late', 'provision', '2026-07-30T10:02:00Z', null, { message_id: source.id })],
    );

    expect(placed.byMessageId.get(reply.id)?.map((item) => item.id)).toEqual(['late']);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('resolves a native requester message id to its durable transcript row', () => {
    const source = { ...message('source-user', '2026-07-30T10:00:00Z', 'user'), native_message_id: 'slack-source' };
    const reply = message('owner-reply', '2026-07-30T10:01:00Z', 'agent');
    const placed = placeVaultProvisionRequests(
      [source, reply],
      [request('native-late', 'provision', '2026-07-30T10:02:00Z', null, { message_id: 'slack-source' })],
    );

    expect(placed.byMessageId.get(reply.id)?.map((item) => item.id)).toEqual(['native-late']);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('scopes native requester matching to the originating platform', () => {
    const webSource = {
      ...message('web-source', '2026-07-30T10:00:00Z', 'user'),
      platform: 'web',
      native_message_id: 'shared-source',
    };
    const webReply = { ...message('web-reply', '2026-07-30T10:01:00Z'), platform: 'web' };
    const slackSource = {
      ...message('slack-source', '2026-07-30T10:02:00Z', 'user'),
      platform: 'slack',
      native_message_id: 'shared-source',
    };
    const slackReply = { ...message('slack-reply', '2026-07-30T10:03:00Z'), platform: 'slack' };
    const placed = placeVaultProvisionRequests(
      [webSource, webReply, slackSource, slackReply],
      [request('native-platform', 'provision', '2026-07-30T10:04:00Z', null, {
        message_id: 'shared-source',
        platform: 'slack',
      })],
    );

    expect(placed.byMessageId.get(slackReply.id)?.map((item) => item.id)).toEqual(['native-platform']);
    expect(placed.byMessageId.has(webReply.id)).toBe(false);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('uses a resolved durable source override for stable turn identities', () => {
    const source = message('source-user', '2026-07-30T10:00:00Z', 'user');
    const reply = message('owner-reply', '2026-07-30T10:01:00Z', 'agent');
    const placed = placeVaultProvisionRequests(
      [source, reply],
      [request('turn-late', 'provision', '2026-07-30T10:02:00Z', null, { turn_id: 'turn-owner' })],
      new Map([['turn-late', source.id]]),
    );

    expect(placed.byMessageId.get(reply.id)?.map((item) => item.id)).toEqual(['turn-late']);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('does not cross a later input when resolving from the requester message', () => {
    const source = message('source-user', '2026-07-30T10:00:00Z', 'user');
    const boundary = message('later-user', '2026-07-30T10:01:00Z', 'user');
    const reply = message('unrelated-reply', '2026-07-30T10:02:00Z', 'agent');
    const placed = placeVaultProvisionRequests(
      [source, boundary, reply],
      [request('late', 'provision', '2026-07-30T10:03:00Z', null, { message_id: source.id })],
    );

    expect([...placed.byMessageId]).toEqual([]);
    // Created after the latest turn's reply: the newest pending state, so it
    // waits at the tail rather than borrowing that unrelated reply.
    expect(placed.awaitingReply.map((item) => item.id)).toEqual(['late']);
  });

  it('does not timestamp-place an unresolved explicit source onto another turn', () => {
    const unrelatedReply = message('unrelated-reply', '2026-07-30T10:02:00Z', 'agent');
    const placed = placeVaultProvisionRequests(
      [unrelatedReply],
      [request('missing-source', 'provision', '2026-07-30T10:01:00Z', null, { message_id: 'trimmed-source' })],
    );

    expect([...placed.byMessageId]).toEqual([]);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('keeps a delayed reply when the next input arrives after request creation', () => {
    const source = message('source-user', '2026-07-30T10:00:00Z', 'user');
    const reply = message('owner-reply', '2026-07-30T10:01:00Z', 'agent');
    const laterUser = message('later-user', '2026-07-30T10:03:00Z', 'user');
    const unrelatedReply = message('unrelated-reply', '2026-07-30T10:04:00Z', 'agent');
    const placed = placeVaultProvisionRequests(
      [source, reply, laterUser, unrelatedReply],
      [request('late', 'provision', '2026-07-30T10:02:00Z', null, { message_id: source.id })],
    );

    expect(placed.byMessageId.get(reply.id)?.map((item) => item.id)).toEqual(['late']);
    expect(placed.byMessageId.has(unrelatedReply.id)).toBe(false);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('uses transcript time for queued source-turn boundaries', () => {
    const source = message('source-user', '2026-07-30T10:00:00Z', 'user');
    const ownerReply = message('owner-reply', '2026-07-30T10:00:30Z', 'agent');
    const queuedInput = message(
      'queued-input',
      '2026-07-30T09:59:00Z',
      'user',
      '2026-07-30T10:02:00Z',
    );
    const unrelatedReply = message('unrelated-reply', '2026-07-30T10:03:00Z');
    const placed = placeVaultProvisionRequests(
      [source, ownerReply, queuedInput, unrelatedReply],
      [request('late', 'provision', '2026-07-30T10:01:00Z', null, { message_id: source.id })],
    );

    expect(placed.byMessageId.get(ownerReply.id)?.map((item) => item.id)).toEqual(['late']);
    expect(placed.byMessageId.has(unrelatedReply.id)).toBe(false);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('ignores a stale requester message when a later turn owns the request', () => {
    const source = message('stale-source', '2026-07-30T10:00:00Z', 'user');
    const oldReply = message('old-reply', '2026-07-30T10:00:10Z', 'agent');
    const actualSource = message('actual-source', '2026-07-30T10:01:00Z', 'user');
    const actualReply = message('actual-reply', '2026-07-30T10:02:00Z', 'agent');
    const placed = placeVaultProvisionRequests(
      [source, oldReply, actualSource, actualReply],
      [request('late', 'provision', '2026-07-30T10:01:30Z', null, { message_id: source.id })],
    );

    expect(placed.byMessageId.get(actualReply.id)?.map((item) => item.id)).toEqual(['late']);
    expect(placed.byMessageId.has(oldReply.id)).toBe(false);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('keeps approvals out of message placement and leaves unmatched provisions visible', () => {
    const placed = placeVaultProvisionRequests(messages, [
      request('approval', 'access', '2026-07-30T10:00:00Z'),
      request('future', 'provision', '2026-07-30T11:00:00Z'),
    ]);

    expect([...placed.byMessageId]).toEqual([]);
    expect(placed.awaitingReply.map((item) => item.id)).toEqual(['future']);
  });

  it('does not attach a request whose owning reply may be outside the retained window', () => {
    const placed = placeVaultProvisionRequests(
      [message('agent-visible', '2026-07-30T10:00:10Z')],
      [request('older', 'provision', '2026-07-30T09:00:00Z')],
    );

    expect([...placed.byMessageId]).toEqual([]);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('uses transcript-entry time when a queued row was accepted after the request', () => {
    const queuedInput = message(
      'queued-input',
      '2026-07-30T09:59:00Z',
      'user',
      '2026-07-30T10:02:00Z',
    );
    const unrelatedReply = message('unrelated-reply', '2026-07-30T10:03:00Z');
    const placed = placeVaultProvisionRequests(
      [queuedInput, unrelatedReply],
      [request('trimmed', 'provision', '2026-07-30T10:01:00Z')],
    );

    expect([...placed.byMessageId]).toEqual([]);
    expect(placed.awaitingReply).toEqual([]);
  });

  it('shows a running turn request at the tail until its reply lands', () => {
    const source = message('source-user', '2026-07-30T10:00:00Z', 'user');
    const interim = { ...message('agent-interim', '2026-07-30T10:01:30Z'), type: 'interim' };
    const live = request('live', 'provision', '2026-07-30T10:01:00Z', null, { turn_id: 'turn-live' });

    const running = placeVaultProvisionRequests([source, interim], [live]);
    expect([...running.byMessageId]).toEqual([]);
    expect(running.awaitingReply.map((item) => item.id)).toEqual(['live']);

    const reply = { ...message('owner-reply', '2026-07-30T10:02:00Z'), metadata: { turn_id: 'turn-live' } };
    const settled = placeVaultProvisionRequests([source, interim, reply], [live]);
    expect(settled.byMessageId.get(reply.id)?.map((item) => item.id)).toEqual(['live']);
    expect(settled.awaitingReply).toEqual([]);
  });

  it('stops waiting at the tail once a later input starts another turn', () => {
    const source = message('source-user', '2026-07-30T10:00:00Z', 'user');
    const queuedInput = message(
      'queued-input',
      '2026-07-30T10:00:30Z',
      'user',
      '2026-07-30T10:02:00Z',
    );
    const placed = placeVaultProvisionRequests(
      [source, queuedInput],
      [request('superseded', 'provision', '2026-07-30T10:01:00Z')],
    );

    expect([...placed.byMessageId]).toEqual([]);
    expect(placed.awaitingReply).toEqual([]);
  });
});