@repo/ai-oneapp

pnpm add @repo/ai-oneapp

import { PlatformOrchestrator } from "@repo/ai-oneapp/agents/orchestrator";
import { anthropic } from "@ai-sdk/anthropic";

// highlight-start
const orchestrator = new PlatformOrchestrator({
  model: anthropic("claude-sonnet-4"),
  riskLevel: "medium",
  enableGuardrails: true
});
// highlight-end

const result = await orchestrator.execute({
  prompt: "Analyze this customer query",
  userId: "user-123"
});

console.log(result.response);

import { createAgent } from "@repo/ai-oneapp/agents";
import { guardrailPolicy } from "@repo/ai-oneapp/policies/guardrails";
import { loopControlPolicy } from "@repo/ai-oneapp/policies/loop-controls";

// highlight-start
const agent = createAgent({
  model: anthropic("claude-sonnet-4"),
  policies: [guardrailPolicy({ level: "strict" }), loopControlPolicy({ maxIterations: 5 })]
});
// highlight-end

const stream = await agent.streamText({
  prompt: userInput
});

for await (const chunk of stream) {
  console.log(chunk.text);
}

import { ResearchPipeline } from "@repo/ai-oneapp/research/pipeline";

// highlight-start
const pipeline = new ResearchPipeline({
  perplexity: { apiKey: process.env.PERPLEXITY_API_KEY },
  anthropic: { apiKey: process.env.ANTHROPIC_API_KEY },
  openai: { apiKey: process.env.OPENAI_API_KEY }
});
// highlight-end

const research = await pipeline.research({
  query: "What are the latest GDPR requirements for AI systems?",
  depth: "comprehensive"
});

console.log(research.findings);
console.log(`Confidence: ${research.confidence}%`);
console.log(`Citations: ${research.citations.length}`);

import { ProofMap } from "@repo/ai-oneapp/proof-map";
import { verifyChain } from "@repo/ai-oneapp/proof-map/loop";

// highlight-start
const proofMap = new ProofMap({
  claim: "System meets HIPAA compliance requirements",
  evidence: [
    /* ... */
  ]
});
// highlight-end

const verified = await verifyChain(proofMap, {
  model: anthropic("claude-sonnet-4"),
  maxIterations: 2
});

console.log(verified.result); // 'verified' | 'rejected' | 'uncertain'
console.log(verified.reasoning);

interface OrchestratorOptions {
  model: LanguageModel; // AI SDK model instance
  riskLevel?: "low" | "medium" | "high"; // Default: 'medium'
  enableGuardrails?: boolean; // Default: true
  enableTelemetry?: boolean; // Default: true
  maxIterations?: number; // Default: varies by risk
  tools?: Record<string, Tool>; // Custom tools
}

interface GuardrailConfig {
  level: "permissive" | "balanced" | "strict";
  customPatterns?: Array<{ pattern: RegExp; reason: string }>;
  enablePII?: boolean; // Default: true
  enableSQLInjection?: boolean; // Default: true
  enablePromptInjection?: boolean; // Default: true
}

interface ResearchConfig {
  perplexity: { apiKey: string; model?: string };
  anthropic: { apiKey: string; model?: string };
  openai: { apiKey: string; model?: string };
  enableCitations?: boolean; // Default: true
  enableTracing?: boolean; // Default: true
}

interface ResearchResult {
  findings: string; // Consolidated findings
  confidence: number; // 0-100 confidence score
  citations: Array<{
    source: string;
    url: string;
    relevance: number;
  }>;
  reasoning: {
    claims: string[];
    assumptions: string[];
    gaps: string[];
  };
  metadata: {
    tokensUsed: number;
    duration: number;
    models: string[];
  };
}

@repo/ai-oneapp/
├── agents/              # Agent orchestration
│   ├── orchestrator.ts  # Risk-aware agent factory
│   ├── agent.ts         # Base agent implementation
│   └── tools/           # MCP and custom tools
├── policies/            # Compliance policies
│   ├── guardrails.ts    # Content filtering
│   ├── loop-controls.ts # Iteration limits
│   └── telemetry.ts     # Audit logging
├── research/            # Multi-model research
│   ├── pipeline.ts      # 3-stage pipeline
│   ├── tool.ts          # Research tool wrapper
│   ├── trace.ts         # Execution tracing
│   └── types.ts         # Type definitions
├── proof-map/           # Verification framework
│   ├── schema.ts        # Proof structure
│   ├── loop.ts          # Verification loops
│   └── applyPatch.ts    # Safe edits
└── shared/              # Shared utilities
    ├── schemas.ts       # Zod schemas
    └── signals.ts       # Event bus

User Input
    ↓
[Guardrails] → Input Validation
    ↓
[Orchestrator] → Risk Assessment → Agent Selection
    ↓
[Agent] → Model Execution → [Loop Controls]
    ↓
[Guardrails] → Output Validation
    ↓
[Telemetry] → Compliance Events
    ↓
Response

const orchestrator = new PlatformOrchestrator({
  model: anthropic("claude-sonnet-4"),
  // highlight-next-line
  riskLevel: "high" // 2-step limit, requires escalation
});

// For customer data queries
const result = await orchestrator.execute({
  prompt: "Show me customer billing history",
  userId: "user-123"
});

// Automatically applies:
// - Max 2 iterations
// - Strict guardrails
// - Escalation signals

# Research Pipeline (Required)
PERPLEXITY_API_KEY="pplx-..."
ANTHROPIC_API_KEY="sk-ant-..."
OPENAI_API_KEY="sk-..."

# Optional
AI_TELEMETRY_ENDPOINT="https://your-telemetry-endpoint.com"
AI_TRACE_STORAGE_PATH="./traces"

# All tests
pnpm --filter @repo/ai-oneapp test

# Specific suite
pnpm --filter @repo/ai-oneapp test orchestrator

# Watch mode
pnpm --filter @repo/ai-oneapp test --watch

# Coverage
pnpm --filter @repo/ai-oneapp test --coverage

import { describe, it, expect, vi } from "vitest";
import { PlatformOrchestrator } from "@repo/ai-oneapp/agents/orchestrator";

// highlight-start
describe("PlatformOrchestrator", () => {
  it("selects agent based on risk level", async () => {
    const orchestrator = new PlatformOrchestrator({
      model: mockModel,
      riskLevel: "high"
    });

    const result = await orchestrator.execute({
      prompt: "Test prompt"
    });

    expect(result.iterations).toBeLessThanOrEqual(2);
  });
});
// highlight-end

// ❌ WRONG: Both fields use totalTokens
inputTokens: result.usage.totalTokens ?? 0,
outputTokens: result.usage.totalTokens ?? 0,

// ✅ FIX: Use correct fields
inputTokens: result.usage.inputTokens ?? 0,
outputTokens: result.usage.outputTokens ?? 0,