@od-oneapp/ai-platform 0.1.0

package/src/internal/__tests__/hallucination.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Hallucination detection smoke tests
+ */
+
+import { describe, it, expect } from 'vitest';
+
+import {
+  detectHallucinations,
+  extractClaims,
+  calculateJaccardSimilarity,
+  verifyClaim,
+  createHallucinationDetector,
+} from "../grounding/hallucination";
+
+import type { GroundingSource } from '../grounding/types';
+
+describe('Hallucination Detection', () => {
+  const testSources: GroundingSource[] = [
+    {
+      id: 'source-1',
+      content: 'The company was founded in 2019 with a team of 10 engineers.',
+      url: 'https://example.com/about',
+    },
+    {
+      id: 'source-2',
+      content: 'Revenue reached $5 million in the first year of operation.',
+      url: 'https://example.com/financials',
+    },
+  ];
+
+  describe('extractClaims', () => {
+    it('should extract factual claims from text', () => {
+      const text = 'The company has 100 employees. What do you think? Maybe it will grow.';
+      const claims = extractClaims(text);
+
+      expect(claims.length).toBeGreaterThan(0);
+      expect(claims[0].text).toContain('100 employees');
+    });
+
+    it('should skip questions and hedged statements', () => {
+      const text = 'What is the revenue? I think it might be growing. Perhaps the team is large.';
+      const claims = extractClaims(text);
+
+      // Should skip questions and hedged statements
+      expect(claims.every(c => !c.text.includes('?'))).toBe(true);
+    });
+
+    it('should identify claims with proper nouns', () => {
+      const text = 'John Smith joined the company. The weather is nice.';
+      const claims = extractClaims(text);
+
+      const hasProperNounClaim = claims.some(c => c.text.includes('John Smith'));
+      expect(hasProperNounClaim).toBe(true);
+    });
+  });
+
+  describe('calculateJaccardSimilarity', () => {
+    it('should return 1 for identical texts', () => {
+      const similarity = calculateJaccardSimilarity(
+        'The company was founded in 2019',
+        'The company was founded in 2019',
+      );
+      expect(similarity).toBe(1);
+    });
+
+    it('should return 0 for completely different texts', () => {
+      const similarity = calculateJaccardSimilarity('apple banana cherry', 'xyz abc def');
+      expect(similarity).toBe(0);
+    });
+
+    it('should return value between 0 and 1 for partial overlap', () => {
+      const similarity = calculateJaccardSimilarity(
+        'The company was founded in 2019',
+        'The company started operations in 2020',
+      );
+      expect(similarity).toBeGreaterThan(0);
+      expect(similarity).toBeLessThan(1);
+    });
+  });
+
+  describe('verifyClaim', () => {
+    it('should identify supported claims', () => {
+      const claim = {
+        text: 'The company was founded in 2019 with 10 engineers.',
+        startIndex: 0,
+        endIndex: 50,
+      };
+
+      const result = verifyClaim(claim, testSources);
+
+      expect(result.isSupported).toBe(true);
+      expect(result.supportingSources).toContain('source-1');
+    });
+
+    it('should identify unsupported claims', () => {
+      const claim = {
+        text: 'The company has offices in 50 countries worldwide.',
+        startIndex: 0,
+        endIndex: 50,
+      };
+
+      const result = verifyClaim(claim, testSources, { threshold: 0.5 });
+
+      expect(result.isSupported).toBe(false);
+      expect(result.supportingSources).toHaveLength(0);
+    });
+  });
+
+  describe('detectHallucinations', () => {
+    it('should detect hallucinated content', async () => {
+      const text = 'The company was founded in 2020 and has 500 employees.';
+      const result = await detectHallucinations(text, testSources);
+
+      // The year is wrong (2020 vs 2019) so it should be marked as hallucinated
+      expect(result.unsupportedClaims.length).toBeGreaterThanOrEqual(0);
+      expect(result.summary).toBeDefined();
+    });
+
+    it('should identify supported content', async () => {
+      const text = 'The company was founded in 2019 with a team of engineers.';
+      const result = await detectHallucinations(text, testSources);
+
+      expect(result.supportedClaims.length).toBeGreaterThan(0);
+    });
+
+    it('should return no hallucinations for empty text', async () => {
+      const result = await detectHallucinations('', testSources);
+
+      expect(result.isHallucinated).toBe(false);
+      expect(result.verificationResults).toHaveLength(0);
+    });
+
+    it('should handle custom options', async () => {
+      const text = 'The company was founded in 2019.';
+      const result = await detectHallucinations(text, testSources, {
+        supportThreshold: 0.1,
+      });
+
+      expect(result.verificationResults.length).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('createHallucinationDetector', () => {
+    it('should create a reusable detector', async () => {
+      const detector = createHallucinationDetector({
+        supportThreshold: 0.3,
+      });
+
+      const result = await detector.detect('The company was founded in 2019.', testSources);
+
+      expect(result).toBeDefined();
+      expect(result.summary).toBeDefined();
+    });
+
+    it('should expose utility methods', () => {
+      const detector = createHallucinationDetector();
+
+      const claims = detector.extractClaims('The company has 100 employees.');
+      expect(claims.length).toBeGreaterThanOrEqual(0);
+    });
+  });
+});

package/src/internal/__tests__/models.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Model registry smoke tests
+ */
+
+import { describe, it, expect } from 'vitest';
+
+import { Model, MODEL_METADATA, getModelId, getModelTier, estimateCost } from "../models";
+
+describe('Model Registry', () => {
+  describe('model enum', () => {
+    it('should have semantic model names', () => {
+      expect(Model.OPUS).toBe('opus');
+      expect(Model.SONNET).toBe('sonnet');
+      expect(Model.HAIKU).toBe('haiku');
+      expect(Model.GPT_4O).toBe('gpt-4o');
+    });
+
+    it('should cover all major providers', () => {
+      // Anthropic
+      expect(Model.OPUS).toBeDefined();
+      expect(Model.SONNET).toBeDefined();
+      expect(Model.HAIKU).toBeDefined();
+
+      // OpenAI
+      expect(Model.GPT_4O).toBeDefined();
+      expect(Model.GPT_4_TURBO).toBeDefined();
+    });
+  });
+
+  describe('mODEL_METADATA', () => {
+    it('should have metadata for all models', () => {
+      const models = Object.values(Model);
+      for (const model of models) {
+        const metadata = MODEL_METADATA[model];
+        expect(metadata).toBeDefined();
+        expect(metadata.provider).toBeDefined();
+        expect(metadata.contextWindow).toBeGreaterThan(0);
+      }
+    });
+
+    it('should have pricing for all models', () => {
+      const models = Object.values(Model);
+      for (const model of models) {
+        const metadata = MODEL_METADATA[model];
+        expect(metadata.costPer1kInput).toBeGreaterThanOrEqual(0);
+        expect(metadata.costPer1kOutput).toBeGreaterThanOrEqual(0);
+      }
+    });
+
+    it('should have correct provider assignments', () => {
+      expect(MODEL_METADATA[Model.OPUS].provider).toBe('anthropic');
+      expect(MODEL_METADATA[Model.SONNET].provider).toBe('anthropic');
+      expect(MODEL_METADATA[Model.HAIKU].provider).toBe('anthropic');
+      expect(MODEL_METADATA[Model.GPT_4O].provider).toBe('openai');
+      expect(MODEL_METADATA[Model.GPT_4_TURBO].provider).toBe('openai');
+    });
+  });
+
+  describe('getModelId', () => {
+    it('should return full model ID for gateway routing', () => {
+      const id = getModelId(Model.SONNET);
+      expect(typeof id).toBe('string');
+      expect(id.length).toBeGreaterThan(0);
+    });
+
+    it('should return different IDs for different models', () => {
+      const opusId = getModelId(Model.OPUS);
+      const sonnetId = getModelId(Model.SONNET);
+      expect(opusId).not.toBe(sonnetId);
+    });
+  });
+
+  describe('getModelTier', () => {
+    it('should categorize models by capability tier', () => {
+      expect(getModelTier(Model.OPUS)).toBe('powerful');
+      expect(getModelTier(Model.SONNET)).toBe('balanced');
+      expect(getModelTier(Model.HAIKU)).toBe('fast');
+    });
+
+    it('should return reasoning tier for reasoning models', () => {
+      expect(getModelTier(Model.O1_PREVIEW)).toBe('reasoning');
+    });
+  });
+
+  describe('estimateCost', () => {
+    it('should estimate cost based on token usage', () => {
+      const cost = estimateCost(Model.SONNET, 1000, 500);
+      expect(cost).toBeGreaterThan(0);
+      expect(typeof cost).toBe('number');
+    });
+
+    it('should return 0 for 0 tokens', () => {
+      const cost = estimateCost(Model.SONNET, 0, 0);
+      expect(cost).toBe(0);
+    });
+
+    it('should calculate cost correctly', () => {
+      // SONNET has costPer1kInput: 3, costPer1kOutput: 15
+      const cost = estimateCost(Model.SONNET, 1000, 1000);
+      // 1k input * $3/1k + 1k output * $15/1k = $18
+      expect(cost).toBe(18);
+    });
+  });
+});

package/src/internal/__tests__/sdk-errors.test.ts

@@ -0,0 +1,201 @@
+/**
+ * SDK error hierarchy smoke tests
+ */
+
+import { describe, it, expect } from 'vitest';
+
+import {
+  PlatformAIError,
+  BudgetExceededError,
+  GuardrailError,
+  RateLimitError,
+  ModelUnavailableError,
+  CircuitOpenError,
+  PromptInjectionError,
+  TenantQuotaError,
+  ValidationError,
+  isPlatformError,
+  isRetryableError,
+} from "../sdk/errors";
+
+describe('SDK Error Hierarchy', () => {
+  describe('platformAIError', () => {
+    it('should create base error with required fields', () => {
+      const error = new PlatformAIError({
+        message: 'Test error',
+        code: 'TEST_ERROR',
+      });
+
+      expect(error.message).toBe('Test error');
+      expect(error.code).toBe('TEST_ERROR');
+      expect(error.isRetryable).toBe(false);
+      expect(error.name).toBe('PlatformAIError');
+    });
+
+    it('should support optional metadata', () => {
+      const error = new PlatformAIError({
+        message: 'Test error',
+        code: 'TEST_ERROR',
+        metadata: { userId: '123' },
+      });
+
+      expect(error.metadata).toStrictEqual({ userId: '123' });
+    });
+
+    it('should serialize to JSON', () => {
+      const error = new PlatformAIError({
+        message: 'Test error',
+        code: 'TEST_ERROR',
+      });
+
+      const json = error.toJSON();
+      expect(json.message).toBe('Test error');
+      expect(json.code).toBe('TEST_ERROR');
+    });
+  });
+
+  describe('budgetExceededError', () => {
+    it('should capture budget details', () => {
+      const error = new BudgetExceededError({
+        message: 'Daily budget exceeded',
+        budgetType: 'daily',
+        currentSpend: 100,
+        limit: 50,
+      });
+
+      expect(error.budgetType).toBe('daily');
+      expect(error.currentSpend).toBe(100);
+      expect(error.limit).toBe(50);
+      expect(error.code).toBe('BUDGET_EXCEEDED');
+      expect(error.isRetryable).toBe(false);
+    });
+  });
+
+  describe('rateLimitError', () => {
+    it('should be retryable', () => {
+      const error = new RateLimitError({
+        message: 'Rate limit exceeded',
+        retryAfterMs: 5000,
+      });
+
+      expect(error.isRetryable).toBe(true);
+      expect(error.retryAfterMs).toBe(5000);
+      expect(error.code).toBe('RATE_LIMIT_EXCEEDED');
+    });
+  });
+
+  describe('guardrailError', () => {
+    it('should capture violations', () => {
+      const error = new GuardrailError({
+        message: 'Content policy violation',
+        guardrailType: 'content-filter',
+        violations: ['profanity', 'violence'],
+      });
+
+      expect(error.guardrailType).toBe('content-filter');
+      expect(error.violations).toStrictEqual(['profanity', 'violence']);
+      expect(error.code).toBe('GUARDRAIL_VIOLATION');
+    });
+  });
+
+  describe('modelUnavailableError', () => {
+    it('should indicate fallback availability', () => {
+      const error = new ModelUnavailableError({
+        message: 'Model unavailable',
+        model: 'gpt-4',
+        fallbackAvailable: true,
+      });
+
+      expect(error.model).toBe('gpt-4');
+      expect(error.fallbackAvailable).toBe(true);
+      expect(error.isRetryable).toBe(true);
+    });
+  });
+
+  describe('circuitOpenError', () => {
+    it('should indicate next retry time', () => {
+      const nextRetry = new Date(Date.now() + 60000);
+      const error = new CircuitOpenError({
+        message: 'Circuit breaker open',
+        circuitName: 'openai-api',
+        nextRetryAt: nextRetry,
+      });
+
+      expect(error.circuitName).toBe('openai-api');
+      expect(error.nextRetryAt).toStrictEqual(nextRetry);
+      expect(error.code).toBe('CIRCUIT_OPEN');
+    });
+  });
+
+  describe('promptInjectionError', () => {
+    it('should capture detection details', () => {
+      const error = new PromptInjectionError({
+        message: 'Prompt injection detected',
+        confidence: 0.95,
+        patterns: ['ignore previous', 'system prompt'],
+      });
+
+      expect(error.confidence).toBe(0.95);
+      expect(error.patterns).toHaveLength(2);
+      expect(error.code).toBe('PROMPT_INJECTION_DETECTED');
+    });
+  });
+
+  describe('tenantQuotaError', () => {
+    it('should capture tenant and quota details', () => {
+      const error = new TenantQuotaError({
+        message: 'Tenant quota exceeded',
+        tenantId: 'tenant-123',
+        quotaType: 'requests',
+        current: 1000,
+        limit: 500,
+      });
+
+      expect(error.tenantId).toBe('tenant-123');
+      expect(error.quotaType).toBe('requests');
+      expect(error.current).toBe(1000);
+      expect(error.limit).toBe(500);
+    });
+  });
+
+  describe('validationError', () => {
+    it('should capture field information', () => {
+      const error = new ValidationError({
+        message: 'Invalid email format',
+        field: 'email',
+        value: 'not-an-email',
+      });
+
+      expect(error.field).toBe('email');
+      expect(error.value).toBe('not-an-email');
+      expect(error.code).toBe('VALIDATION_ERROR');
+    });
+  });
+
+  describe('type guards', () => {
+    it('isPlatformError should identify platform errors', () => {
+      const platformError = new PlatformAIError({
+        message: 'Test',
+        code: 'TEST',
+      });
+      const regularError = new Error('Regular error');
+
+      expect(isPlatformError(platformError)).toBe(true);
+      expect(isPlatformError(regularError)).toBe(false);
+      expect(isPlatformError(null)).toBe(false);
+    });
+
+    it('isRetryableError should identify retryable errors', () => {
+      const retryable = new RateLimitError({ message: 'Rate limit' });
+      const notRetryable = new BudgetExceededError({
+        message: 'Budget',
+        budgetType: 'daily',
+        currentSpend: 100,
+        limit: 50,
+      });
+
+      expect(isRetryableError(retryable)).toBe(true);
+      expect(isRetryableError(notRetryable)).toBe(false);
+    });
+  });
+});

package/src/internal/__tests__/stop-conditions.test.ts

@@ -0,0 +1,210 @@
+/**
+ * Stop conditions smoke tests
+ */
+
+import { describe, it, expect } from 'vitest';
+
+import {
+  stepCountIs,
+  hasToolCall,
+  noToolCalls,
+  textContains,
+  textEquals,
+  textEndsWith,
+  anyOf,
+  allOf,
+  not,
+  afterTimeout,
+  toolResultContains,
+} from "../sdk/stop-conditions";
+
+describe('Stop Conditions', () => {
+  describe('stepCountIs', () => {
+    it('should stop when step count is reached', () => {
+      const condition = stepCountIs(5);
+
+      expect(condition({ stepCount: 3 })).toBe(false);
+      expect(condition({ stepCount: 5 })).toBe(true);
+      expect(condition({ stepCount: 10 })).toBe(true);
+    });
+  });
+
+  describe('hasToolCall', () => {
+    it('should stop when specific tool is called', () => {
+      const condition = hasToolCall('submit');
+
+      expect(
+        condition({
+          stepCount: 1,
+          toolCalls: [{ toolName: 'search', args: {} }],
+        }),
+      ).toBe(false);
+
+      expect(
+        condition({
+          stepCount: 1,
+          toolCalls: [{ toolName: 'submit', args: {} }],
+        }),
+      ).toBe(true);
+    });
+
+    it('should accept array of tool names', () => {
+      const condition = hasToolCall(['submit', 'complete']);
+
+      expect(
+        condition({
+          stepCount: 1,
+          toolCalls: [{ toolName: 'complete', args: {} }],
+        }),
+      ).toBe(true);
+    });
+
+    it('should return false when no tool calls', () => {
+      const condition = hasToolCall('submit');
+      expect(condition({ stepCount: 1 })).toBe(false);
+    });
+  });
+
+  describe('noToolCalls', () => {
+    it('should stop when no tools are called', () => {
+      const condition = noToolCalls();
+
+      expect(condition({ stepCount: 1 })).toBe(true);
+      expect(condition({ stepCount: 1, toolCalls: [] })).toBe(true);
+      expect(
+        condition({
+          stepCount: 1,
+          toolCalls: [{ toolName: 'search', args: {} }],
+        }),
+      ).toBe(false);
+    });
+  });
+
+  describe('textContains', () => {
+    it('should stop when text contains pattern (string)', () => {
+      const condition = textContains('DONE');
+
+      expect(condition({ stepCount: 1, text: 'Processing...' })).toBe(false);
+      expect(condition({ stepCount: 1, text: 'Task DONE' })).toBe(true);
+    });
+
+    it('should stop when text contains pattern (regex)', () => {
+      const condition = textContains(/\bDONE\b/i);
+
+      expect(condition({ stepCount: 1, text: 'done' })).toBe(true);
+      expect(condition({ stepCount: 1, text: 'DONE' })).toBe(true);
+      expect(condition({ stepCount: 1, text: 'abandon' })).toBe(false);
+    });
+
+    it('should return false when no text', () => {
+      const condition = textContains('DONE');
+      expect(condition({ stepCount: 1 })).toBe(false);
+    });
+  });
+
+  describe('textEquals', () => {
+    it('should stop when text equals exactly', () => {
+      const condition = textEquals('COMPLETED');
+
+      expect(condition({ stepCount: 1, text: 'COMPLETED' })).toBe(true);
+      expect(condition({ stepCount: 1, text: '  COMPLETED  ' })).toBe(true);
+      expect(condition({ stepCount: 1, text: 'DONE' })).toBe(false);
+    });
+  });
+
+  describe('textEndsWith', () => {
+    it('should stop when text ends with suffix', () => {
+      const condition = textEndsWith('</result>');
+
+      expect(condition({ stepCount: 1, text: 'Some output</result>' })).toBe(true);
+      expect(condition({ stepCount: 1, text: '</result> more text' })).toBe(false);
+    });
+  });
+
+  describe('anyOf', () => {
+    it('should stop when any condition is met', async () => {
+      const condition = anyOf(stepCountIs(5), noToolCalls());
+
+      await expect(condition({ stepCount: 3, toolCalls: [] })).resolves.toBe(true);
+      await expect(
+        condition({
+          stepCount: 5,
+          toolCalls: [{ toolName: 'x', args: {} }],
+        }),
+      ).resolves.toBe(true);
+      await expect(
+        condition({
+          stepCount: 3,
+          toolCalls: [{ toolName: 'x', args: {} }],
+        }),
+      ).resolves.toBe(false);
+    });
+  });
+
+  describe('allOf', () => {
+    it('should stop when all conditions are met', async () => {
+      const condition = allOf(stepCountIs(5), noToolCalls());
+
+      await expect(condition({ stepCount: 5, toolCalls: [] })).resolves.toBe(true);
+      await expect(condition({ stepCount: 3, toolCalls: [] })).resolves.toBe(false);
+      await expect(
+        condition({
+          stepCount: 5,
+          toolCalls: [{ toolName: 'x', args: {} }],
+        }),
+      ).resolves.toBe(false);
+    });
+  });
+
+  describe('not', () => {
+    it('should negate a condition', async () => {
+      const condition = not(noToolCalls());
+
+      await expect(condition({ stepCount: 1, toolCalls: [] })).resolves.toBe(false);
+      await expect(
+        condition({
+          stepCount: 1,
+          toolCalls: [{ toolName: 'x', args: {} }],
+        }),
+      ).resolves.toBe(true);
+    });
+  });
+
+  describe('afterTimeout', () => {
+    it('should stop after timeout', async () => {
+      const condition = afterTimeout(50);
+
+      expect(condition({ stepCount: 1 })).toBe(false);
+
+      await new Promise(resolve => setTimeout(resolve, 60));
+
+      expect(condition({ stepCount: 1 })).toBe(true);
+    });
+  });
+
+  describe('toolResultContains', () => {
+    it('should check tool result with predicate', () => {
+      const condition = toolResultContains('search', result => {
+        if (typeof result !== 'object' || result === null) {
+          return false;
+        }
+        const record = result as Record<string, unknown>;
+        return record.found === true;
+      });
+
+      expect(
+        condition({
+          stepCount: 1,
+          toolResults: [{ toolName: 'search', output: { found: true, items: [] } }],
+        }),
+      ).toBe(true);
+
+      expect(
+        condition({
+          stepCount: 1,
+          toolResults: [{ toolName: 'search', output: { found: false } }],
+        }),
+      ).toBe(false);
+    });
+  });
+});