@vellumai/assistant 0.3.5 → 0.3.7

package/src/__tests__/session-process-bridge.test.ts

@@ -1,244 +0,0 @@
-import { describe, test, expect, beforeEach, mock } from 'bun:test';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-const testDir = mkdtempSync(join(tmpdir(), 'session-process-bridge-test-'));
-
-// ── Platform + logger mocks ─────────────────────────────────────────
-
-mock.module('../util/platform.js', () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === 'darwin',
-  isLinux: () => process.platform === 'linux',
-  isWindows: () => process.platform === 'win32',
-  getSocketPath: () => join(testDir, 'test.sock'),
-  getPidPath: () => join(testDir, 'test.pid'),
-  getDbPath: () => join(testDir, 'test.db'),
-  getLogPath: () => join(testDir, 'test.log'),
-  ensureDataDir: () => {},
-}));
-
-mock.module('../util/logger.js', () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module('../config/loader.js', () => ({
-  getConfig: () => ({
-    apiKeys: { anthropic: 'test-key' },
-    model: 'claude-sonnet-4-20250514',
-    provider: 'anthropic',
-    memory: { enabled: false },
-    calls: { enabled: false },
-    contextWindow: { maxInputTokens: 200000 },
-  }),
-}));
-
-// ── Mock the call bridge ─────────────────────────────────────────────
-
-import type { CallBridgeResult } from '../calls/call-bridge.js';
-
-const mockTryRouteCallMessage = mock(
-  (_convId: string, _text: string, _msgId?: string): Promise<CallBridgeResult> =>
-    Promise.resolve({ handled: false, reason: 'no_active_call' }),
-);
-
-mock.module('../calls/call-bridge.js', () => ({
-  tryRouteCallMessage: (...args: [string, string, string?]) => mockTryRouteCallMessage(...args),
-}));
-
-// ── Mock slash resolution ────────────────────────────────────────────
-
-mock.module('./session-slash.js', () => ({
-  resolveSlash: (content: string) => ({ kind: 'passthrough' as const, content }),
-}));
-
-// ── Import after mocks ──────────────────────────────────────────────
-
-import type { ServerMessage } from '../daemon/ipc-protocol.js';
-import type { ProcessSessionContext } from '../daemon/session-process.js';
-import { processMessage, drainQueue } from '../daemon/session-process.js';
-import { MessageQueue } from '../daemon/session-queue-manager.js';
-
-// ── Session mock factory ─────────────────────────────────────────────
-
-function createMockSession(overrides?: Partial<ProcessSessionContext>): ProcessSessionContext {
-  return {
-    conversationId: 'test-conv',
-    messages: [],
-    processing: false,
-    abortController: null,
-    currentRequestId: undefined,
-    queue: new MessageQueue(),
-    traceEmitter: {
-      emit: () => {},
-    } as unknown as ProcessSessionContext['traceEmitter'],
-    usageStats: { inputTokens: 0, outputTokens: 0, estimatedCost: 0 },
-    persistUserMessage: mock((_content: string, _attachments: unknown[], _requestId?: string) => 'mock-msg-id'),
-    runAgentLoop: mock(async () => {}),
-    ...overrides,
-  };
-}
-
-// ── Tests ────────────────────────────────────────────────────────────
-
-describe('session-process bridge consumption', () => {
-  beforeEach(() => {
-    mockTryRouteCallMessage.mockReset();
-  });
-
-  // ── Direct processMessage path ───────────────────────────────
-
-  test('processMessage emits assistant_text_delta + message_complete when bridge consumes with userFacingText', async () => {
-    mockTryRouteCallMessage.mockResolvedValue({
-      handled: true,
-      userFacingText: 'Instruction relayed to active call.',
-    });
-
-    const events: ServerMessage[] = [];
-    const onEvent = (msg: ServerMessage) => events.push(msg);
-    const session = createMockSession();
-
-    await processMessage(session, 'ask about pricing', [], onEvent);
-
-    // Should have emitted text delta then message_complete
-    const textDelta = events.find((e) => e.type === 'assistant_text_delta');
-    expect(textDelta).toBeDefined();
-    expect((textDelta as { text: string }).text).toBe('Instruction relayed to active call.');
-
-    const complete = events.find((e) => e.type === 'message_complete');
-    expect(complete).toBeDefined();
-
-    // Should NOT have called runAgentLoop
-    expect(session.runAgentLoop).not.toHaveBeenCalled();
-  });
-
-  test('processMessage emits failure text when bridge consumes with failure userFacingText', async () => {
-    mockTryRouteCallMessage.mockResolvedValue({
-      handled: true,
-      reason: 'instruction_relay_failed',
-      userFacingText: 'Failed to relay instruction to the active call.',
-    });
-
-    const events: ServerMessage[] = [];
-    const onEvent = (msg: ServerMessage) => events.push(msg);
-    const session = createMockSession();
-
-    await processMessage(session, 'change the topic', [], onEvent);
-
-    const textDelta = events.find((e) => e.type === 'assistant_text_delta');
-    expect(textDelta).toBeDefined();
-    expect((textDelta as { text: string }).text).toBe('Failed to relay instruction to the active call.');
-
-    const complete = events.find((e) => e.type === 'message_complete');
-    expect(complete).toBeDefined();
-
-    // Only one message_complete
-    const completeCount = events.filter((e) => e.type === 'message_complete').length;
-    expect(completeCount).toBe(1);
-
-    expect(session.runAgentLoop).not.toHaveBeenCalled();
-  });
-
-  test('processMessage skips text delta when bridge consumes without userFacingText', async () => {
-    mockTryRouteCallMessage.mockResolvedValue({
-      handled: true,
-    });
-
-    const events: ServerMessage[] = [];
-    const onEvent = (msg: ServerMessage) => events.push(msg);
-    const session = createMockSession();
-
-    await processMessage(session, 'hello', [], onEvent);
-
-    const textDelta = events.find((e) => e.type === 'assistant_text_delta');
-    expect(textDelta).toBeUndefined();
-
-    const complete = events.find((e) => e.type === 'message_complete');
-    expect(complete).toBeDefined();
-
-    expect(session.runAgentLoop).not.toHaveBeenCalled();
-  });
-
-  test('processMessage falls through to agent loop when bridge does not consume', async () => {
-    mockTryRouteCallMessage.mockResolvedValue({
-      handled: false,
-      reason: 'no_active_call',
-    });
-
-    const events: ServerMessage[] = [];
-    const onEvent = (msg: ServerMessage) => events.push(msg);
-    const session = createMockSession();
-
-    await processMessage(session, 'normal message', [], onEvent);
-
-    expect(session.runAgentLoop).toHaveBeenCalled();
-  });
-
-  // ── Queued routeOrProcess path ───────────────────────────────
-
-  test('drainQueue emits assistant_text_delta + message_complete for bridge-consumed queued message', async () => {
-    mockTryRouteCallMessage.mockResolvedValue({
-      handled: true,
-      userFacingText: 'Instruction relayed to active call.',
-    });
-
-    const events: ServerMessage[] = [];
-    const onEvent = (msg: ServerMessage) => events.push(msg);
-    const session = createMockSession({ processing: true });
-
-    // Enqueue a message
-    session.queue.push({
-      content: 'ask about pricing',
-      attachments: [],
-      requestId: 'req-1',
-      onEvent,
-    });
-
-    drainQueue(session);
-
-    // Wait for async routeOrProcess
-    await new Promise((r) => setTimeout(r, 50));
-
-    const textDelta = events.find((e) => e.type === 'assistant_text_delta');
-    expect(textDelta).toBeDefined();
-    expect((textDelta as { text: string }).text).toBe('Instruction relayed to active call.');
-
-    // message_complete (from dequeue + bridge consumption — only one expected for this request)
-    const completeEvents = events.filter((e) => e.type === 'message_complete');
-    expect(completeEvents.length).toBe(1);
-
-    expect(session.runAgentLoop).not.toHaveBeenCalled();
-  });
-
-  test('drainQueue emits failure text for bridge-consumed queued message with relay failure', async () => {
-    mockTryRouteCallMessage.mockResolvedValue({
-      handled: true,
-      reason: 'instruction_relay_failed',
-      userFacingText: 'Failed to relay instruction to the active call.',
-    });
-
-    const events: ServerMessage[] = [];
-    const onEvent = (msg: ServerMessage) => events.push(msg);
-    const session = createMockSession({ processing: true });
-
-    session.queue.push({
-      content: 'change the topic',
-      attachments: [],
-      requestId: 'req-2',
-      onEvent,
-    });
-
-    drainQueue(session);
-    await new Promise((r) => setTimeout(r, 50));
-
-    const textDelta = events.find((e) => e.type === 'assistant_text_delta');
-    expect(textDelta).toBeDefined();
-    expect((textDelta as { text: string }).text).toBe('Failed to relay instruction to the active call.');
-
-    expect(session.runAgentLoop).not.toHaveBeenCalled();
-  });
-});

package/src/calls/call-bridge.ts

@@ -1,168 +0,0 @@
-/**
- * Call message bridge: intercepts user messages in-thread and routes them
- * to the live call orchestrator — either as answers to pending questions
- * or as mid-call steering instructions.
- *
- * Decision priority:
- * 1. If a pending question exists → answer path (existing behavior).
- * 2. If no pending question but an active call exists → instruction path.
- *
- * When the bridge consumes a message it returns `{ handled: true }` so
- * the caller can skip agent processing.
- */
-
-import { getLogger } from '../util/logger.js';
-import {
-  getActiveCallSessionForConversation,
-  getPendingQuestion,
-  answerPendingQuestion,
-  recordCallEvent,
-  getCallSession,
-} from './call-store.js';
-import { getCallOrchestrator } from './call-state.js';
-import { relayInstruction } from './call-domain.js';
-import * as conversationStore from '../memory/conversation-store.js';
-
-const log = getLogger('call-bridge');
-
-export interface CallBridgeResult {
-  handled: boolean;
-  reason?: string;
-  /** User-facing text persisted in-thread by the bridge (success ack or failure notice). */
-  userFacingText?: string;
-}
-
-/**
- * Attempt to route a user message to an active call — as an answer to
- * a pending question (priority) or as a mid-call steering instruction.
- *
- * @param conversationId - The conversation the message belongs to.
- * @param userText - The user's message text.
- * @param _userMessageId - The persisted message ID (reserved for future use).
- * @returns `{ handled: true }` if the message was consumed by the call system,
- *          `{ handled: false, reason }` otherwise.
- */
-export async function tryRouteCallMessage(
-  conversationId: string,
-  userText: string,
-  _userMessageId?: string,
-): Promise<CallBridgeResult> {
-  // 1. Find an active call for this conversation
-  const callSession = getActiveCallSessionForConversation(conversationId);
-  if (!callSession) {
-    return { handled: false, reason: 'no_active_call' };
-  }
-
-  // 2. Check for a pending question — answer path takes priority
-  const pendingQuestion = getPendingQuestion(callSession.id);
-  if (pendingQuestion) {
-    return handleAnswer(conversationId, callSession.id, pendingQuestion, userText);
-  }
-
-  // 3. No pending question — instruction path
-  return handleInstruction(conversationId, callSession.id, userText);
-}
-
-/** @deprecated Use `tryRouteCallMessage` instead. */
-export const tryHandlePendingCallAnswer = tryRouteCallMessage;
-
-// ── Answer path ─────────────────────────────────────────────────────
-
-async function handleAnswer(
-  conversationId: string,
-  callSessionId: string,
-  pendingQuestion: { id: string; questionText: string },
-  userText: string,
-): Promise<CallBridgeResult> {
-  // Empty text (e.g. attachment-only messages) should not be consumed as
-  // an answer — fall through to normal processing so attachments are handled.
-  if (!userText.trim()) {
-    return { handled: false, reason: 'empty_answer_text' };
-  }
-
-  const orchestrator = getCallOrchestrator(callSessionId);
-  if (!orchestrator) {
-    // The call may have ended between the question being asked and the
-    // user replying. Persist a follow-up message so the user knows.
-    const freshSession = getCallSession(callSessionId);
-    const ended = freshSession && (freshSession.status === 'completed' || freshSession.status === 'failed');
-    if (ended) {
-      conversationStore.addMessage(
-        conversationId,
-        'assistant',
-        JSON.stringify([{
-          type: 'text',
-          text: 'The call ended before your answer could be relayed to the caller.',
-        }]),
-      );
-    }
-    return { handled: false, reason: 'orchestrator_not_found' };
-  }
-
-  if (orchestrator.getState() !== 'waiting_on_user') {
-    return { handled: false, reason: 'orchestrator_not_waiting' };
-  }
-
-  const accepted = await orchestrator.handleUserAnswer(userText);
-  if (!accepted) {
-    return { handled: false, reason: 'orchestrator_rejected' };
-  }
-
-  answerPendingQuestion(pendingQuestion.id, userText);
-  recordCallEvent(callSessionId, 'user_answered', { answer: userText });
-
-  log.info(
-    { conversationId, callSessionId, questionId: pendingQuestion.id },
-    'User reply routed as call answer via bridge',
-  );
-
-  return { handled: true };
-}
-
-// ── Instruction path ────────────────────────────────────────────────
-
-async function handleInstruction(
-  conversationId: string,
-  callSessionId: string,
-  userText: string,
-): Promise<CallBridgeResult> {
-  // Empty text (e.g. attachment-only messages) should not be relayed —
-  // fall through to normal processing so attachments are handled.
-  if (!userText.trim()) {
-    return { handled: false, reason: 'empty_instruction_text' };
-  }
-
-  const result = await relayInstruction({ callSessionId, instructionText: userText });
-
-  if (!result.ok) {
-    log.warn(
-      { conversationId, callSessionId, error: result.error },
-      'Instruction relay failed via bridge',
-    );
-
-    const failureText = 'Failed to relay instruction to the active call.';
-    conversationStore.addMessage(
-      conversationId,
-      'assistant',
-      JSON.stringify([{ type: 'text', text: failureText }]),
-    );
-
-    // Consumed: caller should NOT fall through to the agent loop
-    return { handled: true, reason: 'instruction_relay_failed', userFacingText: failureText };
-  }
-
-  // Persist a concise acknowledgement so the user sees confirmation
-  const ackText = 'Instruction relayed to active call.';
-  conversationStore.addMessage(
-    conversationId,
-    'assistant',
-    JSON.stringify([{ type: 'text', text: ackText }]),
-  );
-
-  log.info(
-    { conversationId, callSessionId },
-    'User message routed as call instruction via bridge',
-  );
-
-  return { handled: true, userFacingText: ackText };
-}

package/src/config/bundled-skills/media-processing/services/capability-registry.ts

@@ -1,137 +0,0 @@
-/**
- * Generic capability registry with tier-based classification.
- *
- * The registry is domain-agnostic: any domain (sports, surveillance, lecture
- * recording, etc.) can register its own capabilities. Basketball-specific
- * capabilities are registered as one example via `registerDefaults()`.
- */
-
-import type { CapabilityTier } from '../../../../memory/media-store.js';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface Capability {
-  /** Unique name used as the key in tracking profiles (e.g. 'turnover'). */
-  name: string;
-  /** Human-readable description of what this capability detects/tracks. */
-  description: string;
-  /** Maturity tier governing confidence disclaimers and default inclusion. */
-  tier: CapabilityTier;
-  /** Domain this capability belongs to (e.g. 'basketball', 'surveillance'). */
-  domain: string;
-  /** Granularity level (e.g. 'team', 'per-player'). */
-  granularity?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Registry (singleton in-memory Map)
-// ---------------------------------------------------------------------------
-
-const registry = new Map<string, Capability>();
-
-/**
- * Register a capability. Overwrites any existing capability with the same name.
- */
-export function registerCapability(cap: Capability): void {
-  registry.set(cap.name, cap);
-}
-
-/**
- * Get all registered capabilities, optionally filtered by domain.
- */
-export function getCapabilities(domain?: string): Capability[] {
-  const all = Array.from(registry.values());
-  if (!domain) return all;
-  return all.filter((c) => c.domain === domain);
-}
-
-/**
- * Get capabilities filtered by tier.
- */
-export function getCapabilitiesByTier(tier: CapabilityTier): Capability[] {
-  return Array.from(registry.values()).filter((c) => c.tier === tier);
-}
-
-/**
- * Look up a single capability by name.
- */
-export function getCapabilityByName(name: string): Capability | undefined {
-  return registry.get(name);
-}
-
-/**
- * Get all unique domain names in the registry.
- */
-export function getRegisteredDomains(): string[] {
-  const domains = new Set<string>();
-  for (const cap of registry.values()) {
-    domains.add(cap.domain);
-  }
-  return Array.from(domains);
-}
-
-// ---------------------------------------------------------------------------
-// Default registrations — basketball as one example domain
-// ---------------------------------------------------------------------------
-
-/**
- * Register the default basketball capabilities as an example domain.
- * Other domains should call `registerCapability()` with their own entries.
- */
-export function registerDefaults(): void {
-  // Ready tier: production-quality detection
-  registerCapability({
-    name: 'turnover',
-    description: 'Team-level turnover detection',
-    tier: 'ready',
-    domain: 'basketball',
-    granularity: 'team',
-  });
-
-  // Beta tier: functional but may have accuracy gaps
-  registerCapability({
-    name: 'field_goal',
-    description: 'Team-level field goal detection',
-    tier: 'beta',
-    domain: 'basketball',
-    granularity: 'team',
-  });
-
-  registerCapability({
-    name: 'rebound',
-    description: 'Team-level rebound detection',
-    tier: 'beta',
-    domain: 'basketball',
-    granularity: 'team',
-  });
-
-  registerCapability({
-    name: 'turnover_per_player',
-    description: 'Per-player turnover attribution',
-    tier: 'beta',
-    domain: 'basketball',
-    granularity: 'per-player',
-  });
-
-  // Experimental tier: early-stage, expect noise
-  registerCapability({
-    name: 'field_goal_per_player',
-    description: 'Per-player field goal attribution',
-    tier: 'experimental',
-    domain: 'basketball',
-    granularity: 'per-player',
-  });
-
-  registerCapability({
-    name: 'rebound_per_player',
-    description: 'Per-player rebound attribution',
-    tier: 'experimental',
-    domain: 'basketball',
-    granularity: 'per-player',
-  });
-}
-
-// Auto-register defaults on first import
-registerDefaults();