Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

11.6 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

vi.mock('@/auth/secureStorage', () => ({
  getSecureItem: vi.fn(async () => null),
  setSecureItem: vi.fn(async () => undefined),
  deleteSecureItem: vi.fn(async () => undefined),
}));
vi.mock('@/session/mobileRealtimeAudio', () => ({ startMobileRealtimeAudio: vi.fn() }));

import type { AsrEvent, AsrProvider, AudioTrace, RefinementResult } from '@cindy/voice-input-core';
import { setMobileDebugSink } from '@/debug/mobileDebugLog';
import { serializeMobileDebugRecord } from '@/debug/mobileDebugRecord';
import type { StoredMobileVoiceCredential } from '@/session/mobileVoiceCredentialStore';
import { createMobileVoiceControllerSession } from '@/session/mobileVoiceController';
import { ApiError } from '@/api/client';
import { classifyMobileVoiceFailure } from '@/session/mobileVoiceDiagnostics';

const SPOKEN = '周五下午三点和财务对预算';
const REFINED = '周五下午 3 点和财务核对预算。';

class SpeakingAsr implements AsrProvider {
  private callback: (event: AsrEvent) => void = () => {};
  async start(): Promise<void> {
    this.callback({ type: 'connected', at: Date.now() });
  }
  async stop(): Promise<void> {}
  appendAudio(): void {
    this.callback({ type: 'partial', text: SPOKEN.slice(0, 4), at: Date.now() });
  }
  async flushAudio(): Promise<void> {
    this.callback({ type: 'stable', text: SPOKEN, at: Date.now() });
  }
  onEvent(callback: (event: AsrEvent) => void): void {
    this.callback = callback;
  }
}

function credential(): StoredMobileVoiceCredential {
  return {
    temporary: true,
    credentialVersion: 1,
    issuedAt: '2026-09-26T00:00:00.000Z',
    proxyBaseUrl: 'https://voice.example.test/proxy',
    proxyApiKey: '',
    hostDeviceId: 'host-a',
    storageVersion: 1,
    syncedAt: '2026-09-26T00:01:00.000Z',
    asr: {
      provider: 'litellm-volcengine-sauc-asr',
      model: 'volcengine-sauc-asr',
      auth: 'api-key',
      mode: 'provider-native-websocket',
      pcmSampleRate: 16_000,
      protocolProfile: 'volcengine-sauc-duration',
      resourceId: 'volc.seedasr.sauc.duration',
    },
    refiner: {
      provider: 'managed',
      model: 'auto',
      auth: 'api-key',
      transport: 'litellm-chat-completions',
      endpointPath: '/v1/chat/completions',
    },
  };
}

async function startAudibleAudio({
  onChunk,
}: {
  onChunk: (chunk: { pcm16: ArrayBuffer; trace: AudioTrace }) => void;
}): Promise<() => Promise<void>> {
  onChunk({
    pcm16: new Int16Array(160).fill(1000).buffer,
    trace: { capturedAt: 1, convertedAt: 2, chunkIndex: 1, sampleRate: 16000, durationMs: 10 },
  });
  return async () => undefined;
}

let records: string[] = [];
beforeEach(() => {
  records = [];
  setMobileDebugSink((level, scope, args) =>
    records.push(serializeMobileDebugRecord(level, scope, args)),
  );
  vi.spyOn(console, 'info').mockImplementation(() => undefined);
  vi.spyOn(console, 'warn').mockImplementation(() => undefined);
  vi.spyOn(console, 'error').mockImplementation(() => undefined);
});
afterEach(() => {
  setMobileDebugSink(undefined);
  vi.restoreAllMocks();
  vi.useRealTimers();
});

const messages = () =>
  records.map(
    (line) => JSON.parse(line) as { scope: string; args: [string, Record<string, unknown>?] },
  );

