If you enable OpenTelemetry:

npm install @opentelemetry/sdk-node @opentelemetry/auto-instrumentations-node \
  @opentelemetry/exporter-trace-otlp-http

No native build steps are required. This is a pure Node.js backend; no iOS/Android linking needed.

Project setup

1. Copy the source/ directory into your project root, e.g. as src/.

2. Configure tsconfig.json for NestJS decorators:

{
  "compilerOptions": {
    "module": "CommonJS",
    "target": "ES2021",
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "strictNullChecks": true,
    "esModuleInterop": true,
    "outDir": "dist",
    "baseUrl": ".",
    "paths": {
      "@src/*": ["src/*"]
    }
  }
}

3. Set required environment variables (create .env):

DATABASE_URL=postgresql://user:pass@localhost:5432/manifest
BETTER_AUTH_URL=http://localhost:3001
BETTER_AUTH_SECRET=your-secret-here
PORT=3001
NODE_ENV=development
# Optional
THROTTLE_TTL=60000
THROTTLE_LIMIT=100
FRAME_ANCESTORS=
WINGMAN_PORT=3002

4. The entry point is src/main.ts. Start with:

npx ts-node -r tsconfig-paths/register src/main.ts
# or via NestJS CLI:
npx nest start

5. The first account created at the / dashboard becomes the admin.

Public API

bootstrap

export async function bootstrap(): Promise<void>

Bootstraps the NestJS application: registers Helmet with a strict Content Security Policy, enables compression, mounts the Better Auth middleware, attaches the global SpaFallbackFilter, and starts the HTTP listener on process.env.PORT (default 3001). Call this once from your process entry point. In production, BETTER_AUTH_URL must start with https:// for HSTS to activate.

detectSpecificity

export { detectSpecificity } from './specificity-detector';
// signature (from scoring/index.ts re-export):
function detectSpecificity(input: ScorerInput): SpecificityResult

Analyzes a chat message payload and returns a specificity classification. Use this when you need to decide whether a query is concrete enough to route to a smaller, cheaper model. The result includes a tier and confidence score.

scanMessages

export { scanMessages } from './scan-messages';
// usage: scanMessages(messages: ScorerInput['messages']): ScoringResult

Runs the full multi-dimension scoring pipeline over a conversation's message array. Returns a ScoringResult with per-dimension scores, a final Tier, confidence, and a list of ScoringReason entries explaining the decision. Use this outside NestJS (e.g. in a middleware or edge function) when you want scoring without standing up the full server.

SpaFallbackFilter

// common/filters/spa-fallback.filter.ts
export class SpaFallbackFilter implements ExceptionFilter {
  constructor(private readonly betterAuthUrl?: string) {}
  catch(exception: HttpException, host: ArgumentsHost): void
}

A NestJS exception filter that intercepts 404 responses for non-API routes and serves the SPA index.html. Register it globally via app.useGlobalFilters(new SpaFallbackFilter(betterAuthUrl)). It correctly passes through /api/ and /v1/ 404s as JSON errors.

Working examples

Scenario - Standalone complexity scoring before routing

You want to score an incoming OpenAI-format chat payload in a plain TypeScript script, without NestJS, to decide which model tier to use.

import { scanMessages } from './src/scoring/scan-messages';
import type { ScorerInput, Tier } from './src/scoring/index';

const input: ScorerInput = {
  messages: [
    { role: 'user', content: 'Explain the difference between TCP and UDP in one sentence.' },
  ],
};

const result = scanMessages(input.messages);
console.log('Tier:', result.tier);           // e.g. "low"
console.log('Confidence:', result.confidence);
console.log('Reasons:', result.reasons);

function pickModel(tier: Tier): string {
  if (tier === 'high') return 'gpt-4o';
  if (tier === 'medium') return 'gpt-4o-mini';
  return 'gemini-2.0-flash';
}

console.log('Route to:', pickModel(result.tier));

Scenario - Specificity detection for a multi-turn conversation

You want to know whether the latest user turn is specific enough to route to a specialist model.

import { detectSpecificity } from './src/scoring/index';
import type { ScorerInput } from './src/scoring/index';

const input: ScorerInput = {
  messages: [
    { role: 'user', content: 'I need a Python function that parses ISO 8601 dates with timezone offsets and returns a UTC timestamp as an integer.' },
    { role: 'assistant', content: 'Sure, here is a draft...' },
    { role: 'user', content: 'Add error handling for malformed strings and raise a ValueError with the offending substring.' },
  ],
};

const result = detectSpecificity(input);
console.log('Specificity tier:', result.tier);
console.log('Score:', result.score);
// Use result.tier === 'specific' to route to a code-specialist model.

Scenario - Bootstrapping the full NestJS server programmatically

Embed the Manifest backend inside a monorepo that already manages its own process lifecycle.

import { bootstrap } from './src/main';

async function start() {
  // Set env vars before calling bootstrap
  process.env['PORT'] = '4000';
  process.env['BETTER_AUTH_URL'] = 'http://localhost:4000';
  process.env['NODE_ENV'] = 'development';

  await bootstrap();
  console.log('Manifest router listening on port 4000');
}

