@od-oneapp/ai-platform 0.1.0

package/src/grounding/rag/__tests__/pipeline.test.ts

@@ -0,0 +1,274 @@
+/**
+ * @fileoverview Tests for research pipeline
+ * Tests for research pipeline
+ */
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  executeResearchPipeline,
+  reasonWithSonnet,
+  researchWithPerplexity,
+  verifyWithGPT5,
+} from '../pipeline';
+
+// Mock the AI SDK functions
+vi.mock('ai', () => ({
+  generateText: vi.fn(),
+}));
+
+vi.mock('@ai-sdk/anthropic', () => ({
+  anthropic: vi.fn((model: string) => `anthropic:${model}`),
+}));
+
+vi.mock('@ai-sdk/openai', () => ({
+  openai: vi.fn((model: string) => `openai:${model}`),
+}));
+
+const originalFetch = global.fetch;
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  if (originalFetch) {
+    global.fetch = originalFetch;
+  }
+  delete process.env.PPLX_API_KEY;
+  delete process.env.NEXT_AI_VERIFICATION_MODEL;
+});
+
+describe('Research Pipeline', () => {
+  describe('researchWithPerplexity', () => {
+    it('should have real API integration ready', () => {
+      // This test verifies the structure is ready for Perplexity API
+      expect(researchWithPerplexity).toBeDefined();
+      expect(typeof researchWithPerplexity).toBe('function');
+    });
+
+    it('should accept tier parameter', async () => {
+      // Mock implementation
+      const { generateText } = await import('ai');
+      vi.mocked(generateText).mockResolvedValue({
+        text: 'Test notes [Source: https://example.com]',
+        usage: { totalTokens: 100 },
+      } as unknown as Awaited<ReturnType<typeof generateText>>);
+
+      const result = await researchWithPerplexity('test query', 'fast');
+      expect(result).toHaveProperty('notes');
+      expect(result).toHaveProperty('cites');
+      expect(result).toHaveProperty('usage');
+    });
+
+    it('prefers Perplexity API when key is present and merges citations', async () => {
+      process.env.PPLX_API_KEY = 'test-key';
+      const fetchMock = vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          citations: ['https://api.cite/one'],
+          choices: [{ message: { content: 'Note [Source: https://inline.example/two]' } }],
+          usage: { prompt_tokens: 12, completion_tokens: 8 },
+        }),
+      });
+      global.fetch = fetchMock as typeof global.fetch;
+
+      const { generateText } = await import('ai');
+      vi.mocked(generateText).mockResolvedValue({
+        text: 'fallback',
+        usage: { inputTokens: 0, outputTokens: 0 },
+      } as unknown as Awaited<ReturnType<typeof generateText>>);
+
+      const result = await researchWithPerplexity('Perplexity path', 'balanced');
+
+      expect(generateText).not.toHaveBeenCalled();
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      expect(result.cites).toStrictEqual(
+        expect.arrayContaining(['https://api.cite/one', 'https://inline.example/two']),
+      );
+      expect(result.usage.inputTokens).toBe(12);
+      expect(result.usage.outputTokens).toBe(8);
+    });
+
+    it('falls back to GPT-4 Turbo when Perplexity fails', async () => {
+      process.env.PPLX_API_KEY = 'test-key';
+      const fetchMock = vi.fn().mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: 'Internal',
+        text: async () => 'error body',
+      });
+      global.fetch = fetchMock as typeof global.fetch;
+
+      const { generateText } = await import('ai');
+      vi.mocked(generateText).mockResolvedValue({
+        text: 'Fallback notes [Source: https://fallback.example]',
+        usage: { inputTokens: 5, outputTokens: 7 },
+      } as unknown as Awaited<ReturnType<typeof generateText>>);
+
+      const result = await researchWithPerplexity('Fallback path', 'fast');
+
+      expect(generateText).toHaveBeenCalledTimes(1);
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      expect(result.cites).toContain('https://fallback.example');
+      expect(result.usage.inputTokens).toBe(5);
+      expect(result.usage.outputTokens).toBe(7);
+    });
+  });
+
+  describe('reasonWithSonnet', () => {
+    it('should process notes into structured reasoning', async () => {
+      const { generateText } = await import('ai');
+      vi.mocked(generateText).mockResolvedValue({
+        text: JSON.stringify({
+          claims: [
+            {
+              statement: 'Test claim',
+              supportedBy: ['https://example.com'],
+              confidence: 'high',
+            },
+          ],
+          assumptions: ['Test assumption'],
+          gaps: [],
+          answerDraft: 'Test answer',
+        }),
+        usage: { totalTokens: 200 },
+      } as unknown as Awaited<ReturnType<typeof generateText>>);
+
+      const result = await reasonWithSonnet({
+        question: 'Test?',
+        notes: 'Test notes',
+        cites: ['https://example.com'],
+      });
+
+      expect(result).toHaveProperty('claims');
+      expect(result).toHaveProperty('assumptions');
+      expect(result).toHaveProperty('gaps');
+      expect(result).toHaveProperty('answerDraft');
+    });
+
+    it('throws when Sonnet response lacks JSON payload', async () => {
+      const { generateText } = await import('ai');
+      vi.mocked(generateText).mockResolvedValue({
+        text: 'no json here',
+        usage: { totalTokens: 10 },
+      } as unknown as Awaited<ReturnType<typeof generateText>>);
+
+      await expect(
+        reasonWithSonnet({ question: 'Bad response', notes: 'notes', cites: [] }),
+      ).rejects.toThrowError('Failed to extract JSON');
+    });
+  });
+
+  describe('verifyWithGPT5', () => {
+    it('should verify reasoning output', async () => {
+      const { generateText } = await import('ai');
+      vi.mocked(generateText).mockResolvedValue({
+        text: JSON.stringify({
+          finalAnswer: 'Verified answer',
+          flags: [],
+          trace: [
+            {
+              claim: 'Test claim',
+              citationCheck: 'verified',
+            },
+          ],
+          confidence: 'high',
+        }),
+        usage: { totalTokens: 150 },
+      } as unknown as Awaited<ReturnType<typeof generateText>>);
+
+      const draftReasoning = {
+        claims: [
+          {
+            statement: 'Test claim',
+            supportedBy: ['https://example.com'],
+            confidence: 'high' as const,
+          },
+        ],
+        assumptions: [],
+        gaps: [],
+        answerDraft: 'Draft answer',
+        usage: { inputTokens: 100, outputTokens: 100 },
+      };
+
+      const result = await verifyWithGPT5(draftReasoning, ['https://example.com']);
+
+      expect(result).toHaveProperty('finalAnswer');
+      expect(result).toHaveProperty('flags');
+      expect(result).toHaveProperty('trace');
+      expect(result).toHaveProperty('confidence');
+    });
+
+    it('should use configured verification model', () => {
+      const originalEnv = process.env.NEXT_AI_VERIFICATION_MODEL;
+      process.env.NEXT_AI_VERIFICATION_MODEL = 'gpt-5';
+
+      // Verification happens in the function call
+      expect(process.env.NEXT_AI_VERIFICATION_MODEL).toBe('gpt-5');
+
+      // Cleanup
+      process.env.NEXT_AI_VERIFICATION_MODEL = originalEnv;
+    });
+
+    it('throws when verification response is malformed', async () => {
+      const { generateText } = await import('ai');
+      vi.mocked(generateText).mockResolvedValue({
+        text: 'not json',
+        usage: { totalTokens: 10 },
+      } as unknown as Awaited<ReturnType<typeof generateText>>);
+
+      await expect(
+        verifyWithGPT5(
+          {
+            claims: [],
+            assumptions: [],
+            gaps: [],
+            answerDraft: 'draft',
+            usage: { inputTokens: 0, outputTokens: 0 },
+          },
+          [],
+        ),
+      ).rejects.toThrowError('Failed to extract JSON');
+    });
+  });
+
+  describe('executeResearchPipeline', () => {
+    it('should execute full pipeline', async () => {
+      const { generateText } = await import('ai');
+
+      // Mock all three steps
+      vi.mocked(generateText)
+        .mockResolvedValueOnce({
+          text: 'Notes with citations [Source: https://example.com]',
+          usage: { totalTokens: 100 },
+        } as unknown as Awaited<ReturnType<typeof generateText>>)
+        .mockResolvedValueOnce({
+          text: JSON.stringify({
+            claims: [
+              { statement: 'Claim', supportedBy: ['https://example.com'], confidence: 'high' },
+            ],
+            assumptions: [],
+            gaps: [],
+            answerDraft: 'Draft',
+          }),
+          usage: { totalTokens: 200 },
+        } as unknown as Awaited<ReturnType<typeof generateText>>)
+        .mockResolvedValueOnce({
+          text: JSON.stringify({
+            finalAnswer: 'Final answer',
+            flags: [],
+            trace: [{ claim: 'Claim', citationCheck: 'verified' }],
+            confidence: 'high',
+          }),
+          usage: { totalTokens: 150 },
+        } as unknown as Awaited<ReturnType<typeof generateText>>);
+
+      const result = await executeResearchPipeline('Test question', { tier: 'balanced' });
+
+      expect(result).toHaveProperty('answer');
+      expect(result).toHaveProperty('confidence');
+      expect(result).toHaveProperty('trace');
+      expect(result.trace).toHaveProperty('contextExpansion');
+      expect(result.trace).toHaveProperty('reasoning');
+      expect(result.trace).toHaveProperty('verification');
+    });
+  });
+});