describe('mobile voice diagnostics', () => {
  it.each(['text', 'empty', 'rate_limit'] as const)('recovers an empty mobile recording and diagnoses the result: %s', async (outcome) => {
    vi.useFakeTimers();
    let emit: (event: AsrEvent) => void = () => {};
    let recovered = false;
    const recover = vi.fn(async () => {
      if (outcome === 'rate_limit') throw new ApiError('RATE_LIMITED', 429, 'PRIVATE_SERVER_MESSAGE');
      recovered = true;
    });
    const onError = vi.fn();
    const onDraftChanged = vi.fn();
    const session = createMobileVoiceControllerSession({
      credential: credential(), initialDraft: '', startAudio: startAudibleAudio,
      refiner: null,
      asr: {
        onEvent(callback) { emit = callback; },
        async start() { emit({ type: 'connected', at: Date.now() }); },
        async stop() {}, appendAudio() {}, recover,
        async flushAudio() {
          if (recovered && outcome === 'text') emit({ type: 'stable', text: SPOKEN, at: Date.now() });
        },
      },
      onError, onDraftChanged,
    });
    await session.start();
    const stopping = session.stop().then(() => undefined, (error: unknown) => error);
    await vi.advanceTimersByTimeAsync(1100);
    const stopError = await stopping;
    expect(recover).toHaveBeenCalledTimes(1);
    const logged = messages();
    expect(logged.find((record) => record.args[0] === 'asr recovery attempted')?.args[1])
      .toMatchObject({ trigger: 'empty_transcript', attempt: 1 });
    if (outcome === 'text') {
      expect(stopError).toBeUndefined();
      expect(onError).not.toHaveBeenCalled();
      expect(JSON.stringify(onDraftChanged.mock.calls)).toContain(SPOKEN);
    } else {
      expect(stopError).toBeInstanceOf(Error);
      expect(onError).toHaveBeenCalledTimes(1);
      expect(logged.find((record) => record.args[0] === 'run failed')?.args[1])
        .toMatchObject({ reason: outcome === 'empty' ? 'empty_transcript' : 'rate_limited' });
    }
    expect(records.join('\n')).not.toContain(SPOKEN);
    expect(records.join('\n')).not.toContain('PRIVATE_SERVER_MESSAGE');
  });

  it('records the run stages and summaries in the voice scope without any dictated text', async () => {
    const session = createMobileVoiceControllerSession({
      credential: credential(),
      initialDraft: '',
      asr: new SpeakingAsr(),
      refiner: {
        async refine(input): Promise<RefinementResult> {
          return {
            accepted: true,
            sourceSegmentIds: input.segmentIds,
            basedOnText: input.text,
            refinedText: REFINED,
            elapsedMs: 12,
          };
        },
      },
      startAudio: startAudibleAudio,
      onDraftChanged: () => {},
    });
    await session.start();
    await session.stop();

    const logged = messages();
    expect(logged.every((record) => record.scope === 'voice')).toBe(true);
    const names = logged.map((record) => record.args[0]);
    expect(logged.find((record) => record.args[0] === 'stop requested')?.args[1]).toMatchObject({
      capturedAudioMs: 10,
      rmsDbfs: -30,
      peakDbfs: -30,
    });
    for (const name of [
      'start',
      'capture live',
      'stop requested',
      'latency summary',
      'refinement latency summary',
      'stop finished',
    ]) {
      expect(names).toContain(name);
    }
    const summary = logged.find((record) => record.args[0] === 'latency summary')!.args[1]!;
    expect(summary).toMatchObject({
      provider: 'litellm-volcengine-sauc-asr',
      submitSource: 'stable',
      chars: SPOKEN.length,
    });
    const refinement = logged.find((record) => record.args[0] === 'refinement latency summary')!
      .args[1]!;
    expect(refinement).toMatchObject({
      outcome: 'accepted',
      basedOnChars: SPOKEN.length,
      refinedChars: REFINED.length,
    });

    const everything = records.join('');
    for (const fragment of [SPOKEN, SPOKEN.slice(0, 4), REFINED, '财务'])
      expect(everything).not.toContain(fragment);
  });

  it('tells runs apart, logs ASR readiness, and treats no_change as a normal outcome', async () => {
    const originalCrypto = globalThis.crypto;
    // React Native has no crypto.randomUUID; ids then share a fixed prefix.
    Object.defineProperty(globalThis, 'crypto', { value: {}, configurable: true });
    try {
      const runIds: unknown[] = [];
      for (let run = 0; run < 2; run++) {
        records = [];
        const session = createMobileVoiceControllerSession({
          credential: credential(),
          initialDraft: '',
          asr: new SpeakingAsr(),
          refiner: {
            async refine(input): Promise<RefinementResult> {
              return {
                accepted: false,
                sourceSegmentIds: input.segmentIds,
                basedOnText: input.text,
                refinedText: input.text,
                rejectionReason: 'no_change',
                elapsedMs: 5,
              };
            },
          },
          startAudio: startAudibleAudio,
          onDraftChanged: () => {},
        });
        await session.start();
        await session.stop();
        const logged = messages();
        const ids = new Set(logged.map((record) => record.args[1]?.runId).filter(Boolean));
        expect(ids.size).toBe(1);
        runIds.push([...ids][0]);
        expect(logged.map((record) => record.args[0])).toContain('asr ready');
        const refinement = JSON.parse(
          records.find((line) => line.includes('refinement latency summary'))!,
        ) as { level: string };
        expect(refinement.level).toBe('info');
      }
      expect(runIds[0]).not.toBe(runIds[1]);
    } finally {
      Object.defineProperty(globalThis, 'crypto', { value: originalCrypto, configurable: true });
    }
  });

  it('never logs error text that quotes a refinement response', async () => {
    const session = createMobileVoiceControllerSession({
      credential: credential(),
      initialDraft: '',
      asr: new SpeakingAsr(),
      refiner: {
        async refine(): Promise<RefinementResult> {
          // A malformed model response surfaces as an error quoting its output.
          throw new Error(`Refiner returned invalid JSON: ${REFINED}`);
        },
      },
      startAudio: startAudibleAudio,
      onDraftChanged: () => {},
    });
    await session.start();
    await session.stop();
    const refinement = messages().find((record) => record.args[0] === 'refinement latency summary')!
      .args[1]!;
    expect(refinement).toMatchObject({ outcome: 'rejected', reason: 'parse_error' });
    expect(records.join('')).not.toContain('财务');
  });

  it('classifies failures into fixed codes without echoing the message', () => {
    expect(classifyMobileVoiceFailure(new ApiError('RATE_LIMITED', 429, `限流 ${SPOKEN}`))).toBe(
      'api_rate_limited_429',
    );
    expect(
      classifyMobileVoiceFailure(new Error('Voice refine warmup failed with status 409')),
    ).toBe('http_409');
    expect(classifyMobileVoiceFailure('语音会话不可优化、优化次数已用完,或不属于当前用户')).toBe(
      'refine_quota_exhausted',
    );
    expect(
      classifyMobileVoiceFailure(
        new Error('Volcengine SAUC ASR connection timed out after 5000ms'),
      ),
    ).toBe('timeout');
    expect(classifyMobileVoiceFailure(new Error(SPOKEN))).toBe('other');
  });

  it('logs a silent recording ending without ASR finalization', async () => {
    class QuietAsr extends SpeakingAsr {
      appendAudio(): void {}
    }
    const session = createMobileVoiceControllerSession({
      credential: credential(),
      initialDraft: '',
      asr: new QuietAsr(),
      refiner: null,
      startAudio: async ({ onChunk }) => {
        onChunk({
          pcm16: new Int16Array(320).buffer,
          trace: {
            capturedAt: 1,
            convertedAt: 2,
            chunkIndex: 1,
            sampleRate: 16000,
            durationMs: 20,
          },
        });
        return async () => undefined;
      },
      onDraftChanged: () => {},
    });
    await session.start();
    records = [];
    await session.stop();
    const logged = messages();
    const stop = logged.find((record) => record.args[0] === 'stop requested')!.args[1]!;
    expect(stop).toMatchObject({ captureLive: true, soundDetected: false, hasTranscript: false });
    expect(logged.map((record) => record.args[0])).toContain(
      'silent recording ended without ASR finalization',
    );
    expect(logged.map((record) => record.args[0])).not.toContain('latency summary');
  });
});