start().catch((err) => {
  console.error('Failed to start Manifest:', err);
  process.exit(1);
});

File walkthrough

• main.ts - Entry point; configures Helmet CSP (with dev-only Wingman iframe allowance), compression, Better Auth middleware, global validation pipe, SPA fallback filter, and starts the listener.
• app.module.ts - Root @Module that imports every feature module, registers global cache, throttler, TypeORM, and serves static frontend assets when a build is present.
• analytics/ - REST controllers exposing /api/analytics/* endpoints for costs, savings, tokens, messages, and per-agent breakdowns; backed by TypeORM query services.
• auth/ - Mounts Better Auth at /api/auth/*; exports SessionGuard and @CurrentUser() decorator for controller-level auth enforcement.
• common/ - Cross-cutting: ApiKeyGuard, cache interceptors, error codes, IngestEventBusService, ManifestRuntimeService, and shared DTOs.
• config/ - appConfig factory reads env vars and exposes typed config to the DI container via ConfigModule.
• database/ - DatabaseModule bootstraps TypeORM with the configured DATABASE_URL and runs migrations on startup.
• entities/ - TypeORM entity classes (ApiKey, etc.) shared across modules.
• free-models/ - Discovers and caches model listings that are available without billing.
• github/ - GitHub OAuth callback and repository-linking flows.
• health/ - GET /api/health liveness/readiness probe powered by @nestjs/terminus.
• model-discovery/ - Polls configured providers and caches the union model list for the routing layer.
• model-prices/ - Ingests per-token price tables and exposes lookups for cost accounting in analytics.
• notifications/ - Watches spend against configured budgets and dispatches alerts.
• otlp/ - Accepts OTLP/HTTP trace and metric payloads and forwards them to the telemetry pipeline.
• public-stats/ - Unauthenticated endpoint exposing aggregate routing statistics for status pages.
• routing/ - Core proxy: selects provider/model based on scorer output and custom headers, streams the response, handles retries and fallback chains.
• scoring/ - Pure-TS library: keyword trie, structural/contextual dimension scorers, momentum adjustment, sigmoid confidence, specificity detector. No NestJS dependency.
• setup/ - First-run wizard: creates the SQLite/Postgres schema and seeds the first admin user.
• sse/ - Pushes real-time routing events to connected dashboard clients via text/event-stream.
• telemetry/ - Initializes the OpenTelemetry Node SDK with configured exporters before the NestJS app boots.

Common pitfalls and fixes

• emitDecoratorMetadata not enabled: NestJS DI silently fails to inject dependencies. Fix: ensure "emitDecoratorMetadata": true in tsconfig.json and import 'reflect-metadata' at the top of main.ts.
• BETTER_AUTH_URL missing or wrong origin: Auth callbacks redirect to the wrong host and sessions are rejected. Fix: set BETTER_AUTH_URL to the exact public-facing origin including scheme and port.
• HSTS breaks HTTP LAN deployments: Helmet enables HSTS when BETTER_AUTH_URL starts with https://, causing browsers to rewrite asset URLs. Fix: use an http:// URL for local/LAN installs; terminate TLS at a reverse proxy.
• Static assets cached at index.html: SPA routing breaks after deploys because the browser serves a stale entry point. Fix: index.html is served with Cache-Control: no-cache by ServeStaticModule; do not override this header at your proxy.
• Throttler blocks legitimate burst traffic: Default limits (100 req/60 s) are low for automated pipelines. Fix: set THROTTLE_LIMIT and THROTTLE_TTL env vars before startup.
• Scoring module imported inside NestJS DI context: scanMessages and detectSpecificity are pure functions with no NestJS decorators; importing them into a provider works fine, but do not attempt to inject them via @Injectable() wrappers you write yourself, as they have no DI tokens.

Vibe-coding prompt template

I have dropped the Manifest AI Router backend source into `src/` in my project.
The integration guide is in `USAGE.md`. The upstream package is `manifest` (backend domain).

Please help me integrate this source into my existing project step by step:

1. Read `USAGE.md` fully before making any changes.
2. Check my existing `tsconfig.json` and update it for NestJS decorator support as described.
3. Wire `src/main.ts` `bootstrap()` into my process entry point, preserving any existing
   startup logic I have.
4. Add the required environment variables from `USAGE.md` to my `.env` file, using
   placeholder values I can fill in.
5. If I already have a database module, show me how to replace it with `src/database/`
   or adapt the TypeORM config.
6. Show me how to call `scanMessages` and `detectSpecificity` from `src/scoring/`
   in my existing request middleware to add model-routing decisions without touching
   the NestJS app layer.
7. Point out any conflicts with my existing dependencies and suggest resolutions.

Work through each step one at a time and ask me to confirm before proceeding to the next.

License and credit

See source/LICENSE if present. Based on the README, the project is licensed under the terms shown in the Manifest GitHub repository (license badge visible in README). Review the LICENSE file in the upstream repository before commercial use. Upstream project: github.com/mnfst/manifest.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

The full install guide and integration prompts unlock after purchase.