package/src/grounding/rag/__tests__/tool.test.ts

@@ -0,0 +1,202 @@
+/**
+ * @fileoverview Tests for research tool
+ * Tests for research tool
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+
+import { createResearchTool, researchInputSchema } from '../tool';
+
+// Mock dependencies
+vi.mock('../pipeline', () => ({
+  researchWithPerplexity: vi.fn(),
+  reasonWithSonnet: vi.fn(),
+  verifyWithGPT5: vi.fn(),
+}));
+
+vi.mock('../trace', () => ({
+  startRun: vi.fn(() => ({
+    runId: 'test-run-123',
+    app: 'test-app',
+    question: 'Test?',
+    tier: 'balanced',
+    startedAt: Date.now(),
+    steps: [],
+  })),
+  startStep: vi.fn(() => ({
+    id: 'step-123',
+    kind: 'context-expansion',
+    startAt: Date.now(),
+    endAt: 0,
+    latencyMs: 0,
+    artifacts: {},
+    artifactKeys: [],
+  })),
+  endStep: vi.fn(step => step),
+  endRun: vi.fn(run => run),
+  persistStep: vi.fn(),
+  persistRunMeta: vi.fn(),
+  persistRunIndex: vi.fn(),
+}));
+
+describe('Research Tool', () => {
+  it('should create a tool with proper schema', () => {
+    const tool = createResearchTool();
+
+    expect(tool).toBeDefined();
+    expect(tool.description).toContain('Context expansion');
+    expect(tool.description).toContain('reasoning');
+    expect(tool.description).toContain('Verification');
+  });
+
+  it('should accept onSignal callback', () => {
+    const onSignal = vi.fn();
+    const tool = createResearchTool({ onSignal });
+
+    expect(tool).toBeDefined();
+  });
+
+  it('should accept onTrace callback', () => {
+    const onTrace = vi.fn();
+    const tool = createResearchTool({ onTrace });
+
+    expect(tool).toBeDefined();
+  });
+
+  it('should have input schema with question and tier', () => {
+    const tool = createResearchTool();
+
+    expect(tool.inputSchema).toBeDefined();
+
+    // Test valid input
+    const validInput = researchInputSchema.safeParse({
+      question: 'What is AI?',
+      tier: 'balanced',
+    });
+    expect(validInput.success).toBe(true);
+  });
+
+  it('should validate tier enum', () => {
+    const invalidTier = researchInputSchema.safeParse({
+      question: 'Test?',
+      tier: 'invalid',
+    });
+    expect(invalidTier.success).toBe(false);
+
+    const validTiers = ['fast', 'balanced', 'deep'];
+    validTiers.forEach(tier => {
+      const result = researchInputSchema.safeParse({
+        question: 'Test?',
+        tier,
+      });
+      expect(result.success).toBe(true);
+    });
+  });
+
+  it('should execute with mocked pipeline', async () => {
+    const { researchWithPerplexity, reasonWithSonnet, verifyWithGPT5 } =
+      await import('../pipeline');
+
+    // Mock the pipeline functions
+    vi.mocked(researchWithPerplexity).mockResolvedValue({
+      notes: 'Test notes',
+      cites: ['https://example.com'],
+      usage: { inputTokens: 100, outputTokens: 100 },
+    });
+
+    vi.mocked(reasonWithSonnet).mockResolvedValue({
+      claims: [{ statement: 'Test', supportedBy: ['https://example.com'], confidence: 'high' }],
+      assumptions: [],
+      gaps: [],
+      answerDraft: 'Draft',
+      usage: { inputTokens: 100, outputTokens: 100 },
+    });
+
+    vi.mocked(verifyWithGPT5).mockResolvedValue({
+      finalAnswer: 'Final answer',
+      flags: [],
+      trace: [],
+      confidence: 'high',
+      usage: { inputTokens: 100, outputTokens: 100 },
+    });
+
+    const tool = createResearchTool();
+    expect(tool.execute).toBeDefined();
+    const result = await tool.execute!(
+      { question: 'Test?', tier: 'balanced' },
+      { toolCallId: 'test-call-id', messages: [] },
+    );
+
+    expect(result).toHaveProperty('success');
+    expect(result).toHaveProperty('answer');
+  });
+
+  it('should handle errors gracefully', async () => {
+    const { researchWithPerplexity } = await import('../pipeline');
+
+    // Mock error
+    vi.mocked(researchWithPerplexity).mockRejectedValue(new Error('API error'));
+
+    const tool = createResearchTool();
+    expect(tool.execute).toBeDefined();
+    const result = await tool.execute!(
+      { question: 'Test?', tier: 'fast' },
+      { toolCallId: 'test-call-id', messages: [] },
+    );
+
+    expect(result).toHaveProperty('success', false);
+    expect(result).toHaveProperty('error');
+  });
+
+  it('should emit signals when callbacks provided', async () => {
+    const { researchWithPerplexity, reasonWithSonnet, verifyWithGPT5 } =
+      await import('../pipeline');
+
+    // Mock successful execution
+    vi.mocked(researchWithPerplexity).mockResolvedValue({
+      notes: 'Notes',
+      cites: ['https://example.com'],
+      usage: { inputTokens: 100, outputTokens: 100 },
+    });
+
+    vi.mocked(reasonWithSonnet).mockResolvedValue({
+      claims: [{ statement: 'Test', supportedBy: ['https://example.com'], confidence: 'high' }],
+      assumptions: [],
+      gaps: [],
+      answerDraft: 'Draft',
+      usage: { inputTokens: 100, outputTokens: 100 },
+    });
+
+    vi.mocked(verifyWithGPT5).mockResolvedValue({
+      finalAnswer: 'Answer',
+      flags: [],
+      trace: [],
+      confidence: 'high',
+      usage: { inputTokens: 100, outputTokens: 100 },
+    });
+
+    const onSignal = vi.fn();
+    const tool = createResearchTool({ onSignal });
+
+    expect(tool.execute).toBeDefined();
+    await tool.execute!(
+      { question: 'Test?', tier: 'balanced' },
+      { toolCallId: 'test-call-id', messages: [] },
+    );
+
+    expect(onSignal).toHaveBeenCalledTimes(2);
+    const [startCall, endCall] = onSignal.mock.calls;
+
+    expect(startCall?.[0]).toMatchObject({
+      type: 'tool.executed',
+      message: expect.stringContaining('Starting multi-model research'),
+      metadata: expect.objectContaining({ question: 'Test?', tier: 'balanced' }),
+    });
+
+    expect(endCall?.[0]).toMatchObject({
+      type: 'tool.executed',
+      message: expect.stringContaining('Research completed'),
+      metadata: expect.objectContaining({ confidence: 'high', flagCount: 0 }),
+    });
+  });
+});

package/src/grounding/rag/__tests__/trace.test.ts

@@ -0,0 +1,229 @@
+/**
+ * @fileoverview Tests for trace utilities
+ * Tests for trace utilities
+ */
+
+import { mkdtempSync, rmSync } from 'node:fs';
+import os from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  endRun,
+  endStep,
+  estimateCost,
+  listRuns,
+  loadRun,
+  loadStepArtifact,
+  persistRunIndex,
+  persistRunMeta,
+  persistStep,
+  startRun,
+  startStep,
+} from '../trace';
+
+describe('Trace Utilities', () => {
+  describe('startRun', () => {
+    it('should create a new run with unique ID', () => {
+      const run1 = startRun('Test question 1', 'balanced');
+      const run2 = startRun('Test question 2', 'balanced');
+
+      expect(run1.runId).not.toBe(run2.runId);
+      expect(run1).toHaveProperty('question', 'Test question 1');
+      expect(run2).toHaveProperty('question', 'Test question 2');
+    });
+
+    it('should include all required fields', () => {
+      const run = startRun('Test?', 'fast', 'test-app');
+
+      expect(run).toHaveProperty('runId');
+      expect(run).toHaveProperty('app', 'test-app');
+      expect(run).toHaveProperty('question', 'Test?');
+      expect(run).toHaveProperty('tier', 'fast');
+      expect(run).toHaveProperty('startedAt');
+      expect(run).toHaveProperty('steps');
+      expect(Array.isArray(run.steps)).toBe(true);
+    });
+
+    it('should use default app name', () => {
+      const run = startRun('Test?', 'balanced');
+      expect(run.app).toBe('research-agent');
+    });
+  });
+
+  describe('startStep', () => {
+    it('should create a new step', () => {
+      const step = startStep('context-expansion', 'llama-3.1-sonar-large-128k-online');
+
+      expect(step).toHaveProperty('id');
+      expect(step).toHaveProperty('kind', 'context-expansion');
+      expect(step).toHaveProperty('model', 'llama-3.1-sonar-large-128k-online');
+      expect(step).toHaveProperty('startAt');
+      expect(step).toHaveProperty('latencyMs', 0);
+    });
+
+    it('should support all step kinds', () => {
+      const kinds = ['context-expansion', 'reasoning', 'verification'] as const;
+
+      kinds.forEach(kind => {
+        const step = startStep(kind);
+        expect(step.kind).toBe(kind);
+      });
+    });
+  });
+
+  describe('endStep', () => {
+    it('should calculate latency', async () => {
+      const step = startStep('context-expansion');
+
+      // Wait a bit
+      await new Promise(resolve => setTimeout(resolve, 10));
+
+      const endedStep = endStep(step, {
+        inputTokens: 100,
+        outputTokens: 200,
+      });
+
+      expect(endedStep.latencyMs).toBeGreaterThan(0);
+      expect(endedStep.inputTokens).toBe(100);
+      expect(endedStep.outputTokens).toBe(200);
+    });
+
+    it('should estimate cost when model provided', () => {
+      const step = startStep('context-expansion', 'gpt-4-turbo');
+
+      const endedStep = endStep(step, {
+        inputTokens: 1000,
+        outputTokens: 1000,
+      });
+
+      expect(endedStep.costUSD).toBeGreaterThan(0);
+    });
+
+    it('should accept manual cost override', () => {
+      const step = startStep('context-expansion');
+
+      const endedStep = endStep(step, {
+        inputTokens: 100,
+        outputTokens: 100,
+        costUSD: 0.05,
+      });
+
+      expect(endedStep.costUSD).toBe(0.05);
+    });
+  });
+
+  describe('endRun', () => {
+    it('should calculate total latency and cost', async () => {
+      const run = startRun('Test?', 'balanced');
+
+      const step1 = startStep('context-expansion', 'gpt-4-turbo');
+      await new Promise(resolve => setTimeout(resolve, 10));
+      endStep(step1, { inputTokens: 100, outputTokens: 100 });
+      run.steps.push(step1);
+
+      const step2 = startStep('reasoning', 'claude-3-5-sonnet-20241022');
+      await new Promise(resolve => setTimeout(resolve, 10));
+      endStep(step2, { inputTokens: 200, outputTokens: 200 });
+      run.steps.push(step2);
+
+      const endedRun = endRun(run);
+
+      expect(endedRun.totalLatencyMs).toBeGreaterThan(0);
+      expect(endedRun.totalCostUSD).toBeGreaterThan(0);
+      expect(endedRun).toHaveProperty('endedAt');
+    });
+  });
+
+  describe('estimateCost', () => {
+    it('should estimate cost for known models', () => {
+      // Perplexity flat rate
+      expect(estimateCost('perplexity-latest', 0, 0)).toBeGreaterThan(0);
+
+      // GPT-4 Turbo
+      expect(estimateCost('gpt-4-turbo', 1000, 1000)).toBeGreaterThan(0);
+
+      // Claude Sonnet
+      expect(estimateCost('claude-3-5-sonnet-20241022', 1000, 1000)).toBeGreaterThan(0);
+    });
+
+    it('should return 0 for unknown models', () => {
+      expect(estimateCost('unknown-model', 1000, 1000)).toBe(0);
+    });
+
+    it('should handle edge cases', () => {
+      expect(estimateCost('gpt-4-turbo', 0, 0)).toBe(0);
+      expect(estimateCost('gpt-4-turbo', -100, -100)).toBeLessThanOrEqual(0);
+    });
+  });
+
+  describe('run ID validation', () => {
+    it('should generate valid run IDs', () => {
+      const run = startRun('Test?', 'balanced');
+
+      // Run ID format: timestamp-hash
+      const parts = run.runId.split('-');
+      expect(parts).toHaveLength(2);
+
+      const timestamp = parseInt(parts[0] ?? '', 10);
+      expect(timestamp).toBeGreaterThan(0);
+
+      const hash = parts[1];
+      expect(hash).toHaveLength(12);
+      expect(/^[0-9a-f]{12}$/i.test(hash ?? '')).toBe(true);
+    });
+  });
+
+  describe('trace persistence', () => {
+    let tempDir: string;
+
+    beforeEach(() => {
+      tempDir = mkdtempSync(join(os.tmpdir(), 'ai-platform-traces-'));
+      process.env.NEXT_AI_TRACES_PATH = tempDir;
+    });
+
+    afterEach(() => {
+      rmSync(tempDir, { recursive: true, force: true });
+      delete process.env.NEXT_AI_TRACES_PATH;
+    });
+
+    it('persists runs and artifacts to disk', async () => {
+      const run = startRun('Persist?', 'balanced');
+      const step = endStep(startStep('context-expansion', 'gpt-4-turbo'), {
+        inputTokens: 10,
+        outputTokens: 20,
+      });
+      run.steps.push(step);
+
+      await persistStep(run, step, { summary: { text: 'hello' } });
+      await persistRunMeta(run);
+      await persistRunIndex(run);
+
+      const runs = await listRuns(10);
+      // Test isolation: check our run is in the list (other tests may add runs)
+      expect(runs.length).toBeGreaterThanOrEqual(1);
+      expect(runs.some(r => r.runId === run.runId)).toBe(true);
+
+      const loaded = await loadRun(run.runId);
+      expect(loaded?.runId).toBe(run.runId);
+      const artifactKey = loaded?.steps[0]?.artifactKeys?.[0];
+      expect(artifactKey).toBeDefined();
+
+      const artifact = await loadStepArtifact(run.runId, artifactKey ?? '');
+      expect(artifact).toMatchObject({ text: 'hello' });
+    });
+
+    it('guards against invalid artifact access', async () => {
+      const invalidRun = await loadRun('../bad-run');
+      expect(invalidRun).toBeNull();
+
+      const artifact = await loadStepArtifact('1733875200000-badbadbadbad', '../escape');
+      expect(artifact).toBeNull();
+
+      // Test artifactKey with slash rejection branch
+      const artifactWithSlash = await loadStepArtifact('1733875200000-badbadbadbad', 'bad/key');
+      expect(artifactWithSlash).toBeNull();
+    });
+  });
+});