Compare commits
4 Commits
fix/idempo
...
0fe2cb79a7
| Author | SHA1 | Date | |
|---|---|---|---|
| 0fe2cb79a7 | |||
| caf058db0d | |||
| aa93c0c614 | |||
| 180604661e |
154
.env.example
154
.env.example
@@ -1,154 +1,20 @@
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# Mosaic — Environment Variables Reference
|
||||
# Copy this file to .env and fill in the values for your deployment.
|
||||
# Lines beginning with # are comments; optional vars are commented out.
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
|
||||
# ─── Database (PostgreSQL 17 + pgvector) ─────────────────────────────────────
|
||||
# Full connection string used by the gateway, ORM, and migration runner.
|
||||
# Port 5433 avoids conflict with a host-side PostgreSQL instance.
|
||||
# Database (port 5433 avoids conflict with host PostgreSQL)
|
||||
DATABASE_URL=postgresql://mosaic:mosaic@localhost:5433/mosaic
|
||||
|
||||
# Docker Compose host-port override for the PostgreSQL container (default: 5433)
|
||||
# PG_HOST_PORT=5433
|
||||
|
||||
|
||||
# ─── Queue (Valkey 8 / Redis-compatible) ─────────────────────────────────────
|
||||
# Port 6380 avoids conflict with a host-side Redis/Valkey instance.
|
||||
# Valkey (Redis-compatible, port 6380 avoids conflict with host Redis/Valkey)
|
||||
VALKEY_URL=redis://localhost:6380
|
||||
|
||||
# Docker Compose host-port override for the Valkey container (default: 6380)
|
||||
# Docker Compose host port overrides (optional)
|
||||
# PG_HOST_PORT=5433
|
||||
# VALKEY_HOST_PORT=6380
|
||||
|
||||
|
||||
# ─── Gateway ─────────────────────────────────────────────────────────────────
|
||||
# TCP port the NestJS/Fastify gateway listens on (default: 4000)
|
||||
GATEWAY_PORT=4000
|
||||
|
||||
# Comma-separated list of allowed CORS origins.
|
||||
# Must include the web app origin in production.
|
||||
GATEWAY_CORS_ORIGIN=http://localhost:3000
|
||||
|
||||
|
||||
# ─── Auth (BetterAuth) ───────────────────────────────────────────────────────
|
||||
# REQUIRED — random secret used to sign sessions and tokens.
|
||||
# Generate with: openssl rand -base64 32
|
||||
BETTER_AUTH_SECRET=change-me-to-a-random-32-char-string
|
||||
|
||||
# Public base URL of the gateway (used by BetterAuth for callback URLs)
|
||||
BETTER_AUTH_URL=http://localhost:4000
|
||||
|
||||
|
||||
# ─── Web App (Next.js) ───────────────────────────────────────────────────────
|
||||
# Public gateway URL — accessible from the browser, not just the server.
|
||||
NEXT_PUBLIC_GATEWAY_URL=http://localhost:4000
|
||||
|
||||
|
||||
# ─── OpenTelemetry ───────────────────────────────────────────────────────────
|
||||
# OTLP HTTP endpoint (otel-collector or any OpenTelemetry-compatible backend)
|
||||
# OpenTelemetry
|
||||
OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
|
||||
|
||||
# Service name shown in traces
|
||||
OTEL_SERVICE_NAME=mosaic-gateway
|
||||
|
||||
# Auth (BetterAuth)
|
||||
BETTER_AUTH_SECRET=change-me-to-a-random-32-char-string
|
||||
BETTER_AUTH_URL=http://localhost:4000
|
||||
|
||||
# ─── AI Providers ────────────────────────────────────────────────────────────
|
||||
|
||||
# Ollama (local models — set OLLAMA_BASE_URL to enable)
|
||||
# OLLAMA_BASE_URL=http://localhost:11434
|
||||
# OLLAMA_HOST is a legacy alias for OLLAMA_BASE_URL
|
||||
# OLLAMA_HOST=http://localhost:11434
|
||||
# Comma-separated list of Ollama model IDs to register (default: llama3.2,codellama,mistral)
|
||||
# OLLAMA_MODELS=llama3.2,codellama,mistral
|
||||
|
||||
# Anthropic (claude-sonnet-4-6, claude-opus-4-6, claude-haiku-4-5)
|
||||
# ANTHROPIC_API_KEY=sk-ant-...
|
||||
|
||||
# OpenAI (gpt-4o, gpt-4o-mini, o3-mini)
|
||||
# OPENAI_API_KEY=sk-...
|
||||
|
||||
# Z.ai / GLM (glm-4.5, glm-4.5-air, glm-4.5-flash)
|
||||
# ZAI_API_KEY=...
|
||||
|
||||
# Custom providers — JSON array of provider configs
|
||||
# Format: [{"id":"<id>","baseUrl":"<url>","apiKey":"<key>","models":[{"id":"<model-id>","name":"<label>"}]}]
|
||||
# MOSAIC_CUSTOM_PROVIDERS=
|
||||
|
||||
|
||||
# ─── Embedding Service ───────────────────────────────────────────────────────
|
||||
# OpenAI-compatible embeddings endpoint (default: OpenAI)
|
||||
# EMBEDDING_API_URL=https://api.openai.com/v1
|
||||
# EMBEDDING_MODEL=text-embedding-3-small
|
||||
|
||||
|
||||
# ─── Log Summarization Service ───────────────────────────────────────────────
|
||||
# OpenAI-compatible chat completions endpoint for log summarization (default: OpenAI)
|
||||
# SUMMARIZATION_API_URL=https://api.openai.com/v1
|
||||
# SUMMARIZATION_MODEL=gpt-4o-mini
|
||||
|
||||
# Cron schedule for summarization job (default: every 6 hours)
|
||||
# SUMMARIZATION_CRON=0 */6 * * *
|
||||
|
||||
# Cron schedule for log tier management (default: daily at 03:00)
|
||||
# TIER_MANAGEMENT_CRON=0 3 * * *
|
||||
|
||||
|
||||
# ─── Agent ───────────────────────────────────────────────────────────────────
|
||||
# Filesystem sandbox root for agent file tools (default: process.cwd())
|
||||
# AGENT_FILE_SANDBOX_DIR=/var/lib/mosaic/sandbox
|
||||
|
||||
# Comma-separated list of tool names available to non-admin users.
|
||||
# Leave unset to allow all tools for all authenticated users.
|
||||
# AGENT_USER_TOOLS=read_file,list_directory,search_files
|
||||
|
||||
# System prompt injected into every agent session (optional)
|
||||
# AGENT_SYSTEM_PROMPT=You are a helpful assistant.
|
||||
|
||||
|
||||
# ─── MCP Servers ─────────────────────────────────────────────────────────────
|
||||
# JSON array of MCP server configs — set to enable MCP tool integration.
|
||||
# Each entry: {"name":"<id>","url":"<http-or-sse-url>"}
|
||||
# MCP_SERVERS=[{"name":"my-mcp","url":"http://localhost:3100/sse"}]
|
||||
|
||||
|
||||
# ─── Coordinator ─────────────────────────────────────────────────────────────
|
||||
# Root directory used to scope coordinator (worktree/repo) operations.
|
||||
# Defaults to the monorepo root auto-detected from process.cwd().
|
||||
# MOSAIC_WORKSPACE_ROOT=/home/user/projects/mosaic
|
||||
|
||||
|
||||
# ─── Discord Plugin (optional — set DISCORD_BOT_TOKEN to enable) ─────────────
|
||||
# DISCORD_BOT_TOKEN=
|
||||
# DISCORD_GUILD_ID=
|
||||
# DISCORD_GATEWAY_URL=http://localhost:4000
|
||||
|
||||
|
||||
# ─── Telegram Plugin (optional — set TELEGRAM_BOT_TOKEN to enable) ───────────
|
||||
# TELEGRAM_BOT_TOKEN=
|
||||
# TELEGRAM_GATEWAY_URL=http://localhost:4000
|
||||
|
||||
|
||||
# ─── SSO Providers (add credentials to enable) ───────────────────────────────
|
||||
|
||||
# --- Authentik (optional — set AUTHENTIK_CLIENT_ID to enable) ---
|
||||
# AUTHENTIK_ISSUER=https://auth.example.com/application/o/mosaic/
|
||||
# AUTHENTIK_CLIENT_ID=
|
||||
# AUTHENTIK_CLIENT_SECRET=
|
||||
|
||||
# --- WorkOS (optional — set WORKOS_CLIENT_ID to enable) ---
|
||||
# WORKOS_ISSUER=https://your-company.authkit.app
|
||||
# WORKOS_CLIENT_ID=client_...
|
||||
# WORKOS_CLIENT_SECRET=sk_live_...
|
||||
|
||||
# --- Keycloak (optional — set KEYCLOAK_CLIENT_ID to enable) ---
|
||||
# KEYCLOAK_ISSUER=https://auth.example.com/realms/master
|
||||
# Legacy alternative if you prefer to compose the issuer from separate vars:
|
||||
# KEYCLOAK_URL=https://auth.example.com
|
||||
# KEYCLOAK_REALM=master
|
||||
# KEYCLOAK_CLIENT_ID=mosaic
|
||||
# KEYCLOAK_CLIENT_SECRET=
|
||||
|
||||
# Feature flags — set to true alongside provider credentials to show SSO buttons in the UI
|
||||
# NEXT_PUBLIC_WORKOS_ENABLED=true
|
||||
# NEXT_PUBLIC_KEYCLOAK_ENABLED=true
|
||||
# Gateway
|
||||
GATEWAY_PORT=4000
|
||||
|
||||
@@ -1 +1,4 @@
|
||||
#!/bin/sh
|
||||
. "$(dirname "$0")/_/husky.sh"
|
||||
|
||||
npx lint-staged
|
||||
|
||||
@@ -1 +1,4 @@
|
||||
#!/bin/sh
|
||||
. "$(dirname "$0")/_/husky.sh"
|
||||
|
||||
pnpm typecheck && pnpm lint && pnpm format:check
|
||||
|
||||
@@ -4,4 +4,3 @@ pnpm-lock.yaml
|
||||
**/node_modules
|
||||
**/drizzle
|
||||
**/.next
|
||||
.claude/
|
||||
|
||||
@@ -1,73 +1,57 @@
|
||||
variables:
|
||||
- &node_image 'node:22-alpine'
|
||||
- &enable_pnpm 'corepack enable'
|
||||
- &install_deps |
|
||||
corepack enable
|
||||
pnpm install --frozen-lockfile
|
||||
|
||||
when:
|
||||
- event: [push, pull_request, manual]
|
||||
|
||||
# Turbo remote cache (turbo.mosaicstack.dev) is configured via Woodpecker
|
||||
# repository-level environment variables (TURBO_API, TURBO_TEAM, TURBO_TOKEN).
|
||||
# This avoids from_secret which is blocked on pull_request events.
|
||||
# If the env vars aren't set, turbo falls back to local cache only.
|
||||
|
||||
steps:
|
||||
install:
|
||||
image: *node_image
|
||||
commands:
|
||||
- corepack enable
|
||||
- pnpm install --frozen-lockfile
|
||||
- *install_deps
|
||||
|
||||
typecheck:
|
||||
image: *node_image
|
||||
commands:
|
||||
- *enable_pnpm
|
||||
- *install_deps
|
||||
- pnpm typecheck
|
||||
depends_on:
|
||||
- install
|
||||
|
||||
# lint, format, and test are independent — run in parallel after typecheck
|
||||
lint:
|
||||
image: *node_image
|
||||
commands:
|
||||
- *enable_pnpm
|
||||
- *install_deps
|
||||
- pnpm lint
|
||||
depends_on:
|
||||
- typecheck
|
||||
- install
|
||||
|
||||
format:
|
||||
image: *node_image
|
||||
commands:
|
||||
- *enable_pnpm
|
||||
- *install_deps
|
||||
- pnpm format:check
|
||||
depends_on:
|
||||
- typecheck
|
||||
- install
|
||||
|
||||
test:
|
||||
image: *node_image
|
||||
environment:
|
||||
DATABASE_URL: postgresql://mosaic:mosaic@postgres:5432/mosaic
|
||||
commands:
|
||||
- *enable_pnpm
|
||||
# Install postgresql-client for pg_isready
|
||||
- apk add --no-cache postgresql-client
|
||||
# Wait up to 30s for postgres to be ready
|
||||
- |
|
||||
for i in $(seq 1 30); do
|
||||
pg_isready -h postgres -p 5432 -U mosaic && break
|
||||
echo "Waiting for postgres ($i/30)..."
|
||||
sleep 1
|
||||
done
|
||||
# Run migrations (DATABASE_URL is set in environment above)
|
||||
- pnpm --filter @mosaic/db run db:migrate
|
||||
# Run all tests
|
||||
- *install_deps
|
||||
- pnpm test
|
||||
depends_on:
|
||||
- typecheck
|
||||
- install
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: pgvector/pgvector:pg17
|
||||
environment:
|
||||
POSTGRES_USER: mosaic
|
||||
POSTGRES_PASSWORD: mosaic
|
||||
POSTGRES_DB: mosaic
|
||||
build:
|
||||
image: *node_image
|
||||
commands:
|
||||
- *install_deps
|
||||
- pnpm build
|
||||
depends_on:
|
||||
- typecheck
|
||||
- lint
|
||||
- format
|
||||
- test
|
||||
|
||||
@@ -1,97 +0,0 @@
|
||||
# Build, publish npm packages, and push Docker images
|
||||
# Runs only on main branch push/tag
|
||||
|
||||
variables:
|
||||
- &node_image 'node:22-alpine'
|
||||
- &enable_pnpm 'corepack enable'
|
||||
|
||||
when:
|
||||
- branch: [main]
|
||||
event: [push, manual, tag]
|
||||
|
||||
steps:
|
||||
install:
|
||||
image: *node_image
|
||||
commands:
|
||||
- corepack enable
|
||||
- pnpm install --frozen-lockfile
|
||||
|
||||
build:
|
||||
image: *node_image
|
||||
commands:
|
||||
- *enable_pnpm
|
||||
- pnpm build
|
||||
depends_on:
|
||||
- install
|
||||
|
||||
publish-npm:
|
||||
image: *node_image
|
||||
environment:
|
||||
NPM_TOKEN:
|
||||
from_secret: gitea_token
|
||||
commands:
|
||||
- *enable_pnpm
|
||||
# Configure auth for Gitea npm registry
|
||||
- |
|
||||
echo "//git.mosaicstack.dev/api/packages/mosaic/npm/:_authToken=$NPM_TOKEN" > ~/.npmrc
|
||||
echo "@mosaic:registry=https://git.mosaicstack.dev/api/packages/mosaic/npm/" >> ~/.npmrc
|
||||
# Publish all non-private packages (--no-git-checks skips dirty/branch checks in CI)
|
||||
# --filter excludes private apps (gateway, web) and the root
|
||||
- >
|
||||
pnpm --filter "@mosaic/*"
|
||||
--filter "!@mosaic/gateway"
|
||||
--filter "!@mosaic/web"
|
||||
publish --no-git-checks --access public
|
||||
|| echo "[publish] Some packages may already exist at this version — continuing"
|
||||
depends_on:
|
||||
- build
|
||||
|
||||
build-gateway:
|
||||
image: gcr.io/kaniko-project/executor:debug
|
||||
environment:
|
||||
REGISTRY_USER:
|
||||
from_secret: gitea_username
|
||||
REGISTRY_PASS:
|
||||
from_secret: gitea_password
|
||||
CI_COMMIT_BRANCH: ${CI_COMMIT_BRANCH}
|
||||
CI_COMMIT_TAG: ${CI_COMMIT_TAG}
|
||||
CI_COMMIT_SHA: ${CI_COMMIT_SHA}
|
||||
commands:
|
||||
- mkdir -p /kaniko/.docker
|
||||
- echo "{\"auths\":{\"git.mosaicstack.dev\":{\"username\":\"$REGISTRY_USER\",\"password\":\"$REGISTRY_PASS\"}}}" > /kaniko/.docker/config.json
|
||||
- |
|
||||
DESTINATIONS="--destination git.mosaicstack.dev/mosaic/mosaic-stack/gateway:sha-${CI_COMMIT_SHA:0:7}"
|
||||
if [ "$CI_COMMIT_BRANCH" = "main" ]; then
|
||||
DESTINATIONS="$DESTINATIONS --destination git.mosaicstack.dev/mosaic/mosaic-stack/gateway:latest"
|
||||
fi
|
||||
if [ -n "$CI_COMMIT_TAG" ]; then
|
||||
DESTINATIONS="$DESTINATIONS --destination git.mosaicstack.dev/mosaic/mosaic-stack/gateway:$CI_COMMIT_TAG"
|
||||
fi
|
||||
/kaniko/executor --context . --dockerfile docker/gateway.Dockerfile $DESTINATIONS
|
||||
depends_on:
|
||||
- build
|
||||
|
||||
build-web:
|
||||
image: gcr.io/kaniko-project/executor:debug
|
||||
environment:
|
||||
REGISTRY_USER:
|
||||
from_secret: gitea_username
|
||||
REGISTRY_PASS:
|
||||
from_secret: gitea_password
|
||||
CI_COMMIT_BRANCH: ${CI_COMMIT_BRANCH}
|
||||
CI_COMMIT_TAG: ${CI_COMMIT_TAG}
|
||||
CI_COMMIT_SHA: ${CI_COMMIT_SHA}
|
||||
commands:
|
||||
- mkdir -p /kaniko/.docker
|
||||
- echo "{\"auths\":{\"git.mosaicstack.dev\":{\"username\":\"$REGISTRY_USER\",\"password\":\"$REGISTRY_PASS\"}}}" > /kaniko/.docker/config.json
|
||||
- |
|
||||
DESTINATIONS="--destination git.mosaicstack.dev/mosaic/mosaic-stack/web:sha-${CI_COMMIT_SHA:0:7}"
|
||||
if [ "$CI_COMMIT_BRANCH" = "main" ]; then
|
||||
DESTINATIONS="$DESTINATIONS --destination git.mosaicstack.dev/mosaic/mosaic-stack/web:latest"
|
||||
fi
|
||||
if [ -n "$CI_COMMIT_TAG" ]; then
|
||||
DESTINATIONS="$DESTINATIONS --destination git.mosaicstack.dev/mosaic/mosaic-stack/web:$CI_COMMIT_TAG"
|
||||
fi
|
||||
/kaniko/executor --context . --dockerfile docker/web.Dockerfile $DESTINATIONS
|
||||
depends_on:
|
||||
- build
|
||||
25
AGENTS.md
25
AGENTS.md
@@ -53,28 +53,3 @@ pnpm typecheck && pnpm lint && pnpm format:check # Quality gates
|
||||
- ESM everywhere (`"type": "module"`, `.js` extensions in imports)
|
||||
- NodeNext module resolution in all tsconfigs
|
||||
- Scratchpads are mandatory for non-trivial tasks
|
||||
|
||||
## docs/TASKS.md — Schema (CANONICAL)
|
||||
|
||||
The `agent` column specifies the required model for each task. **This is set at task creation by the orchestrator and must not be changed by workers.**
|
||||
|
||||
| Value | When to use | Budget |
|
||||
| -------- | ----------------------------------------------------------- | -------------------------- |
|
||||
| `codex` | All coding tasks (default for implementation) | OpenAI credits — preferred |
|
||||
| `glm-5` | Cost-sensitive coding where Codex is unavailable | Z.ai credits |
|
||||
| `haiku` | Review gates, verify tasks, status checks, docs-only | Cheapest Claude tier |
|
||||
| `sonnet` | Complex planning, multi-file reasoning, architecture review | Claude quota |
|
||||
| `opus` | Major cross-cutting architecture decisions ONLY | Most expensive — minimize |
|
||||
| `—` | No preference / auto-select cheapest capable | Pipeline decides |
|
||||
|
||||
Pipeline crons read this column and spawn accordingly. Workers never modify `docs/TASKS.md` — only the orchestrator writes it.
|
||||
|
||||
**Full schema:**
|
||||
|
||||
```
|
||||
| id | status | description | issue | agent | repo | branch | depends_on | estimate | notes |
|
||||
```
|
||||
|
||||
- `status`: `not-started` | `in-progress` | `done` | `failed` | `blocked` | `needs-qa`
|
||||
- `agent`: model value from table above (set before spawning)
|
||||
- `estimate`: token budget e.g. `8K`, `25K`
|
||||
|
||||
244
README.md
244
README.md
@@ -1,244 +0,0 @@
|
||||
# Mosaic Stack
|
||||
|
||||
Self-hosted, multi-user AI agent platform. One config, every runtime, same standards.
|
||||
|
||||
Mosaic gives you a unified launcher for Claude Code, Codex, OpenCode, and Pi — injecting consistent system prompts, guardrails, skills, and mission context into every session. A NestJS gateway provides the API surface, a Next.js dashboard gives you the UI, and a plugin system connects Discord, Telegram, and more.
|
||||
|
||||
## Quick Install
|
||||
|
||||
```bash
|
||||
bash <(curl -fsSL https://git.mosaicstack.dev/mosaic/mosaic-stack/raw/branch/main/tools/install.sh)
|
||||
```
|
||||
|
||||
This installs both components:
|
||||
|
||||
| Component | What | Where |
|
||||
| --------------- | ----------------------------------------------------- | -------------------- |
|
||||
| **Framework** | Bash launcher, guides, runtime configs, tools, skills | `~/.config/mosaic/` |
|
||||
| **@mosaic/cli** | TUI, gateway client, wizard, auto-updater | `~/.npm-global/bin/` |
|
||||
|
||||
After install, set up your agent identity:
|
||||
|
||||
```bash
|
||||
mosaic init # Interactive wizard
|
||||
```
|
||||
|
||||
### Requirements
|
||||
|
||||
- Node.js ≥ 20
|
||||
- npm (for global @mosaic/cli install)
|
||||
- One or more runtimes: [Claude Code](https://docs.anthropic.com/en/docs/claude-code), [Codex](https://github.com/openai/codex), [OpenCode](https://opencode.ai), or [Pi](https://github.com/mariozechner/pi-coding-agent)
|
||||
|
||||
## Usage
|
||||
|
||||
### Launching Agent Sessions
|
||||
|
||||
```bash
|
||||
mosaic pi # Launch Pi with Mosaic injection
|
||||
mosaic claude # Launch Claude Code with Mosaic injection
|
||||
mosaic codex # Launch Codex with Mosaic injection
|
||||
mosaic opencode # Launch OpenCode with Mosaic injection
|
||||
|
||||
mosaic yolo claude # Claude with dangerous-permissions mode
|
||||
mosaic yolo pi # Pi in yolo mode
|
||||
```
|
||||
|
||||
The launcher verifies your config, checks for `SOUL.md`, injects your `AGENTS.md` standards into the runtime, and forwards all arguments.
|
||||
|
||||
### TUI & Gateway
|
||||
|
||||
```bash
|
||||
mosaic tui # Interactive TUI connected to the gateway
|
||||
mosaic login # Authenticate with a gateway instance
|
||||
mosaic sessions list # List active agent sessions
|
||||
```
|
||||
|
||||
### Management
|
||||
|
||||
```bash
|
||||
mosaic doctor # Health audit — detect drift and missing files
|
||||
mosaic sync # Sync skills from canonical source
|
||||
mosaic update # Check for and install CLI updates
|
||||
mosaic wizard # Full guided setup wizard
|
||||
mosaic bootstrap <path> # Bootstrap a repo with Mosaic standards
|
||||
mosaic coord init # Initialize a new orchestration mission
|
||||
mosaic prdy init # Create a PRD via guided session
|
||||
```
|
||||
|
||||
## Development
|
||||
|
||||
### Prerequisites
|
||||
|
||||
- Node.js ≥ 20
|
||||
- pnpm 10.6+
|
||||
- Docker & Docker Compose
|
||||
|
||||
### Setup
|
||||
|
||||
```bash
|
||||
git clone git@git.mosaicstack.dev:mosaic/mosaic-stack.git
|
||||
cd mosaic-stack
|
||||
|
||||
# Start infrastructure (Postgres, Valkey, Jaeger)
|
||||
docker compose up -d
|
||||
|
||||
# Install dependencies
|
||||
pnpm install
|
||||
|
||||
# Run migrations
|
||||
pnpm --filter @mosaic/db run db:migrate
|
||||
|
||||
# Start all services in dev mode
|
||||
pnpm dev
|
||||
```
|
||||
|
||||
### Infrastructure
|
||||
|
||||
Docker Compose provides:
|
||||
|
||||
| Service | Port | Purpose |
|
||||
| --------------------- | --------- | ---------------------- |
|
||||
| PostgreSQL (pgvector) | 5433 | Primary database |
|
||||
| Valkey | 6380 | Task queue + caching |
|
||||
| Jaeger | 16686 | Distributed tracing UI |
|
||||
| OTEL Collector | 4317/4318 | Telemetry ingestion |
|
||||
|
||||
### Quality Gates
|
||||
|
||||
```bash
|
||||
pnpm typecheck # TypeScript type checking (all packages)
|
||||
pnpm lint # ESLint (all packages)
|
||||
pnpm test # Vitest (all packages)
|
||||
pnpm format:check # Prettier check
|
||||
pnpm format # Prettier auto-fix
|
||||
```
|
||||
|
||||
### CI
|
||||
|
||||
Woodpecker CI runs on every push:
|
||||
|
||||
- `pnpm install --frozen-lockfile`
|
||||
- Database migration against a fresh Postgres
|
||||
- `pnpm test` (Turbo-orchestrated across all packages)
|
||||
|
||||
npm packages are published to the Gitea package registry on main merges.
|
||||
|
||||
## Architecture
|
||||
|
||||
```
|
||||
mosaic-stack/
|
||||
├── apps/
|
||||
│ ├── gateway/ NestJS API + WebSocket hub (Fastify, Socket.IO, OTEL)
|
||||
│ └── web/ Next.js dashboard (React 19, Tailwind)
|
||||
├── packages/
|
||||
│ ├── cli/ Mosaic CLI — TUI, gateway client, wizard
|
||||
│ ├── mosaic/ Framework — wizard, runtime detection, update checker
|
||||
│ ├── types/ Shared TypeScript contracts (Socket.IO typed events)
|
||||
│ ├── db/ Drizzle ORM schema + migrations (pgvector)
|
||||
│ ├── auth/ BetterAuth configuration
|
||||
│ ├── brain/ Data layer (PG-backed)
|
||||
│ ├── queue/ Valkey task queue + MCP
|
||||
│ ├── coord/ Mission coordination
|
||||
│ ├── forge/ Multi-stage AI pipeline (intake → board → plan → code → review)
|
||||
│ ├── macp/ MACP protocol — credential resolution, gate runner, events
|
||||
│ ├── agent/ Agent session management
|
||||
│ ├── memory/ Agent memory layer
|
||||
│ ├── log/ Structured logging
|
||||
│ ├── prdy/ PRD creation and validation
|
||||
│ ├── quality-rails/ Quality templates (TypeScript, Next.js, monorepo)
|
||||
│ └── design-tokens/ Shared design tokens
|
||||
├── plugins/
|
||||
│ ├── discord/ Discord channel plugin (discord.js)
|
||||
│ ├── telegram/ Telegram channel plugin (Telegraf)
|
||||
│ ├── macp/ OpenClaw MACP runtime plugin
|
||||
│ └── mosaic-framework/ OpenClaw framework injection plugin
|
||||
├── tools/
|
||||
│ └── install.sh Unified installer (framework + npm CLI)
|
||||
├── scripts/agent/ Agent session lifecycle scripts
|
||||
├── docker-compose.yml Dev infrastructure
|
||||
└── .woodpecker/ CI pipeline configs
|
||||
```
|
||||
|
||||
### Key Design Decisions
|
||||
|
||||
- **Gateway is the single API surface** — all clients (TUI, web, Discord, Telegram) connect through it
|
||||
- **ESM everywhere** — `"type": "module"`, `.js` extensions in imports, NodeNext resolution
|
||||
- **Socket.IO typed events** — defined in `@mosaic/types`, enforced at compile time
|
||||
- **OTEL auto-instrumentation** — loads before NestJS bootstrap
|
||||
- **Explicit `@Inject()` decorators** — required since tsx/esbuild doesn't emit decorator metadata
|
||||
|
||||
### Framework (`~/.config/mosaic/`)
|
||||
|
||||
The framework is the bash-based standards layer installed to every developer machine:
|
||||
|
||||
```
|
||||
~/.config/mosaic/
|
||||
├── AGENTS.md ← Central standards (loaded into every runtime)
|
||||
├── SOUL.md ← Agent identity (name, style, guardrails)
|
||||
├── USER.md ← User profile (name, timezone, preferences)
|
||||
├── TOOLS.md ← Machine-level tool reference
|
||||
├── bin/mosaic ← Unified launcher (claude, codex, opencode, pi, yolo)
|
||||
├── guides/ ← E2E delivery, orchestrator protocol, PRD, etc.
|
||||
├── runtime/ ← Per-runtime configs (claude/, codex/, opencode/, pi/)
|
||||
├── skills/ ← Universal skills (synced from agent-skills repo)
|
||||
├── tools/ ← Tool suites (orchestrator, git, quality, prdy, etc.)
|
||||
└── memory/ ← Persistent agent memory (preserved across upgrades)
|
||||
```
|
||||
|
||||
### Forge Pipeline
|
||||
|
||||
Forge is a multi-stage AI pipeline for autonomous feature delivery:
|
||||
|
||||
```
|
||||
Intake → Discovery → Board Review → Planning (3 stages) → Coding → Review → Remediation → Test → Deploy
|
||||
```
|
||||
|
||||
Each stage has a dispatch mode (`exec` for research/review, `yolo` for coding), quality gates, and timeouts. The board review uses multiple AI personas (CEO, CTO, CFO, COO + specialists) to evaluate briefs before committing resources.
|
||||
|
||||
## Upgrading
|
||||
|
||||
Run the installer again — it handles upgrades automatically:
|
||||
|
||||
```bash
|
||||
bash <(curl -fsSL https://git.mosaicstack.dev/mosaic/mosaic-stack/raw/branch/main/tools/install.sh)
|
||||
```
|
||||
|
||||
Or use the CLI:
|
||||
|
||||
```bash
|
||||
mosaic update # Check + install CLI updates
|
||||
mosaic update --check # Check only, don't install
|
||||
```
|
||||
|
||||
The CLI also performs a background update check on every invocation (cached for 1 hour).
|
||||
|
||||
### Installer Flags
|
||||
|
||||
```bash
|
||||
bash tools/install.sh --check # Version check only
|
||||
bash tools/install.sh --framework # Framework only (skip npm CLI)
|
||||
bash tools/install.sh --cli # npm CLI only (skip framework)
|
||||
bash tools/install.sh --ref v1.0 # Install from a specific git ref
|
||||
```
|
||||
|
||||
## Contributing
|
||||
|
||||
```bash
|
||||
# Create a feature branch
|
||||
git checkout -b feat/my-feature
|
||||
|
||||
# Make changes, then verify
|
||||
pnpm typecheck && pnpm lint && pnpm test && pnpm format:check
|
||||
|
||||
# Commit (husky runs lint-staged automatically)
|
||||
git commit -m "feat: description of change"
|
||||
|
||||
# Push and create PR
|
||||
git push -u origin feat/my-feature
|
||||
```
|
||||
|
||||
DTOs go in `*.dto.ts` files at module boundaries. Scratchpads (`docs/scratchpads/`) are mandatory for non-trivial tasks. See `AGENTS.md` for the full standards reference.
|
||||
|
||||
## License
|
||||
|
||||
Proprietary — all rights reserved.
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@mosaic/gateway",
|
||||
"version": "0.0.2",
|
||||
"version": "0.0.0",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"main": "dist/main.js",
|
||||
@@ -12,20 +12,15 @@
|
||||
"test": "vitest run --passWithNoTests"
|
||||
},
|
||||
"dependencies": {
|
||||
"@anthropic-ai/sdk": "^0.80.0",
|
||||
"@fastify/helmet": "^13.0.2",
|
||||
"@mariozechner/pi-ai": "~0.57.1",
|
||||
"@mariozechner/pi-coding-agent": "~0.57.1",
|
||||
"@modelcontextprotocol/sdk": "^1.27.1",
|
||||
"@mosaic/auth": "workspace:^",
|
||||
"@mosaic/brain": "workspace:^",
|
||||
"@mosaic/coord": "workspace:^",
|
||||
"@mosaic/db": "workspace:^",
|
||||
"@mosaic/discord-plugin": "workspace:^",
|
||||
"@mosaic/log": "workspace:^",
|
||||
"@mosaic/memory": "workspace:^",
|
||||
"@mosaic/queue": "workspace:^",
|
||||
"@mosaic/telegram-plugin": "workspace:^",
|
||||
"@mosaic/types": "workspace:^",
|
||||
"@nestjs/common": "^11.0.0",
|
||||
"@nestjs/core": "^11.0.0",
|
||||
@@ -42,18 +37,14 @@
|
||||
"@opentelemetry/semantic-conventions": "^1.40.0",
|
||||
"@sinclair/typebox": "^0.34.48",
|
||||
"better-auth": "^1.5.5",
|
||||
"bullmq": "^5.71.0",
|
||||
"class-transformer": "^0.5.1",
|
||||
"class-validator": "^0.15.1",
|
||||
"dotenv": "^17.3.1",
|
||||
"fastify": "^5.0.0",
|
||||
"node-cron": "^4.2.1",
|
||||
"openai": "^6.32.0",
|
||||
"reflect-metadata": "^0.2.0",
|
||||
"rxjs": "^7.8.0",
|
||||
"socket.io": "^4.8.0",
|
||||
"uuid": "^11.0.0",
|
||||
"zod": "^4.3.6"
|
||||
"uuid": "^11.0.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "^22.0.0",
|
||||
|
||||
@@ -1,605 +0,0 @@
|
||||
/**
|
||||
* Integration tests for conversation persistence and context resume (M1-008).
|
||||
*
|
||||
* Verifies the full flow end-to-end using in-memory mocks:
|
||||
* 1. User messages are persisted when sent via ChatGateway.
|
||||
* 2. Assistant responses are persisted with metadata on agent:end.
|
||||
* 3. Conversation history is loaded and injected into context on session resume.
|
||||
* 4. The search endpoint returns matching messages.
|
||||
*/
|
||||
|
||||
import { BadRequestException, NotFoundException } from '@nestjs/common';
|
||||
import { describe, expect, it, vi, beforeEach } from 'vitest';
|
||||
import type { ConversationHistoryMessage } from '../agent/agent.service.js';
|
||||
import { ConversationsController } from '../conversations/conversations.controller.js';
|
||||
import type { Message } from '@mosaic/brain';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Shared test data
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const USER_ID = 'user-test-001';
|
||||
const CONV_ID = 'conv-test-001';
|
||||
|
||||
function makeConversation(overrides?: Record<string, unknown>) {
|
||||
return {
|
||||
id: CONV_ID,
|
||||
userId: USER_ID,
|
||||
title: null,
|
||||
projectId: null,
|
||||
archived: false,
|
||||
createdAt: new Date('2026-01-01T00:00:00Z'),
|
||||
updatedAt: new Date('2026-01-01T00:00:00Z'),
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function makeMessage(
|
||||
role: 'user' | 'assistant' | 'system',
|
||||
content: string,
|
||||
overrides?: Record<string, unknown>,
|
||||
) {
|
||||
return {
|
||||
id: `msg-${role}-${Math.random().toString(36).slice(2)}`,
|
||||
conversationId: CONV_ID,
|
||||
role,
|
||||
content,
|
||||
metadata: null,
|
||||
createdAt: new Date('2026-01-01T00:01:00Z'),
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helper: build a mock ConversationsRepo
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function createMockBrain(options?: {
|
||||
conversation?: ReturnType<typeof makeConversation> | undefined;
|
||||
messages?: ReturnType<typeof makeMessage>[];
|
||||
searchResults?: Array<{
|
||||
messageId: string;
|
||||
conversationId: string;
|
||||
conversationTitle: string | null;
|
||||
role: 'user' | 'assistant' | 'system';
|
||||
content: string;
|
||||
createdAt: Date;
|
||||
}>;
|
||||
}) {
|
||||
const conversation = options?.conversation;
|
||||
const messages = options?.messages ?? [];
|
||||
const searchResults = options?.searchResults ?? [];
|
||||
|
||||
return {
|
||||
conversations: {
|
||||
findAll: vi.fn().mockResolvedValue(conversation ? [conversation] : []),
|
||||
findById: vi.fn().mockResolvedValue(conversation),
|
||||
create: vi.fn().mockResolvedValue(conversation ?? makeConversation()),
|
||||
update: vi.fn().mockResolvedValue(conversation),
|
||||
remove: vi.fn().mockResolvedValue(true),
|
||||
findMessages: vi.fn().mockResolvedValue(messages),
|
||||
addMessage: vi.fn().mockImplementation((data: unknown) => {
|
||||
const d = data as {
|
||||
conversationId: string;
|
||||
role: 'user' | 'assistant' | 'system';
|
||||
content: string;
|
||||
metadata?: Record<string, unknown>;
|
||||
};
|
||||
return Promise.resolve(makeMessage(d.role, d.content, { metadata: d.metadata ?? null }));
|
||||
}),
|
||||
searchMessages: vi.fn().mockResolvedValue(searchResults),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 1. ConversationsRepo: addMessage persists user message
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('ConversationsRepo.addMessage — user message persistence', () => {
|
||||
it('persists a user message and returns the saved record', async () => {
|
||||
const brain = createMockBrain({ conversation: makeConversation() });
|
||||
|
||||
const result = await brain.conversations.addMessage(
|
||||
{
|
||||
conversationId: CONV_ID,
|
||||
role: 'user',
|
||||
content: 'Hello, agent!',
|
||||
metadata: { timestamp: '2026-01-01T00:01:00.000Z' },
|
||||
},
|
||||
USER_ID,
|
||||
);
|
||||
|
||||
expect(brain.conversations.addMessage).toHaveBeenCalledOnce();
|
||||
expect(result).toBeDefined();
|
||||
expect(result!.role).toBe('user');
|
||||
expect(result!.content).toBe('Hello, agent!');
|
||||
expect(result!.conversationId).toBe(CONV_ID);
|
||||
});
|
||||
|
||||
it('returns undefined when conversation does not belong to the user', async () => {
|
||||
// Simulate the repo enforcement: ownership mismatch returns undefined
|
||||
const brain = createMockBrain({ conversation: undefined });
|
||||
brain.conversations.addMessage = vi.fn().mockResolvedValue(undefined);
|
||||
|
||||
const result = await brain.conversations.addMessage(
|
||||
{ conversationId: CONV_ID, role: 'user', content: 'Hello' },
|
||||
'other-user',
|
||||
);
|
||||
|
||||
expect(result).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 2. ConversationsRepo.addMessage — assistant response with metadata
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('ConversationsRepo.addMessage — assistant response metadata', () => {
|
||||
it('persists assistant message with model, provider, tokens and toolCalls metadata', async () => {
|
||||
const assistantMetadata = {
|
||||
timestamp: '2026-01-01T00:02:00.000Z',
|
||||
model: 'claude-3-5-sonnet-20241022',
|
||||
provider: 'anthropic',
|
||||
toolCalls: [
|
||||
{
|
||||
toolCallId: 'tc-001',
|
||||
toolName: 'read_file',
|
||||
args: { path: '/foo/bar.ts' },
|
||||
isError: false,
|
||||
},
|
||||
],
|
||||
tokenUsage: {
|
||||
input: 1000,
|
||||
output: 250,
|
||||
cacheRead: 0,
|
||||
cacheWrite: 0,
|
||||
total: 1250,
|
||||
},
|
||||
};
|
||||
|
||||
const brain = createMockBrain({ conversation: makeConversation() });
|
||||
|
||||
const result = await brain.conversations.addMessage(
|
||||
{
|
||||
conversationId: CONV_ID,
|
||||
role: 'assistant',
|
||||
content: 'Here is the file content you requested.',
|
||||
metadata: assistantMetadata,
|
||||
},
|
||||
USER_ID,
|
||||
);
|
||||
|
||||
expect(result).toBeDefined();
|
||||
expect(result!.role).toBe('assistant');
|
||||
expect(result!.content).toBe('Here is the file content you requested.');
|
||||
expect(result!.metadata).toMatchObject({
|
||||
model: 'claude-3-5-sonnet-20241022',
|
||||
provider: 'anthropic',
|
||||
tokenUsage: { input: 1000, output: 250, total: 1250 },
|
||||
});
|
||||
expect((result!.metadata as Record<string, unknown>)['toolCalls']).toHaveLength(1);
|
||||
expect(
|
||||
(
|
||||
(result!.metadata as Record<string, unknown>)['toolCalls'] as Array<Record<string, unknown>>
|
||||
)[0]!['toolName'],
|
||||
).toBe('read_file');
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 3. ChatGateway.loadConversationHistory — session resume loads history
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('Conversation resume — history loading', () => {
|
||||
it('maps DB messages to ConversationHistoryMessage shape', () => {
|
||||
// Simulate what ChatGateway.loadConversationHistory does:
|
||||
// convert DB Message rows to ConversationHistoryMessage for context injection.
|
||||
const dbMessages = [
|
||||
makeMessage('user', 'What is the capital of France?', {
|
||||
createdAt: new Date('2026-01-01T00:01:00Z'),
|
||||
}),
|
||||
makeMessage('assistant', 'The capital of France is Paris.', {
|
||||
createdAt: new Date('2026-01-01T00:01:05Z'),
|
||||
}),
|
||||
makeMessage('user', 'And Germany?', { createdAt: new Date('2026-01-01T00:02:00Z') }),
|
||||
makeMessage('assistant', 'The capital of Germany is Berlin.', {
|
||||
createdAt: new Date('2026-01-01T00:02:05Z'),
|
||||
}),
|
||||
];
|
||||
|
||||
// Replicate the mapping logic from ChatGateway
|
||||
const history: ConversationHistoryMessage[] = dbMessages.map((msg) => ({
|
||||
role: msg.role as 'user' | 'assistant' | 'system',
|
||||
content: msg.content,
|
||||
createdAt: msg.createdAt,
|
||||
}));
|
||||
|
||||
expect(history).toHaveLength(4);
|
||||
expect(history[0]).toEqual({
|
||||
role: 'user',
|
||||
content: 'What is the capital of France?',
|
||||
createdAt: new Date('2026-01-01T00:01:00Z'),
|
||||
});
|
||||
expect(history[1]).toEqual({
|
||||
role: 'assistant',
|
||||
content: 'The capital of France is Paris.',
|
||||
createdAt: new Date('2026-01-01T00:01:05Z'),
|
||||
});
|
||||
expect(history[2]!.role).toBe('user');
|
||||
expect(history[3]!.role).toBe('assistant');
|
||||
});
|
||||
|
||||
it('returns empty array when conversation has no messages', async () => {
|
||||
const brain = createMockBrain({ conversation: makeConversation(), messages: [] });
|
||||
|
||||
const messages = await brain.conversations.findMessages(CONV_ID, USER_ID);
|
||||
expect(messages).toHaveLength(0);
|
||||
|
||||
// Gateway produces empty history → no context injection
|
||||
const history: ConversationHistoryMessage[] = (messages as Message[]).map((msg) => ({
|
||||
role: msg.role as 'user' | 'assistant' | 'system',
|
||||
content: msg.content,
|
||||
createdAt: msg.createdAt,
|
||||
}));
|
||||
expect(history).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('returns empty array when conversation does not belong to the user', async () => {
|
||||
const brain = createMockBrain({ conversation: undefined });
|
||||
brain.conversations.findMessages = vi.fn().mockResolvedValue([]);
|
||||
|
||||
const messages = await brain.conversations.findMessages(CONV_ID, 'other-user');
|
||||
expect(messages).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('preserves message order (ascending by createdAt)', async () => {
|
||||
const ordered = [
|
||||
makeMessage('user', 'First', { createdAt: new Date('2026-01-01T00:01:00Z') }),
|
||||
makeMessage('assistant', 'Second', { createdAt: new Date('2026-01-01T00:01:05Z') }),
|
||||
makeMessage('user', 'Third', { createdAt: new Date('2026-01-01T00:02:00Z') }),
|
||||
];
|
||||
const brain = createMockBrain({ conversation: makeConversation(), messages: ordered });
|
||||
|
||||
const messages = await brain.conversations.findMessages(CONV_ID, USER_ID);
|
||||
expect(messages[0]!.content).toBe('First');
|
||||
expect(messages[1]!.content).toBe('Second');
|
||||
expect(messages[2]!.content).toBe('Third');
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 4. AgentService.buildHistoryPromptSection — context injection format
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('AgentService — buildHistoryPromptSection (context injection)', () => {
|
||||
/**
|
||||
* Replicate the private method logic to test it in isolation.
|
||||
* The real method lives in AgentService but is private; we mirror the
|
||||
* exact logic here so the test is independent of the service's constructor.
|
||||
*/
|
||||
function buildHistoryPromptSection(
|
||||
history: ConversationHistoryMessage[],
|
||||
contextWindow: number,
|
||||
_sessionId: string,
|
||||
): string {
|
||||
const TOKEN_BUDGET = Math.floor(contextWindow * 0.8);
|
||||
const HISTORY_HEADER = '## Conversation History (resumed session)\n\n';
|
||||
|
||||
const formatMessage = (msg: ConversationHistoryMessage): string => {
|
||||
const roleLabel =
|
||||
msg.role === 'user' ? 'User' : msg.role === 'assistant' ? 'Assistant' : 'System';
|
||||
return `**${roleLabel}:** ${msg.content}`;
|
||||
};
|
||||
|
||||
const estimateTokens = (text: string) => Math.ceil(text.length / 4);
|
||||
|
||||
const formatted = history.map((msg) => formatMessage(msg));
|
||||
const fullHistory = formatted.join('\n\n');
|
||||
const fullTokens = estimateTokens(HISTORY_HEADER + fullHistory);
|
||||
|
||||
if (fullTokens <= TOKEN_BUDGET) {
|
||||
return HISTORY_HEADER + fullHistory;
|
||||
}
|
||||
|
||||
// History exceeds budget — summarize oldest messages, keep recent verbatim
|
||||
const SUMMARY_RESERVE = Math.floor(TOKEN_BUDGET * 0.2);
|
||||
const verbatimBudget = TOKEN_BUDGET - SUMMARY_RESERVE;
|
||||
|
||||
let verbatimTokens = 0;
|
||||
let verbatimCutIndex = history.length;
|
||||
for (let i = history.length - 1; i >= 0; i--) {
|
||||
const t = estimateTokens(formatted[i]!);
|
||||
if (verbatimTokens + t > verbatimBudget) break;
|
||||
verbatimTokens += t;
|
||||
verbatimCutIndex = i;
|
||||
}
|
||||
|
||||
const summarizedMessages = history.slice(0, verbatimCutIndex);
|
||||
const verbatimMessages = history.slice(verbatimCutIndex);
|
||||
|
||||
let summaryText = '';
|
||||
if (summarizedMessages.length > 0) {
|
||||
const topics = summarizedMessages
|
||||
.filter((m) => m.role === 'user')
|
||||
.map((m) => m.content.slice(0, 120).replace(/\n/g, ' '))
|
||||
.join('; ');
|
||||
summaryText =
|
||||
`**Previous conversation summary** (${summarizedMessages.length} messages omitted for brevity):\n` +
|
||||
`Topics discussed: ${topics || '(no user messages in summarized portion)'}`;
|
||||
}
|
||||
|
||||
const verbatimSection = verbatimMessages.map((m) => formatMessage(m)).join('\n\n');
|
||||
|
||||
const parts: string[] = [HISTORY_HEADER];
|
||||
if (summaryText) parts.push(summaryText);
|
||||
if (verbatimSection) parts.push(verbatimSection);
|
||||
|
||||
return parts.join('\n\n');
|
||||
}
|
||||
|
||||
it('includes header and all messages when history fits within context budget', () => {
|
||||
const history: ConversationHistoryMessage[] = [
|
||||
{ role: 'user', content: 'Hello', createdAt: new Date() },
|
||||
{ role: 'assistant', content: 'Hi there!', createdAt: new Date() },
|
||||
];
|
||||
|
||||
const result = buildHistoryPromptSection(history, 8192, 'session-1');
|
||||
|
||||
expect(result).toContain('## Conversation History (resumed session)');
|
||||
expect(result).toContain('**User:** Hello');
|
||||
expect(result).toContain('**Assistant:** Hi there!');
|
||||
});
|
||||
|
||||
it('labels roles correctly (user, assistant, system)', () => {
|
||||
const history: ConversationHistoryMessage[] = [
|
||||
{ role: 'system', content: 'You are helpful.', createdAt: new Date() },
|
||||
{ role: 'user', content: 'Ping', createdAt: new Date() },
|
||||
{ role: 'assistant', content: 'Pong', createdAt: new Date() },
|
||||
];
|
||||
|
||||
const result = buildHistoryPromptSection(history, 8192, 'session-2');
|
||||
|
||||
expect(result).toContain('**System:** You are helpful.');
|
||||
expect(result).toContain('**User:** Ping');
|
||||
expect(result).toContain('**Assistant:** Pong');
|
||||
});
|
||||
|
||||
it('summarizes old messages when history exceeds 80% of context window', () => {
|
||||
// Create enough messages to exceed a tiny context window budget
|
||||
const longContent = 'A'.repeat(200);
|
||||
const history: ConversationHistoryMessage[] = Array.from({ length: 20 }, (_, i) => ({
|
||||
role: (i % 2 === 0 ? 'user' : 'assistant') as 'user' | 'assistant',
|
||||
content: `${longContent} message ${i}`,
|
||||
createdAt: new Date(),
|
||||
}));
|
||||
|
||||
// Use a small context window so history definitely exceeds 80%
|
||||
const result = buildHistoryPromptSection(history, 512, 'session-3');
|
||||
|
||||
// Should contain the summary prefix
|
||||
expect(result).toContain('messages omitted for brevity');
|
||||
expect(result).toContain('Topics discussed:');
|
||||
});
|
||||
|
||||
it('returns only header for empty history', () => {
|
||||
const result = buildHistoryPromptSection([], 8192, 'session-4');
|
||||
// With empty history, the full history join is '' and the section is just the header
|
||||
expect(result).toContain('## Conversation History (resumed session)');
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 5. ConversationsController.search — GET /api/conversations/search
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('ConversationsController — search endpoint', () => {
|
||||
let brain: ReturnType<typeof createMockBrain>;
|
||||
let controller: ConversationsController;
|
||||
|
||||
beforeEach(() => {
|
||||
const searchResults = [
|
||||
{
|
||||
messageId: 'msg-001',
|
||||
conversationId: CONV_ID,
|
||||
conversationTitle: 'Test Chat',
|
||||
role: 'user' as const,
|
||||
content: 'What is the capital of France?',
|
||||
createdAt: new Date('2026-01-01T00:01:00Z'),
|
||||
},
|
||||
{
|
||||
messageId: 'msg-002',
|
||||
conversationId: CONV_ID,
|
||||
conversationTitle: 'Test Chat',
|
||||
role: 'assistant' as const,
|
||||
content: 'The capital of France is Paris.',
|
||||
createdAt: new Date('2026-01-01T00:01:05Z'),
|
||||
},
|
||||
];
|
||||
brain = createMockBrain({ searchResults });
|
||||
controller = new ConversationsController(brain as never);
|
||||
});
|
||||
|
||||
it('returns matching messages for a valid search query', async () => {
|
||||
const results = await controller.search({ q: 'France' }, { id: USER_ID });
|
||||
|
||||
expect(brain.conversations.searchMessages).toHaveBeenCalledWith(USER_ID, 'France', 20, 0);
|
||||
expect(results).toHaveLength(2);
|
||||
expect(results[0]).toMatchObject({
|
||||
messageId: 'msg-001',
|
||||
role: 'user',
|
||||
content: 'What is the capital of France?',
|
||||
});
|
||||
expect(results[1]).toMatchObject({
|
||||
messageId: 'msg-002',
|
||||
role: 'assistant',
|
||||
content: 'The capital of France is Paris.',
|
||||
});
|
||||
});
|
||||
|
||||
it('uses custom limit and offset when provided', async () => {
|
||||
await controller.search({ q: 'Paris', limit: 5, offset: 10 }, { id: USER_ID });
|
||||
|
||||
expect(brain.conversations.searchMessages).toHaveBeenCalledWith(USER_ID, 'Paris', 5, 10);
|
||||
});
|
||||
|
||||
it('throws BadRequestException when query is empty', async () => {
|
||||
await expect(controller.search({ q: '' }, { id: USER_ID })).rejects.toBeInstanceOf(
|
||||
BadRequestException,
|
||||
);
|
||||
await expect(controller.search({ q: ' ' }, { id: USER_ID })).rejects.toBeInstanceOf(
|
||||
BadRequestException,
|
||||
);
|
||||
});
|
||||
|
||||
it('trims whitespace from query before passing to repo', async () => {
|
||||
await controller.search({ q: ' Berlin ' }, { id: USER_ID });
|
||||
|
||||
expect(brain.conversations.searchMessages).toHaveBeenCalledWith(
|
||||
USER_ID,
|
||||
'Berlin',
|
||||
expect.any(Number),
|
||||
expect.any(Number),
|
||||
);
|
||||
});
|
||||
|
||||
it('returns empty array when no messages match', async () => {
|
||||
brain.conversations.searchMessages = vi.fn().mockResolvedValue([]);
|
||||
|
||||
const results = await controller.search({ q: 'xyzzy-no-match' }, { id: USER_ID });
|
||||
|
||||
expect(results).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 6. ConversationsController — messages CRUD
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('ConversationsController — message CRUD', () => {
|
||||
it('listMessages returns 404 when conversation is not owned by user', async () => {
|
||||
const brain = createMockBrain({ conversation: undefined });
|
||||
const controller = new ConversationsController(brain as never);
|
||||
|
||||
await expect(controller.listMessages(CONV_ID, { id: USER_ID })).rejects.toBeInstanceOf(
|
||||
NotFoundException,
|
||||
);
|
||||
});
|
||||
|
||||
it('listMessages returns the messages for an owned conversation', async () => {
|
||||
const msgs = [makeMessage('user', 'Test message'), makeMessage('assistant', 'Test reply')];
|
||||
const brain = createMockBrain({ conversation: makeConversation(), messages: msgs });
|
||||
const controller = new ConversationsController(brain as never);
|
||||
|
||||
const result = await controller.listMessages(CONV_ID, { id: USER_ID });
|
||||
|
||||
expect(result).toHaveLength(2);
|
||||
expect(result[0]!.role).toBe('user');
|
||||
expect(result[1]!.role).toBe('assistant');
|
||||
});
|
||||
|
||||
it('addMessage returns the persisted message', async () => {
|
||||
const brain = createMockBrain({ conversation: makeConversation() });
|
||||
const controller = new ConversationsController(brain as never);
|
||||
|
||||
const result = await controller.addMessage(
|
||||
CONV_ID,
|
||||
{ role: 'user', content: 'Persisted content' },
|
||||
{ id: USER_ID },
|
||||
);
|
||||
|
||||
expect(result).toBeDefined();
|
||||
expect(result.role).toBe('user');
|
||||
expect(result.content).toBe('Persisted content');
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 7. End-to-end persistence flow simulation
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('End-to-end persistence flow', () => {
|
||||
it('simulates a full conversation: persist user message → persist assistant response → resume with history', async () => {
|
||||
// ── Step 1: Conversation is created ────────────────────────────────────
|
||||
const brain = createMockBrain({ conversation: makeConversation() });
|
||||
|
||||
await brain.conversations.create({ id: CONV_ID, userId: USER_ID });
|
||||
expect(brain.conversations.create).toHaveBeenCalledOnce();
|
||||
|
||||
// ── Step 2: User message is persisted ──────────────────────────────────
|
||||
const userMsg = await brain.conversations.addMessage(
|
||||
{
|
||||
conversationId: CONV_ID,
|
||||
role: 'user',
|
||||
content: 'Explain monads in simple terms.',
|
||||
metadata: { timestamp: '2026-01-01T00:01:00.000Z' },
|
||||
},
|
||||
USER_ID,
|
||||
);
|
||||
|
||||
expect(userMsg).toBeDefined();
|
||||
expect(userMsg!.role).toBe('user');
|
||||
|
||||
// ── Step 3: Assistant response is persisted with metadata ───────────────
|
||||
const assistantMeta = {
|
||||
timestamp: '2026-01-01T00:01:10.000Z',
|
||||
model: 'claude-3-5-sonnet-20241022',
|
||||
provider: 'anthropic',
|
||||
toolCalls: [],
|
||||
tokenUsage: { input: 500, output: 120, cacheRead: 0, cacheWrite: 0, total: 620 },
|
||||
};
|
||||
|
||||
const assistantMsg = await brain.conversations.addMessage(
|
||||
{
|
||||
conversationId: CONV_ID,
|
||||
role: 'assistant',
|
||||
content: 'A monad is a design pattern that wraps values in a context...',
|
||||
metadata: assistantMeta,
|
||||
},
|
||||
USER_ID,
|
||||
);
|
||||
|
||||
expect(assistantMsg).toBeDefined();
|
||||
expect(assistantMsg!.role).toBe('assistant');
|
||||
|
||||
// ── Step 4: On session resume, history is loaded ────────────────────────
|
||||
const storedMessages = [
|
||||
makeMessage('user', 'Explain monads in simple terms.', {
|
||||
createdAt: new Date('2026-01-01T00:01:00Z'),
|
||||
metadata: { timestamp: '2026-01-01T00:01:00.000Z' },
|
||||
}),
|
||||
makeMessage('assistant', 'A monad is a design pattern that wraps values in a context...', {
|
||||
createdAt: new Date('2026-01-01T00:01:10Z'),
|
||||
metadata: assistantMeta,
|
||||
}),
|
||||
];
|
||||
|
||||
brain.conversations.findMessages = vi.fn().mockResolvedValue(storedMessages);
|
||||
|
||||
const dbMessages = await brain.conversations.findMessages(CONV_ID, USER_ID);
|
||||
expect(dbMessages).toHaveLength(2);
|
||||
|
||||
// ── Step 5: History is mapped for context injection ─────────────────────
|
||||
const history: ConversationHistoryMessage[] = (dbMessages as Message[]).map((msg) => ({
|
||||
role: msg.role as 'user' | 'assistant' | 'system',
|
||||
content: msg.content,
|
||||
createdAt: msg.createdAt,
|
||||
}));
|
||||
|
||||
expect(history[0]).toMatchObject({
|
||||
role: 'user',
|
||||
content: 'Explain monads in simple terms.',
|
||||
});
|
||||
expect(history[1]).toMatchObject({
|
||||
role: 'assistant',
|
||||
content: 'A monad is a design pattern that wraps values in a context...',
|
||||
});
|
||||
|
||||
// ── Step 6: History roles are valid for injection ───────────────────────
|
||||
for (const msg of history) {
|
||||
expect(['user', 'assistant', 'system']).toContain(msg.role);
|
||||
expect(typeof msg.content).toBe('string');
|
||||
expect(msg.createdAt).toBeInstanceOf(Date);
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -1,485 +0,0 @@
|
||||
/**
|
||||
* Integration test: Cross-user data isolation (M2-007)
|
||||
*
|
||||
* Verifies that every repository query path is scoped to the requesting user —
|
||||
* no user can read, write, or enumerate another user's records.
|
||||
*
|
||||
* Test strategy:
|
||||
* - Two real users (User A, User B) are inserted directly into the database.
|
||||
* - Realistic data (conversations + messages, agent configs, preferences,
|
||||
* insights) is created for each user.
|
||||
* - A shared system agent is inserted so both users can see it via
|
||||
* findAccessible().
|
||||
* - All assertions are made against the live database (no mocks).
|
||||
* - All inserted rows are cleaned up in the afterAll hook.
|
||||
*
|
||||
* Requires: DATABASE_URL pointing at a running PostgreSQL instance with
|
||||
* pgvector enabled and the Mosaic schema already applied.
|
||||
*/
|
||||
|
||||
import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
|
||||
import { createDb } from '@mosaic/db';
|
||||
import { createConversationsRepo } from '@mosaic/brain';
|
||||
import { createAgentsRepo } from '@mosaic/brain';
|
||||
import { createPreferencesRepo, createInsightsRepo } from '@mosaic/memory';
|
||||
import { users, conversations, messages, agents, preferences, insights } from '@mosaic/db';
|
||||
import { eq } from '@mosaic/db';
|
||||
import type { DbHandle } from '@mosaic/db';
|
||||
|
||||
// ─── Fixed IDs so the afterAll cleanup is deterministic ──────────────────────
|
||||
|
||||
const USER_A_ID = 'test-iso-user-a';
|
||||
const USER_B_ID = 'test-iso-user-b';
|
||||
const CONV_A_ID = 'aaaaaaaa-0000-0000-0000-000000000001';
|
||||
const CONV_B_ID = 'bbbbbbbb-0000-0000-0000-000000000001';
|
||||
const MSG_A_ID = 'aaaaaaaa-0000-0000-0000-000000000002';
|
||||
const MSG_B_ID = 'bbbbbbbb-0000-0000-0000-000000000002';
|
||||
const AGENT_A_ID = 'aaaaaaaa-0000-0000-0000-000000000003';
|
||||
const AGENT_B_ID = 'bbbbbbbb-0000-0000-0000-000000000003';
|
||||
const AGENT_SYS_ID = 'ffffffff-0000-0000-0000-000000000001';
|
||||
const PREF_A_ID = 'aaaaaaaa-0000-0000-0000-000000000004';
|
||||
const PREF_B_ID = 'bbbbbbbb-0000-0000-0000-000000000004';
|
||||
const INSIGHT_A_ID = 'aaaaaaaa-0000-0000-0000-000000000005';
|
||||
const INSIGHT_B_ID = 'bbbbbbbb-0000-0000-0000-000000000005';
|
||||
|
||||
// ─── Test fixture ─────────────────────────────────────────────────────────────
|
||||
|
||||
let handle: DbHandle;
|
||||
let dbAvailable = false;
|
||||
|
||||
beforeAll(async () => {
|
||||
try {
|
||||
handle = createDb();
|
||||
const db = handle.db;
|
||||
|
||||
// Insert two users
|
||||
await db
|
||||
.insert(users)
|
||||
.values([
|
||||
{
|
||||
id: USER_A_ID,
|
||||
name: 'Isolation Test User A',
|
||||
email: 'test-iso-user-a@example.invalid',
|
||||
emailVerified: false,
|
||||
},
|
||||
{
|
||||
id: USER_B_ID,
|
||||
name: 'Isolation Test User B',
|
||||
email: 'test-iso-user-b@example.invalid',
|
||||
emailVerified: false,
|
||||
},
|
||||
])
|
||||
.onConflictDoNothing();
|
||||
|
||||
// Conversations — one per user
|
||||
await db
|
||||
.insert(conversations)
|
||||
.values([
|
||||
{ id: CONV_A_ID, userId: USER_A_ID, title: 'User A conversation' },
|
||||
{ id: CONV_B_ID, userId: USER_B_ID, title: 'User B conversation' },
|
||||
])
|
||||
.onConflictDoNothing();
|
||||
|
||||
// Messages — one per conversation
|
||||
await db
|
||||
.insert(messages)
|
||||
.values([
|
||||
{
|
||||
id: MSG_A_ID,
|
||||
conversationId: CONV_A_ID,
|
||||
role: 'user',
|
||||
content: 'Hello from User A',
|
||||
},
|
||||
{
|
||||
id: MSG_B_ID,
|
||||
conversationId: CONV_B_ID,
|
||||
role: 'user',
|
||||
content: 'Hello from User B',
|
||||
},
|
||||
])
|
||||
.onConflictDoNothing();
|
||||
|
||||
// Agent configs — private agents (one per user) + one system agent
|
||||
await db
|
||||
.insert(agents)
|
||||
.values([
|
||||
{
|
||||
id: AGENT_A_ID,
|
||||
name: 'Agent A (private)',
|
||||
provider: 'test',
|
||||
model: 'test-model',
|
||||
ownerId: USER_A_ID,
|
||||
isSystem: false,
|
||||
},
|
||||
{
|
||||
id: AGENT_B_ID,
|
||||
name: 'Agent B (private)',
|
||||
provider: 'test',
|
||||
model: 'test-model',
|
||||
ownerId: USER_B_ID,
|
||||
isSystem: false,
|
||||
},
|
||||
{
|
||||
id: AGENT_SYS_ID,
|
||||
name: 'Shared System Agent',
|
||||
provider: 'test',
|
||||
model: 'test-model',
|
||||
ownerId: null,
|
||||
isSystem: true,
|
||||
},
|
||||
])
|
||||
.onConflictDoNothing();
|
||||
|
||||
// Preferences — one per user (same key, different values)
|
||||
await db
|
||||
.insert(preferences)
|
||||
.values([
|
||||
{
|
||||
id: PREF_A_ID,
|
||||
userId: USER_A_ID,
|
||||
key: 'theme',
|
||||
value: 'dark',
|
||||
category: 'appearance',
|
||||
},
|
||||
{
|
||||
id: PREF_B_ID,
|
||||
userId: USER_B_ID,
|
||||
key: 'theme',
|
||||
value: 'light',
|
||||
category: 'appearance',
|
||||
},
|
||||
])
|
||||
.onConflictDoNothing();
|
||||
|
||||
// Insights — no embedding to keep the fixture simple; embedding-based search
|
||||
// is tested separately with a zero-vector that falls outside maxDistance
|
||||
await db
|
||||
.insert(insights)
|
||||
.values([
|
||||
{
|
||||
id: INSIGHT_A_ID,
|
||||
userId: USER_A_ID,
|
||||
content: 'User A insight',
|
||||
source: 'user',
|
||||
category: 'general',
|
||||
relevanceScore: 1.0,
|
||||
},
|
||||
{
|
||||
id: INSIGHT_B_ID,
|
||||
userId: USER_B_ID,
|
||||
content: 'User B insight',
|
||||
source: 'user',
|
||||
category: 'general',
|
||||
relevanceScore: 1.0,
|
||||
},
|
||||
])
|
||||
.onConflictDoNothing();
|
||||
|
||||
dbAvailable = true;
|
||||
} catch {
|
||||
// Database is not reachable (e.g., CI environment without Postgres on port 5433).
|
||||
// All tests in this suite will be skipped.
|
||||
}
|
||||
});
|
||||
|
||||
// Skip all tests in this file when the database is not reachable (e.g., CI without Postgres).
|
||||
beforeEach((ctx) => {
|
||||
if (!dbAvailable) {
|
||||
ctx.skip();
|
||||
}
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
if (!handle) return;
|
||||
const db = handle.db;
|
||||
|
||||
// Delete in dependency order (FK constraints)
|
||||
await db.delete(messages).where(eq(messages.id, MSG_A_ID));
|
||||
await db.delete(messages).where(eq(messages.id, MSG_B_ID));
|
||||
await db.delete(conversations).where(eq(conversations.id, CONV_A_ID));
|
||||
await db.delete(conversations).where(eq(conversations.id, CONV_B_ID));
|
||||
await db.delete(agents).where(eq(agents.id, AGENT_A_ID));
|
||||
await db.delete(agents).where(eq(agents.id, AGENT_B_ID));
|
||||
await db.delete(agents).where(eq(agents.id, AGENT_SYS_ID));
|
||||
await db.delete(preferences).where(eq(preferences.id, PREF_A_ID));
|
||||
await db.delete(preferences).where(eq(preferences.id, PREF_B_ID));
|
||||
await db.delete(insights).where(eq(insights.id, INSIGHT_A_ID));
|
||||
await db.delete(insights).where(eq(insights.id, INSIGHT_B_ID));
|
||||
await db.delete(users).where(eq(users.id, USER_A_ID));
|
||||
await db.delete(users).where(eq(users.id, USER_B_ID));
|
||||
|
||||
await handle.close();
|
||||
});
|
||||
|
||||
// ─── Conversations isolation ──────────────────────────────────────────────────
|
||||
|
||||
describe('ConversationsRepo — cross-user isolation', () => {
|
||||
it('User A can find their own conversation by id', async () => {
|
||||
const repo = createConversationsRepo(handle.db);
|
||||
const conv = await repo.findById(CONV_A_ID, USER_A_ID);
|
||||
expect(conv).toBeDefined();
|
||||
expect(conv!.id).toBe(CONV_A_ID);
|
||||
});
|
||||
|
||||
it('User B cannot find User A conversation by id (returns undefined)', async () => {
|
||||
const repo = createConversationsRepo(handle.db);
|
||||
const conv = await repo.findById(CONV_A_ID, USER_B_ID);
|
||||
expect(conv).toBeUndefined();
|
||||
});
|
||||
|
||||
it('User A cannot find User B conversation by id (returns undefined)', async () => {
|
||||
const repo = createConversationsRepo(handle.db);
|
||||
const conv = await repo.findById(CONV_B_ID, USER_A_ID);
|
||||
expect(conv).toBeUndefined();
|
||||
});
|
||||
|
||||
it('findAll returns only own conversations for User A', async () => {
|
||||
const repo = createConversationsRepo(handle.db);
|
||||
const convs = await repo.findAll(USER_A_ID);
|
||||
const ids = convs.map((c) => c.id);
|
||||
expect(ids).toContain(CONV_A_ID);
|
||||
expect(ids).not.toContain(CONV_B_ID);
|
||||
});
|
||||
|
||||
it('findAll returns only own conversations for User B', async () => {
|
||||
const repo = createConversationsRepo(handle.db);
|
||||
const convs = await repo.findAll(USER_B_ID);
|
||||
const ids = convs.map((c) => c.id);
|
||||
expect(ids).toContain(CONV_B_ID);
|
||||
expect(ids).not.toContain(CONV_A_ID);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Messages isolation ───────────────────────────────────────────────────────
|
||||
|
||||
describe('ConversationsRepo.findMessages — cross-user isolation', () => {
|
||||
it('User A can read messages from their own conversation', async () => {
|
||||
const repo = createConversationsRepo(handle.db);
|
||||
const msgs = await repo.findMessages(CONV_A_ID, USER_A_ID);
|
||||
const ids = msgs.map((m) => m.id);
|
||||
expect(ids).toContain(MSG_A_ID);
|
||||
});
|
||||
|
||||
it('User B cannot read messages from User A conversation (returns empty array)', async () => {
|
||||
const repo = createConversationsRepo(handle.db);
|
||||
const msgs = await repo.findMessages(CONV_A_ID, USER_B_ID);
|
||||
expect(msgs).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('User A cannot read messages from User B conversation (returns empty array)', async () => {
|
||||
const repo = createConversationsRepo(handle.db);
|
||||
const msgs = await repo.findMessages(CONV_B_ID, USER_A_ID);
|
||||
expect(msgs).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('addMessage is rejected when user does not own the conversation', async () => {
|
||||
const repo = createConversationsRepo(handle.db);
|
||||
const result = await repo.addMessage(
|
||||
{
|
||||
conversationId: CONV_A_ID,
|
||||
role: 'user',
|
||||
content: 'Attempted injection by User B',
|
||||
},
|
||||
USER_B_ID,
|
||||
);
|
||||
expect(result).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Agent configs isolation ──────────────────────────────────────────────────
|
||||
|
||||
describe('AgentsRepo.findAccessible — cross-user isolation', () => {
|
||||
it('User A sees their own private agent', async () => {
|
||||
const repo = createAgentsRepo(handle.db);
|
||||
const accessible = await repo.findAccessible(USER_A_ID);
|
||||
const ids = accessible.map((a) => a.id);
|
||||
expect(ids).toContain(AGENT_A_ID);
|
||||
});
|
||||
|
||||
it('User A does NOT see User B private agent', async () => {
|
||||
const repo = createAgentsRepo(handle.db);
|
||||
const accessible = await repo.findAccessible(USER_A_ID);
|
||||
const ids = accessible.map((a) => a.id);
|
||||
expect(ids).not.toContain(AGENT_B_ID);
|
||||
});
|
||||
|
||||
it('User B does NOT see User A private agent', async () => {
|
||||
const repo = createAgentsRepo(handle.db);
|
||||
const accessible = await repo.findAccessible(USER_B_ID);
|
||||
const ids = accessible.map((a) => a.id);
|
||||
expect(ids).not.toContain(AGENT_A_ID);
|
||||
});
|
||||
|
||||
it('Both users can see the shared system agent', async () => {
|
||||
const repo = createAgentsRepo(handle.db);
|
||||
const accessibleA = await repo.findAccessible(USER_A_ID);
|
||||
const accessibleB = await repo.findAccessible(USER_B_ID);
|
||||
expect(accessibleA.map((a) => a.id)).toContain(AGENT_SYS_ID);
|
||||
expect(accessibleB.map((a) => a.id)).toContain(AGENT_SYS_ID);
|
||||
});
|
||||
|
||||
it('findSystem returns the system agent for any caller', async () => {
|
||||
const repo = createAgentsRepo(handle.db);
|
||||
const system = await repo.findSystem();
|
||||
const ids = system.map((a) => a.id);
|
||||
expect(ids).toContain(AGENT_SYS_ID);
|
||||
});
|
||||
|
||||
it('update with ownerId prevents User B from modifying User A agent', async () => {
|
||||
const repo = createAgentsRepo(handle.db);
|
||||
const result = await repo.update(AGENT_A_ID, { model: 'hacked' }, USER_B_ID);
|
||||
expect(result).toBeUndefined();
|
||||
|
||||
// Verify the agent was not actually mutated
|
||||
const unchanged = await repo.findById(AGENT_A_ID);
|
||||
expect(unchanged?.model).toBe('test-model');
|
||||
});
|
||||
|
||||
it('remove prevents User B from deleting User A agent', async () => {
|
||||
const repo = createAgentsRepo(handle.db);
|
||||
const deleted = await repo.remove(AGENT_A_ID, USER_B_ID);
|
||||
expect(deleted).toBe(false);
|
||||
|
||||
// Verify the agent still exists
|
||||
const still = await repo.findById(AGENT_A_ID);
|
||||
expect(still).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Preferences isolation ────────────────────────────────────────────────────
|
||||
|
||||
describe('PreferencesRepo — cross-user isolation', () => {
|
||||
it('User A can retrieve their own preferences', async () => {
|
||||
const repo = createPreferencesRepo(handle.db);
|
||||
const prefs = await repo.findByUser(USER_A_ID);
|
||||
const ids = prefs.map((p) => p.id);
|
||||
expect(ids).toContain(PREF_A_ID);
|
||||
});
|
||||
|
||||
it('User A preferences do not contain User B preferences', async () => {
|
||||
const repo = createPreferencesRepo(handle.db);
|
||||
const prefs = await repo.findByUser(USER_A_ID);
|
||||
const ids = prefs.map((p) => p.id);
|
||||
expect(ids).not.toContain(PREF_B_ID);
|
||||
});
|
||||
|
||||
it('User B preferences do not contain User A preferences', async () => {
|
||||
const repo = createPreferencesRepo(handle.db);
|
||||
const prefs = await repo.findByUser(USER_B_ID);
|
||||
const ids = prefs.map((p) => p.id);
|
||||
expect(ids).not.toContain(PREF_A_ID);
|
||||
});
|
||||
|
||||
it('findByUserAndKey is scoped to the requesting user', async () => {
|
||||
const repo = createPreferencesRepo(handle.db);
|
||||
// Both users have key "theme" — each should only see their own value
|
||||
const prefA = await repo.findByUserAndKey(USER_A_ID, 'theme');
|
||||
const prefB = await repo.findByUserAndKey(USER_B_ID, 'theme');
|
||||
|
||||
expect(prefA).toBeDefined();
|
||||
// Drizzle returns JSONB values as parsed JS values; '"dark"' (JSON string) → 'dark'
|
||||
expect(prefA!.value).toBe('dark');
|
||||
expect(prefB).toBeDefined();
|
||||
expect(prefB!.value).toBe('light');
|
||||
});
|
||||
|
||||
it('remove is scoped to the requesting user (cannot delete another user pref)', async () => {
|
||||
const repo = createPreferencesRepo(handle.db);
|
||||
// User B tries to delete User A's "theme" preference — should silently fail
|
||||
const deleted = await repo.remove(USER_B_ID, 'theme');
|
||||
// This only deletes USER_B's own "theme" row; re-insert it for afterAll cleanup
|
||||
expect(deleted).toBe(true); // deletes User B's OWN theme pref
|
||||
|
||||
// User A's theme pref must be untouched
|
||||
const prefA = await repo.findByUserAndKey(USER_A_ID, 'theme');
|
||||
expect(prefA).toBeDefined();
|
||||
|
||||
// Re-insert User B's preference so afterAll cleanup still finds it
|
||||
await repo.upsert({
|
||||
id: PREF_B_ID,
|
||||
userId: USER_B_ID,
|
||||
key: 'theme',
|
||||
value: 'light',
|
||||
category: 'appearance',
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Insights isolation ───────────────────────────────────────────────────────
|
||||
|
||||
describe('InsightsRepo — cross-user isolation', () => {
|
||||
it('User A can retrieve their own insights', async () => {
|
||||
const repo = createInsightsRepo(handle.db);
|
||||
const list = await repo.findByUser(USER_A_ID);
|
||||
const ids = list.map((i) => i.id);
|
||||
expect(ids).toContain(INSIGHT_A_ID);
|
||||
});
|
||||
|
||||
it('User A insights do not contain User B insights', async () => {
|
||||
const repo = createInsightsRepo(handle.db);
|
||||
const list = await repo.findByUser(USER_A_ID);
|
||||
const ids = list.map((i) => i.id);
|
||||
expect(ids).not.toContain(INSIGHT_B_ID);
|
||||
});
|
||||
|
||||
it('User B insights do not contain User A insights', async () => {
|
||||
const repo = createInsightsRepo(handle.db);
|
||||
const list = await repo.findByUser(USER_B_ID);
|
||||
const ids = list.map((i) => i.id);
|
||||
expect(ids).not.toContain(INSIGHT_A_ID);
|
||||
});
|
||||
|
||||
it('findById is scoped to the requesting user', async () => {
|
||||
const repo = createInsightsRepo(handle.db);
|
||||
const own = await repo.findById(INSIGHT_A_ID, USER_A_ID);
|
||||
const cross = await repo.findById(INSIGHT_A_ID, USER_B_ID);
|
||||
|
||||
expect(own).toBeDefined();
|
||||
expect(cross).toBeUndefined();
|
||||
});
|
||||
|
||||
it('searchByEmbedding returns only own insights', async () => {
|
||||
const repo = createInsightsRepo(handle.db);
|
||||
// Our test insights have no embedding — the query filters WHERE embedding IS NOT NULL
|
||||
// so the result set is empty, which already proves no cross-user leakage.
|
||||
// Using a 1536-dimension zero vector as the query embedding.
|
||||
const zeroVector = Array<number>(1536).fill(0);
|
||||
|
||||
const resultsA = await repo.searchByEmbedding(USER_A_ID, zeroVector, 50, 2.0);
|
||||
const resultsB = await repo.searchByEmbedding(USER_B_ID, zeroVector, 50, 2.0);
|
||||
|
||||
// The raw SQL query returns row objects directly (not wrapped in { insight }).
|
||||
// Cast via unknown to extract id safely regardless of the return shape.
|
||||
const toId = (r: unknown): string =>
|
||||
((r as Record<string, unknown>)['id'] as string | undefined) ??
|
||||
((r as Record<string, Record<string, unknown>>)['insight']?.['id'] as string | undefined) ??
|
||||
'';
|
||||
const idsInA = resultsA.map(toId);
|
||||
const idsInB = resultsB.map(toId);
|
||||
|
||||
// User B's insight must never appear in User A's search results
|
||||
expect(idsInA).not.toContain(INSIGHT_B_ID);
|
||||
// User A's insight must never appear in User B's search results
|
||||
expect(idsInB).not.toContain(INSIGHT_A_ID);
|
||||
});
|
||||
|
||||
it('update is scoped to the requesting user', async () => {
|
||||
const repo = createInsightsRepo(handle.db);
|
||||
const result = await repo.update(INSIGHT_A_ID, USER_B_ID, { content: 'hacked' });
|
||||
expect(result).toBeUndefined();
|
||||
|
||||
// Verify the insight was not mutated
|
||||
const unchanged = await repo.findById(INSIGHT_A_ID, USER_A_ID);
|
||||
expect(unchanged?.content).toBe('User A insight');
|
||||
});
|
||||
|
||||
it('remove is scoped to the requesting user', async () => {
|
||||
const repo = createInsightsRepo(handle.db);
|
||||
const deleted = await repo.remove(INSIGHT_A_ID, USER_B_ID);
|
||||
expect(deleted).toBe(false);
|
||||
|
||||
// Verify the insight still exists
|
||||
const still = await repo.findById(INSIGHT_A_ID, USER_A_ID);
|
||||
expect(still).toBeDefined();
|
||||
});
|
||||
});
|
||||
@@ -1,4 +1,4 @@
|
||||
import { ForbiddenException, NotFoundException } from '@nestjs/common';
|
||||
import { ForbiddenException } from '@nestjs/common';
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
import { ConversationsController } from '../conversations/conversations.controller.js';
|
||||
import { MissionsController } from '../missions/missions.controller.js';
|
||||
@@ -18,7 +18,6 @@ function createBrain() {
|
||||
},
|
||||
projects: {
|
||||
findAll: vi.fn(),
|
||||
findAllForUser: vi.fn(),
|
||||
findById: vi.fn(),
|
||||
create: vi.fn(),
|
||||
update: vi.fn(),
|
||||
@@ -26,21 +25,12 @@ function createBrain() {
|
||||
},
|
||||
missions: {
|
||||
findAll: vi.fn(),
|
||||
findAllByUser: vi.fn(),
|
||||
findById: vi.fn(),
|
||||
findByIdAndUser: vi.fn(),
|
||||
findByProject: vi.fn(),
|
||||
create: vi.fn(),
|
||||
update: vi.fn(),
|
||||
remove: vi.fn(),
|
||||
},
|
||||
missionTasks: {
|
||||
findByMissionAndUser: vi.fn(),
|
||||
findByIdAndUser: vi.fn(),
|
||||
create: vi.fn(),
|
||||
update: vi.fn(),
|
||||
remove: vi.fn(),
|
||||
},
|
||||
tasks: {
|
||||
findAll: vi.fn(),
|
||||
findById: vi.fn(),
|
||||
@@ -57,35 +47,32 @@ function createBrain() {
|
||||
describe('Resource ownership checks', () => {
|
||||
it('forbids access to another user conversation', async () => {
|
||||
const brain = createBrain();
|
||||
// The repo enforces ownership via the WHERE clause; it returns undefined when the
|
||||
// conversation does not belong to the requesting user.
|
||||
brain.conversations.findById.mockResolvedValue(undefined);
|
||||
brain.conversations.findById.mockResolvedValue({ id: 'conv-1', userId: 'user-2' });
|
||||
const controller = new ConversationsController(brain as never);
|
||||
|
||||
await expect(controller.findOne('conv-1', { id: 'user-1' })).rejects.toBeInstanceOf(
|
||||
NotFoundException,
|
||||
ForbiddenException,
|
||||
);
|
||||
});
|
||||
|
||||
it('forbids access to another user project', async () => {
|
||||
const brain = createBrain();
|
||||
brain.projects.findById.mockResolvedValue({ id: 'project-1', ownerId: 'user-2' });
|
||||
const teamsService = { canAccessProject: vi.fn().mockResolvedValue(false) };
|
||||
const controller = new ProjectsController(brain as never, teamsService as never);
|
||||
const controller = new ProjectsController(brain as never);
|
||||
|
||||
await expect(controller.findOne('project-1', { id: 'user-1' })).rejects.toBeInstanceOf(
|
||||
ForbiddenException,
|
||||
);
|
||||
});
|
||||
|
||||
it('forbids access to a mission owned by another user', async () => {
|
||||
it('forbids access to a mission owned by another project owner', async () => {
|
||||
const brain = createBrain();
|
||||
// findByIdAndUser returns undefined when the mission doesn't belong to the user
|
||||
brain.missions.findByIdAndUser.mockResolvedValue(undefined);
|
||||
brain.missions.findById.mockResolvedValue({ id: 'mission-1', projectId: 'project-1' });
|
||||
brain.projects.findById.mockResolvedValue({ id: 'project-1', ownerId: 'user-2' });
|
||||
const controller = new MissionsController(brain as never);
|
||||
|
||||
await expect(controller.findOne('mission-1', { id: 'user-1' })).rejects.toBeInstanceOf(
|
||||
NotFoundException,
|
||||
ForbiddenException,
|
||||
);
|
||||
});
|
||||
|
||||
@@ -99,52 +86,4 @@ describe('Resource ownership checks', () => {
|
||||
ForbiddenException,
|
||||
);
|
||||
});
|
||||
|
||||
it('forbids creating a task with an unowned project', async () => {
|
||||
const brain = createBrain();
|
||||
brain.projects.findById.mockResolvedValue({ id: 'project-1', ownerId: 'user-2' });
|
||||
const controller = new TasksController(brain as never);
|
||||
|
||||
await expect(
|
||||
controller.create(
|
||||
{
|
||||
title: 'Task',
|
||||
projectId: 'project-1',
|
||||
},
|
||||
{ id: 'user-1' },
|
||||
),
|
||||
).rejects.toBeInstanceOf(ForbiddenException);
|
||||
});
|
||||
|
||||
it('forbids listing tasks for an unowned project', async () => {
|
||||
const brain = createBrain();
|
||||
brain.projects.findById.mockResolvedValue({ id: 'project-1', ownerId: 'user-2' });
|
||||
const controller = new TasksController(brain as never);
|
||||
|
||||
await expect(
|
||||
controller.list({ id: 'user-1' }, 'project-1', undefined, undefined),
|
||||
).rejects.toBeInstanceOf(ForbiddenException);
|
||||
});
|
||||
|
||||
it('lists only tasks for the current user owned projects when no filter is provided', async () => {
|
||||
const brain = createBrain();
|
||||
brain.projects.findAll.mockResolvedValue([
|
||||
{ id: 'project-1', ownerId: 'user-1' },
|
||||
{ id: 'project-2', ownerId: 'user-2' },
|
||||
]);
|
||||
brain.missions.findAll.mockResolvedValue([{ id: 'mission-1', projectId: 'project-1' }]);
|
||||
brain.tasks.findAll.mockResolvedValue([
|
||||
{ id: 'task-1', projectId: 'project-1' },
|
||||
{ id: 'task-2', missionId: 'mission-1' },
|
||||
{ id: 'task-3', projectId: 'project-2' },
|
||||
]);
|
||||
const controller = new TasksController(brain as never);
|
||||
|
||||
await expect(
|
||||
controller.list({ id: 'user-1' }, undefined, undefined, undefined),
|
||||
).resolves.toEqual([
|
||||
{ id: 'task-1', projectId: 'project-1' },
|
||||
{ id: 'task-2', missionId: 'mission-1' },
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -1,377 +0,0 @@
|
||||
/**
|
||||
* M5-008: Session hardening verification tests.
|
||||
*
|
||||
* Verifies:
|
||||
* 1. /model command switches model → session:info reflects updated modelId
|
||||
* 2. /agent command switches agent config → system prompt / agentName changes
|
||||
* 3. Session resume binds to a conversation (history injected via conversationHistory option)
|
||||
* 4. Session metrics track token usage and message count correctly
|
||||
*/
|
||||
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
||||
import type {
|
||||
AgentSession,
|
||||
AgentSessionOptions,
|
||||
ConversationHistoryMessage,
|
||||
} from '../agent/agent.service.js';
|
||||
import type { SessionInfoDto, SessionMetrics, SessionTokenMetrics } from '../agent/session.dto.js';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helpers — minimal AgentSession fixture
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function makeMetrics(overrides?: Partial<SessionMetrics>): SessionMetrics {
|
||||
return {
|
||||
tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
|
||||
modelSwitches: 0,
|
||||
messageCount: 0,
|
||||
lastActivityAt: new Date().toISOString(),
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function makeSession(overrides?: Partial<AgentSession>): AgentSession {
|
||||
return {
|
||||
id: 'session-001',
|
||||
provider: 'anthropic',
|
||||
modelId: 'claude-3-5-sonnet-20241022',
|
||||
piSession: {} as AgentSession['piSession'],
|
||||
listeners: new Set(),
|
||||
unsubscribe: vi.fn(),
|
||||
createdAt: Date.now(),
|
||||
promptCount: 0,
|
||||
channels: new Set(),
|
||||
skillPromptAdditions: [],
|
||||
sandboxDir: '/tmp',
|
||||
allowedTools: null,
|
||||
metrics: makeMetrics(),
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function sessionToInfo(session: AgentSession): SessionInfoDto {
|
||||
return {
|
||||
id: session.id,
|
||||
provider: session.provider,
|
||||
modelId: session.modelId,
|
||||
...(session.agentName ? { agentName: session.agentName } : {}),
|
||||
createdAt: new Date(session.createdAt).toISOString(),
|
||||
promptCount: session.promptCount,
|
||||
channels: Array.from(session.channels),
|
||||
durationMs: Date.now() - session.createdAt,
|
||||
metrics: { ...session.metrics },
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Replicated AgentService methods (tested in isolation without full DI setup)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function updateSessionModel(session: AgentSession, modelId: string): void {
|
||||
session.modelId = modelId;
|
||||
session.metrics.modelSwitches += 1;
|
||||
session.metrics.lastActivityAt = new Date().toISOString();
|
||||
}
|
||||
|
||||
function applyAgentConfig(
|
||||
session: AgentSession,
|
||||
agentConfigId: string,
|
||||
agentName: string,
|
||||
modelId?: string,
|
||||
): void {
|
||||
session.agentConfigId = agentConfigId;
|
||||
session.agentName = agentName;
|
||||
if (modelId) {
|
||||
updateSessionModel(session, modelId);
|
||||
}
|
||||
}
|
||||
|
||||
function recordTokenUsage(session: AgentSession, tokens: SessionTokenMetrics): void {
|
||||
session.metrics.tokens.input += tokens.input;
|
||||
session.metrics.tokens.output += tokens.output;
|
||||
session.metrics.tokens.cacheRead += tokens.cacheRead;
|
||||
session.metrics.tokens.cacheWrite += tokens.cacheWrite;
|
||||
session.metrics.tokens.total += tokens.total;
|
||||
session.metrics.lastActivityAt = new Date().toISOString();
|
||||
}
|
||||
|
||||
function recordMessage(session: AgentSession): void {
|
||||
session.metrics.messageCount += 1;
|
||||
session.metrics.lastActivityAt = new Date().toISOString();
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 1. /model command — switches model → session:info updated
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('/model command — model switch reflected in session:info', () => {
|
||||
let session: AgentSession;
|
||||
|
||||
beforeEach(() => {
|
||||
session = makeSession();
|
||||
});
|
||||
|
||||
it('updates modelId when /model is called with a model name', () => {
|
||||
updateSessionModel(session, 'claude-opus-4-5-20251001');
|
||||
|
||||
expect(session.modelId).toBe('claude-opus-4-5-20251001');
|
||||
});
|
||||
|
||||
it('increments modelSwitches metric after /model command', () => {
|
||||
expect(session.metrics.modelSwitches).toBe(0);
|
||||
|
||||
updateSessionModel(session, 'gpt-4o');
|
||||
expect(session.metrics.modelSwitches).toBe(1);
|
||||
|
||||
updateSessionModel(session, 'claude-3-5-sonnet-20241022');
|
||||
expect(session.metrics.modelSwitches).toBe(2);
|
||||
});
|
||||
|
||||
it('session:info DTO reflects the new modelId after switch', () => {
|
||||
updateSessionModel(session, 'claude-haiku-3-5-20251001');
|
||||
|
||||
const info = sessionToInfo(session);
|
||||
|
||||
expect(info.modelId).toBe('claude-haiku-3-5-20251001');
|
||||
expect(info.metrics.modelSwitches).toBe(1);
|
||||
});
|
||||
|
||||
it('lastActivityAt is updated after model switch', () => {
|
||||
const before = session.metrics.lastActivityAt;
|
||||
// Ensure at least 1ms passes
|
||||
vi.setSystemTime(Date.now() + 1);
|
||||
updateSessionModel(session, 'new-model');
|
||||
vi.useRealTimers();
|
||||
|
||||
expect(session.metrics.lastActivityAt).not.toBe(before);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 2. /agent command — switches agent config → system prompt / agentName updated
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('/agent command — agent config applied to session', () => {
|
||||
let session: AgentSession;
|
||||
|
||||
beforeEach(() => {
|
||||
session = makeSession();
|
||||
});
|
||||
|
||||
it('sets agentConfigId and agentName on the session', () => {
|
||||
applyAgentConfig(session, 'agent-uuid-001', 'CodeReviewer');
|
||||
|
||||
expect(session.agentConfigId).toBe('agent-uuid-001');
|
||||
expect(session.agentName).toBe('CodeReviewer');
|
||||
});
|
||||
|
||||
it('also updates modelId when agent config carries a model', () => {
|
||||
applyAgentConfig(session, 'agent-uuid-002', 'DataAnalyst', 'gpt-4o-mini');
|
||||
|
||||
expect(session.agentName).toBe('DataAnalyst');
|
||||
expect(session.modelId).toBe('gpt-4o-mini');
|
||||
expect(session.metrics.modelSwitches).toBe(1);
|
||||
});
|
||||
|
||||
it('does NOT update modelId when agent config has no model', () => {
|
||||
const originalModel = session.modelId;
|
||||
applyAgentConfig(session, 'agent-uuid-003', 'Planner', undefined);
|
||||
|
||||
expect(session.modelId).toBe(originalModel);
|
||||
expect(session.metrics.modelSwitches).toBe(0);
|
||||
});
|
||||
|
||||
it('session:info DTO reflects agentName after /agent switch', () => {
|
||||
applyAgentConfig(session, 'agent-uuid-004', 'DevBot');
|
||||
|
||||
const info = sessionToInfo(session);
|
||||
|
||||
expect(info.agentName).toBe('DevBot');
|
||||
});
|
||||
|
||||
it('multiple /agent calls update to the latest agent', () => {
|
||||
applyAgentConfig(session, 'agent-001', 'FirstAgent');
|
||||
applyAgentConfig(session, 'agent-002', 'SecondAgent');
|
||||
|
||||
expect(session.agentConfigId).toBe('agent-002');
|
||||
expect(session.agentName).toBe('SecondAgent');
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 3. Session resume — binds to conversation via conversationHistory
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('Session resume — binds to conversation', () => {
|
||||
it('conversationHistory option is preserved in session options', () => {
|
||||
const history: ConversationHistoryMessage[] = [
|
||||
{
|
||||
role: 'user',
|
||||
content: 'Hello, what is TypeScript?',
|
||||
createdAt: new Date('2026-01-01T00:01:00Z'),
|
||||
},
|
||||
{
|
||||
role: 'assistant',
|
||||
content: 'TypeScript is a typed superset of JavaScript.',
|
||||
createdAt: new Date('2026-01-01T00:01:05Z'),
|
||||
},
|
||||
];
|
||||
|
||||
const options: AgentSessionOptions = {
|
||||
conversationHistory: history,
|
||||
provider: 'anthropic',
|
||||
modelId: 'claude-3-5-sonnet-20241022',
|
||||
};
|
||||
|
||||
expect(options.conversationHistory).toHaveLength(2);
|
||||
expect(options.conversationHistory![0]!.role).toBe('user');
|
||||
expect(options.conversationHistory![1]!.role).toBe('assistant');
|
||||
});
|
||||
|
||||
it('session with conversationHistory option carries the conversation binding', () => {
|
||||
const CONV_ID = 'conv-resume-001';
|
||||
const history: ConversationHistoryMessage[] = [
|
||||
{ role: 'user', content: 'Prior question', createdAt: new Date('2026-01-01T00:01:00Z') },
|
||||
];
|
||||
|
||||
// Simulate what ChatGateway does: pass conversationId + history to createSession
|
||||
const options: AgentSessionOptions = {
|
||||
conversationHistory: history,
|
||||
};
|
||||
|
||||
// The session ID is the conversationId in the gateway
|
||||
const session = makeSession({ id: CONV_ID });
|
||||
|
||||
expect(session.id).toBe(CONV_ID);
|
||||
expect(options.conversationHistory).toHaveLength(1);
|
||||
});
|
||||
|
||||
it('empty conversationHistory is valid (new conversation)', () => {
|
||||
const options: AgentSessionOptions = {
|
||||
conversationHistory: [],
|
||||
};
|
||||
|
||||
expect(options.conversationHistory).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('resumed session preserves all message roles', () => {
|
||||
const history: ConversationHistoryMessage[] = [
|
||||
{ role: 'system', content: 'You are a helpful assistant.', createdAt: new Date() },
|
||||
{ role: 'user', content: 'Question 1', createdAt: new Date() },
|
||||
{ role: 'assistant', content: 'Answer 1', createdAt: new Date() },
|
||||
{ role: 'user', content: 'Question 2', createdAt: new Date() },
|
||||
];
|
||||
|
||||
const roles = history.map((m) => m.role);
|
||||
expect(roles).toEqual(['system', 'user', 'assistant', 'user']);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 4. Session metrics — token usage and message count
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('Session metrics — token usage and message count', () => {
|
||||
let session: AgentSession;
|
||||
|
||||
beforeEach(() => {
|
||||
session = makeSession();
|
||||
});
|
||||
|
||||
it('starts with zero metrics', () => {
|
||||
expect(session.metrics.tokens.input).toBe(0);
|
||||
expect(session.metrics.tokens.output).toBe(0);
|
||||
expect(session.metrics.tokens.total).toBe(0);
|
||||
expect(session.metrics.messageCount).toBe(0);
|
||||
expect(session.metrics.modelSwitches).toBe(0);
|
||||
});
|
||||
|
||||
it('accumulates token usage across multiple turns', () => {
|
||||
recordTokenUsage(session, {
|
||||
input: 100,
|
||||
output: 50,
|
||||
cacheRead: 0,
|
||||
cacheWrite: 0,
|
||||
total: 150,
|
||||
});
|
||||
recordTokenUsage(session, {
|
||||
input: 200,
|
||||
output: 80,
|
||||
cacheRead: 10,
|
||||
cacheWrite: 5,
|
||||
total: 295,
|
||||
});
|
||||
|
||||
expect(session.metrics.tokens.input).toBe(300);
|
||||
expect(session.metrics.tokens.output).toBe(130);
|
||||
expect(session.metrics.tokens.cacheRead).toBe(10);
|
||||
expect(session.metrics.tokens.cacheWrite).toBe(5);
|
||||
expect(session.metrics.tokens.total).toBe(445);
|
||||
});
|
||||
|
||||
it('increments message count with each recordMessage call', () => {
|
||||
expect(session.metrics.messageCount).toBe(0);
|
||||
|
||||
recordMessage(session);
|
||||
expect(session.metrics.messageCount).toBe(1);
|
||||
|
||||
recordMessage(session);
|
||||
recordMessage(session);
|
||||
expect(session.metrics.messageCount).toBe(3);
|
||||
});
|
||||
|
||||
it('session:info DTO exposes correct metrics snapshot', () => {
|
||||
recordTokenUsage(session, {
|
||||
input: 500,
|
||||
output: 100,
|
||||
cacheRead: 20,
|
||||
cacheWrite: 10,
|
||||
total: 630,
|
||||
});
|
||||
recordMessage(session);
|
||||
recordMessage(session);
|
||||
updateSessionModel(session, 'claude-haiku-3-5-20251001');
|
||||
|
||||
const info = sessionToInfo(session);
|
||||
|
||||
expect(info.metrics.tokens.input).toBe(500);
|
||||
expect(info.metrics.tokens.output).toBe(100);
|
||||
expect(info.metrics.tokens.total).toBe(630);
|
||||
expect(info.metrics.messageCount).toBe(2);
|
||||
expect(info.metrics.modelSwitches).toBe(1);
|
||||
});
|
||||
|
||||
it('metrics are independent per session', () => {
|
||||
const sessionA = makeSession({ id: 'session-A' });
|
||||
const sessionB = makeSession({ id: 'session-B' });
|
||||
|
||||
recordTokenUsage(sessionA, { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, total: 150 });
|
||||
recordMessage(sessionA);
|
||||
|
||||
// Session B should remain at zero
|
||||
expect(sessionB.metrics.tokens.input).toBe(0);
|
||||
expect(sessionB.metrics.messageCount).toBe(0);
|
||||
|
||||
// Session A should have updated values
|
||||
expect(sessionA.metrics.tokens.input).toBe(100);
|
||||
expect(sessionA.metrics.messageCount).toBe(1);
|
||||
});
|
||||
|
||||
it('lastActivityAt is updated after recording tokens', () => {
|
||||
const before = session.metrics.lastActivityAt;
|
||||
vi.setSystemTime(new Date(Date.now() + 100));
|
||||
recordTokenUsage(session, { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, total: 15 });
|
||||
vi.useRealTimers();
|
||||
|
||||
expect(session.metrics.lastActivityAt).not.toBe(before);
|
||||
});
|
||||
|
||||
it('lastActivityAt is updated after recording a message', () => {
|
||||
const before = session.metrics.lastActivityAt;
|
||||
vi.setSystemTime(new Date(Date.now() + 100));
|
||||
recordMessage(session);
|
||||
vi.useRealTimers();
|
||||
|
||||
expect(session.metrics.lastActivityAt).not.toBe(before);
|
||||
});
|
||||
});
|
||||
@@ -1,73 +0,0 @@
|
||||
import { Controller, Get, Inject, UseGuards } from '@nestjs/common';
|
||||
import { sql, type Db } from '@mosaic/db';
|
||||
import { createQueue } from '@mosaic/queue';
|
||||
import { DB } from '../database/database.module.js';
|
||||
import { AgentService } from '../agent/agent.service.js';
|
||||
import { ProviderService } from '../agent/provider.service.js';
|
||||
import { AdminGuard } from './admin.guard.js';
|
||||
import type { HealthStatusDto, ServiceStatusDto } from './admin.dto.js';
|
||||
|
||||
@Controller('api/admin/health')
|
||||
@UseGuards(AdminGuard)
|
||||
export class AdminHealthController {
|
||||
constructor(
|
||||
@Inject(DB) private readonly db: Db,
|
||||
@Inject(AgentService) private readonly agentService: AgentService,
|
||||
@Inject(ProviderService) private readonly providerService: ProviderService,
|
||||
) {}
|
||||
|
||||
@Get()
|
||||
async check(): Promise<HealthStatusDto> {
|
||||
const [database, cache] = await Promise.all([this.checkDatabase(), this.checkCache()]);
|
||||
|
||||
const sessions = this.agentService.listSessions();
|
||||
const providers = this.providerService.listProviders();
|
||||
|
||||
const allOk = database.status === 'ok' && cache.status === 'ok';
|
||||
|
||||
return {
|
||||
status: allOk ? 'ok' : 'degraded',
|
||||
database,
|
||||
cache,
|
||||
agentPool: { activeSessions: sessions.length },
|
||||
providers: providers.map((p) => ({
|
||||
id: p.id,
|
||||
name: p.name,
|
||||
available: p.available,
|
||||
modelCount: p.models.length,
|
||||
})),
|
||||
checkedAt: new Date().toISOString(),
|
||||
};
|
||||
}
|
||||
|
||||
private async checkDatabase(): Promise<ServiceStatusDto> {
|
||||
const start = Date.now();
|
||||
try {
|
||||
await this.db.execute(sql`SELECT 1`);
|
||||
return { status: 'ok', latencyMs: Date.now() - start };
|
||||
} catch (err) {
|
||||
return {
|
||||
status: 'error',
|
||||
latencyMs: Date.now() - start,
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
private async checkCache(): Promise<ServiceStatusDto> {
|
||||
const start = Date.now();
|
||||
const handle = createQueue();
|
||||
try {
|
||||
await handle.redis.ping();
|
||||
return { status: 'ok', latencyMs: Date.now() - start };
|
||||
} catch (err) {
|
||||
return {
|
||||
status: 'error',
|
||||
latencyMs: Date.now() - start,
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
};
|
||||
} finally {
|
||||
await handle.close().catch(() => {});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,128 +0,0 @@
|
||||
import {
|
||||
Controller,
|
||||
Get,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
Inject,
|
||||
NotFoundException,
|
||||
Optional,
|
||||
Param,
|
||||
Post,
|
||||
Query,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import { AdminGuard } from './admin.guard.js';
|
||||
import { QueueService } from '../queue/queue.service.js';
|
||||
import type { JobDto, JobListDto, JobStatus, QueueListDto } from '../queue/queue-admin.dto.js';
|
||||
|
||||
@Controller('api/admin/jobs')
|
||||
@UseGuards(AdminGuard)
|
||||
export class AdminJobsController {
|
||||
constructor(
|
||||
@Optional()
|
||||
@Inject(QueueService)
|
||||
private readonly queueService: QueueService | null,
|
||||
) {}
|
||||
|
||||
/**
|
||||
* GET /api/admin/jobs
|
||||
* List jobs across all queues. Optional ?status=active|completed|failed|waiting|delayed
|
||||
*/
|
||||
@Get()
|
||||
async listJobs(@Query('status') status?: string): Promise<JobListDto> {
|
||||
if (!this.queueService) {
|
||||
return { jobs: [], total: 0 };
|
||||
}
|
||||
|
||||
const validStatuses: JobStatus[] = ['active', 'completed', 'failed', 'waiting', 'delayed'];
|
||||
const normalised = status as JobStatus | undefined;
|
||||
|
||||
if (normalised && !validStatuses.includes(normalised)) {
|
||||
return { jobs: [], total: 0 };
|
||||
}
|
||||
|
||||
const jobs: JobDto[] = await this.queueService.listJobs(normalised);
|
||||
return { jobs, total: jobs.length };
|
||||
}
|
||||
|
||||
/**
|
||||
* POST /api/admin/jobs/:id/retry
|
||||
* Retry a specific failed job. The id is "<queue>__<bullmq-job-id>".
|
||||
*/
|
||||
@Post(':id/retry')
|
||||
@HttpCode(HttpStatus.OK)
|
||||
async retryJob(@Param('id') id: string): Promise<{ ok: boolean; message: string }> {
|
||||
if (!this.queueService) {
|
||||
throw new NotFoundException('Queue service is not available');
|
||||
}
|
||||
|
||||
const result = await this.queueService.retryJob(id);
|
||||
if (!result.ok) {
|
||||
throw new NotFoundException(result.message);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* GET /api/admin/jobs/queues
|
||||
* Return status for all managed queues.
|
||||
*/
|
||||
@Get('queues')
|
||||
async listQueues(): Promise<QueueListDto> {
|
||||
if (!this.queueService) {
|
||||
return { queues: [] };
|
||||
}
|
||||
|
||||
const health = await this.queueService.getHealthStatus();
|
||||
const queues = Object.entries(health.queues).map(([name, stats]) => ({
|
||||
name,
|
||||
waiting: stats.waiting,
|
||||
active: stats.active,
|
||||
completed: stats.completed,
|
||||
failed: stats.failed,
|
||||
delayed: 0,
|
||||
paused: stats.paused,
|
||||
}));
|
||||
|
||||
return { queues };
|
||||
}
|
||||
|
||||
/**
|
||||
* POST /api/admin/jobs/queues/:name/pause
|
||||
* Pause the named queue.
|
||||
*/
|
||||
@Post('queues/:name/pause')
|
||||
@HttpCode(HttpStatus.OK)
|
||||
async pauseQueue(@Param('name') name: string): Promise<{ ok: boolean; message: string }> {
|
||||
if (!this.queueService) {
|
||||
throw new NotFoundException('Queue service is not available');
|
||||
}
|
||||
|
||||
const result = await this.queueService.pauseQueue(name);
|
||||
if (!result.ok) {
|
||||
throw new NotFoundException(result.message);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* POST /api/admin/jobs/queues/:name/resume
|
||||
* Resume the named queue.
|
||||
*/
|
||||
@Post('queues/:name/resume')
|
||||
@HttpCode(HttpStatus.OK)
|
||||
async resumeQueue(@Param('name') name: string): Promise<{ ok: boolean; message: string }> {
|
||||
if (!this.queueService) {
|
||||
throw new NotFoundException('Queue service is not available');
|
||||
}
|
||||
|
||||
const result = await this.queueService.resumeQueue(name);
|
||||
if (!result.ok) {
|
||||
throw new NotFoundException(result.message);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@@ -1,146 +0,0 @@
|
||||
import {
|
||||
Body,
|
||||
Controller,
|
||||
Delete,
|
||||
Get,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
Inject,
|
||||
InternalServerErrorException,
|
||||
NotFoundException,
|
||||
Param,
|
||||
Patch,
|
||||
Post,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import { eq, type Db, users as usersTable } from '@mosaic/db';
|
||||
import type { Auth } from '@mosaic/auth';
|
||||
import { AUTH } from '../auth/auth.tokens.js';
|
||||
import { DB } from '../database/database.module.js';
|
||||
import { AdminGuard } from './admin.guard.js';
|
||||
import type {
|
||||
BanUserDto,
|
||||
CreateUserDto,
|
||||
UpdateUserRoleDto,
|
||||
UserDto,
|
||||
UserListDto,
|
||||
} from './admin.dto.js';
|
||||
|
||||
type UserRow = typeof usersTable.$inferSelect;
|
||||
|
||||
function toUserDto(u: UserRow): UserDto {
|
||||
return {
|
||||
id: u.id,
|
||||
name: u.name,
|
||||
email: u.email,
|
||||
role: u.role,
|
||||
banned: u.banned ?? false,
|
||||
banReason: u.banReason ?? null,
|
||||
createdAt: u.createdAt.toISOString(),
|
||||
updatedAt: u.updatedAt.toISOString(),
|
||||
};
|
||||
}
|
||||
|
||||
async function requireUpdated(
|
||||
db: Db,
|
||||
id: string,
|
||||
update: Partial<Omit<UserRow, 'id' | 'createdAt'>>,
|
||||
): Promise<UserDto> {
|
||||
const [updated] = await db
|
||||
.update(usersTable)
|
||||
.set({ ...update, updatedAt: new Date() })
|
||||
.where(eq(usersTable.id, id))
|
||||
.returning();
|
||||
if (!updated) throw new InternalServerErrorException('Update returned no rows');
|
||||
return toUserDto(updated);
|
||||
}
|
||||
|
||||
@Controller('api/admin/users')
|
||||
@UseGuards(AdminGuard)
|
||||
export class AdminController {
|
||||
constructor(
|
||||
@Inject(DB) private readonly db: Db,
|
||||
@Inject(AUTH) private readonly auth: Auth,
|
||||
) {}
|
||||
|
||||
@Get()
|
||||
async listUsers(): Promise<UserListDto> {
|
||||
const rows = await this.db.select().from(usersTable).orderBy(usersTable.createdAt);
|
||||
const userList: UserDto[] = rows.map(toUserDto);
|
||||
return { users: userList, total: userList.length };
|
||||
}
|
||||
|
||||
@Get(':id')
|
||||
async getUser(@Param('id') id: string): Promise<UserDto> {
|
||||
const [user] = await this.db.select().from(usersTable).where(eq(usersTable.id, id)).limit(1);
|
||||
if (!user) throw new NotFoundException('User not found');
|
||||
return toUserDto(user);
|
||||
}
|
||||
|
||||
@Post()
|
||||
async createUser(@Body() body: CreateUserDto): Promise<UserDto> {
|
||||
// Use auth API to create user so password is properly hashed
|
||||
const authApi = this.auth.api as unknown as {
|
||||
createUser: (opts: {
|
||||
body: { name: string; email: string; password: string; role?: string };
|
||||
}) => Promise<{
|
||||
user: { id: string; name: string; email: string; createdAt: unknown; updatedAt: unknown };
|
||||
}>;
|
||||
};
|
||||
|
||||
const result = await authApi.createUser({
|
||||
body: {
|
||||
name: body.name,
|
||||
email: body.email,
|
||||
password: body.password,
|
||||
role: body.role ?? 'member',
|
||||
},
|
||||
});
|
||||
|
||||
// Re-fetch from DB to get full row with our schema
|
||||
const [user] = await this.db
|
||||
.select()
|
||||
.from(usersTable)
|
||||
.where(eq(usersTable.id, result.user.id))
|
||||
.limit(1);
|
||||
|
||||
if (!user) throw new InternalServerErrorException('User created but not found in DB');
|
||||
return toUserDto(user);
|
||||
}
|
||||
|
||||
@Patch(':id/role')
|
||||
async setRole(@Param('id') id: string, @Body() body: UpdateUserRoleDto): Promise<UserDto> {
|
||||
await this.ensureExists(id);
|
||||
return requireUpdated(this.db, id, { role: body.role });
|
||||
}
|
||||
|
||||
@Post(':id/ban')
|
||||
@HttpCode(HttpStatus.OK)
|
||||
async banUser(@Param('id') id: string, @Body() body: BanUserDto): Promise<UserDto> {
|
||||
await this.ensureExists(id);
|
||||
return requireUpdated(this.db, id, { banned: true, banReason: body.reason ?? null });
|
||||
}
|
||||
|
||||
@Post(':id/unban')
|
||||
@HttpCode(HttpStatus.OK)
|
||||
async unbanUser(@Param('id') id: string): Promise<UserDto> {
|
||||
await this.ensureExists(id);
|
||||
return requireUpdated(this.db, id, { banned: false, banReason: null, banExpires: null });
|
||||
}
|
||||
|
||||
@Delete(':id')
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
async deleteUser(@Param('id') id: string): Promise<void> {
|
||||
await this.ensureExists(id);
|
||||
await this.db.delete(usersTable).where(eq(usersTable.id, id));
|
||||
}
|
||||
|
||||
private async ensureExists(id: string): Promise<void> {
|
||||
const [existing] = await this.db
|
||||
.select({ id: usersTable.id })
|
||||
.from(usersTable)
|
||||
.where(eq(usersTable.id, id))
|
||||
.limit(1);
|
||||
if (!existing) throw new NotFoundException('User not found');
|
||||
}
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
export interface UserDto {
|
||||
id: string;
|
||||
name: string;
|
||||
email: string;
|
||||
role: string;
|
||||
banned: boolean;
|
||||
banReason: string | null;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
}
|
||||
|
||||
export interface UserListDto {
|
||||
users: UserDto[];
|
||||
total: number;
|
||||
}
|
||||
|
||||
export interface CreateUserDto {
|
||||
name: string;
|
||||
email: string;
|
||||
password: string;
|
||||
role?: string;
|
||||
}
|
||||
|
||||
export interface UpdateUserRoleDto {
|
||||
role: string;
|
||||
}
|
||||
|
||||
export interface BanUserDto {
|
||||
reason?: string;
|
||||
}
|
||||
|
||||
export interface HealthStatusDto {
|
||||
status: 'ok' | 'degraded' | 'error';
|
||||
database: ServiceStatusDto;
|
||||
cache: ServiceStatusDto;
|
||||
agentPool: AgentPoolStatusDto;
|
||||
providers: ProviderStatusDto[];
|
||||
checkedAt: string;
|
||||
}
|
||||
|
||||
export interface ServiceStatusDto {
|
||||
status: 'ok' | 'error';
|
||||
latencyMs?: number;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
export interface AgentPoolStatusDto {
|
||||
activeSessions: number;
|
||||
}
|
||||
|
||||
export interface ProviderStatusDto {
|
||||
id: string;
|
||||
name: string;
|
||||
available: boolean;
|
||||
modelCount: number;
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
import {
|
||||
CanActivate,
|
||||
ExecutionContext,
|
||||
ForbiddenException,
|
||||
Inject,
|
||||
Injectable,
|
||||
UnauthorizedException,
|
||||
} from '@nestjs/common';
|
||||
import { fromNodeHeaders } from 'better-auth/node';
|
||||
import type { Auth } from '@mosaic/auth';
|
||||
import type { Db } from '@mosaic/db';
|
||||
import { eq, users as usersTable } from '@mosaic/db';
|
||||
import type { FastifyRequest } from 'fastify';
|
||||
import { AUTH } from '../auth/auth.tokens.js';
|
||||
import { DB } from '../database/database.module.js';
|
||||
|
||||
interface UserWithRole {
|
||||
id: string;
|
||||
role?: string;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class AdminGuard implements CanActivate {
|
||||
constructor(
|
||||
@Inject(AUTH) private readonly auth: Auth,
|
||||
@Inject(DB) private readonly db: Db,
|
||||
) {}
|
||||
|
||||
async canActivate(context: ExecutionContext): Promise<boolean> {
|
||||
const request = context.switchToHttp().getRequest<FastifyRequest>();
|
||||
const headers = fromNodeHeaders(request.raw.headers);
|
||||
|
||||
const result = await this.auth.api.getSession({ headers });
|
||||
|
||||
if (!result) {
|
||||
throw new UnauthorizedException('Invalid or expired session');
|
||||
}
|
||||
|
||||
const user = result.user as UserWithRole;
|
||||
|
||||
// Ensure the role field is populated. better-auth should include additionalFields
|
||||
// in the session, but as a fallback, fetch the role from the database if needed.
|
||||
let userRole = user.role;
|
||||
if (!userRole) {
|
||||
const [dbUser] = await this.db
|
||||
.select({ role: usersTable.role })
|
||||
.from(usersTable)
|
||||
.where(eq(usersTable.id, user.id))
|
||||
.limit(1);
|
||||
userRole = dbUser?.role ?? 'member';
|
||||
// Update the session user object with the fetched role
|
||||
(user as UserWithRole).role = userRole;
|
||||
}
|
||||
|
||||
if (userRole !== 'admin') {
|
||||
throw new ForbiddenException('Admin access required');
|
||||
}
|
||||
|
||||
(request as FastifyRequest & { user: unknown; session: unknown }).user = result.user;
|
||||
(request as FastifyRequest & { user: unknown; session: unknown }).session = result.session;
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { AdminController } from './admin.controller.js';
|
||||
import { AdminHealthController } from './admin-health.controller.js';
|
||||
import { AdminJobsController } from './admin-jobs.controller.js';
|
||||
import { AdminGuard } from './admin.guard.js';
|
||||
|
||||
@Module({
|
||||
controllers: [AdminController, AdminHealthController, AdminJobsController],
|
||||
providers: [AdminGuard],
|
||||
})
|
||||
export class AdminModule {}
|
||||
@@ -1,770 +0,0 @@
|
||||
/**
|
||||
* Provider Adapter Integration Tests — M3-012
|
||||
*
|
||||
* Verifies that all five provider adapters (Anthropic, OpenAI, OpenRouter, Z.ai, Ollama)
|
||||
* are properly integrated: registration, model listing, graceful degradation without
|
||||
* API keys, capability matrix correctness, and ProviderCredentialsService behaviour.
|
||||
*
|
||||
* These tests are designed to run in CI with no real API keys; they test graceful
|
||||
* degradation and static configuration rather than live network calls.
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
||||
import { ModelRegistry, AuthStorage } from '@mariozechner/pi-coding-agent';
|
||||
import { AnthropicAdapter } from '../adapters/anthropic.adapter.js';
|
||||
import { OpenAIAdapter } from '../adapters/openai.adapter.js';
|
||||
import { OpenRouterAdapter } from '../adapters/openrouter.adapter.js';
|
||||
import { ZaiAdapter } from '../adapters/zai.adapter.js';
|
||||
import { OllamaAdapter } from '../adapters/ollama.adapter.js';
|
||||
import { ProviderService } from '../provider.service.js';
|
||||
import {
|
||||
getModelCapability,
|
||||
MODEL_CAPABILITIES,
|
||||
findModelsByCapability,
|
||||
} from '../model-capabilities.js';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Environment helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const ALL_PROVIDER_KEYS = [
|
||||
'ANTHROPIC_API_KEY',
|
||||
'OPENAI_API_KEY',
|
||||
'OPENROUTER_API_KEY',
|
||||
'ZAI_API_KEY',
|
||||
'ZAI_BASE_URL',
|
||||
'OLLAMA_BASE_URL',
|
||||
'OLLAMA_HOST',
|
||||
'OLLAMA_MODELS',
|
||||
'BETTER_AUTH_SECRET',
|
||||
] as const;
|
||||
|
||||
type EnvKey = (typeof ALL_PROVIDER_KEYS)[number];
|
||||
|
||||
function saveAndClearEnv(): Map<EnvKey, string | undefined> {
|
||||
const saved = new Map<EnvKey, string | undefined>();
|
||||
for (const key of ALL_PROVIDER_KEYS) {
|
||||
saved.set(key, process.env[key]);
|
||||
delete process.env[key];
|
||||
}
|
||||
return saved;
|
||||
}
|
||||
|
||||
function restoreEnv(saved: Map<EnvKey, string | undefined>): void {
|
||||
for (const key of ALL_PROVIDER_KEYS) {
|
||||
const value = saved.get(key);
|
||||
if (value === undefined) {
|
||||
delete process.env[key];
|
||||
} else {
|
||||
process.env[key] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function makeRegistry(): ModelRegistry {
|
||||
return new ModelRegistry(AuthStorage.inMemory());
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 1. Adapter registration tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('AnthropicAdapter', () => {
|
||||
let savedEnv: Map<EnvKey, string | undefined>;
|
||||
|
||||
beforeEach(() => {
|
||||
savedEnv = saveAndClearEnv();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
restoreEnv(savedEnv);
|
||||
});
|
||||
|
||||
it('skips registration gracefully when ANTHROPIC_API_KEY is missing', async () => {
|
||||
const adapter = new AnthropicAdapter(makeRegistry());
|
||||
await expect(adapter.register()).resolves.toBeUndefined();
|
||||
expect(adapter.listModels()).toEqual([]);
|
||||
});
|
||||
|
||||
it('registers and listModels returns expected models when ANTHROPIC_API_KEY is set', async () => {
|
||||
process.env['ANTHROPIC_API_KEY'] = 'sk-ant-test';
|
||||
const adapter = new AnthropicAdapter(makeRegistry());
|
||||
await adapter.register();
|
||||
|
||||
const models = adapter.listModels();
|
||||
expect(models.length).toBeGreaterThan(0);
|
||||
|
||||
const ids = models.map((m) => m.id);
|
||||
expect(ids).toContain('claude-opus-4-6');
|
||||
expect(ids).toContain('claude-sonnet-4-6');
|
||||
expect(ids).toContain('claude-haiku-4-5');
|
||||
|
||||
for (const model of models) {
|
||||
expect(model.provider).toBe('anthropic');
|
||||
expect(model.contextWindow).toBe(200000);
|
||||
}
|
||||
});
|
||||
|
||||
it('healthCheck returns down with error when ANTHROPIC_API_KEY is missing', async () => {
|
||||
const adapter = new AnthropicAdapter(makeRegistry());
|
||||
const health = await adapter.healthCheck();
|
||||
expect(health.status).toBe('down');
|
||||
expect(health.error).toMatch(/ANTHROPIC_API_KEY/);
|
||||
expect(health.lastChecked).toBeTruthy();
|
||||
});
|
||||
|
||||
it('adapter name is "anthropic"', () => {
|
||||
expect(new AnthropicAdapter(makeRegistry()).name).toBe('anthropic');
|
||||
});
|
||||
});
|
||||
|
||||
describe('OpenAIAdapter', () => {
|
||||
let savedEnv: Map<EnvKey, string | undefined>;
|
||||
|
||||
beforeEach(() => {
|
||||
savedEnv = saveAndClearEnv();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
restoreEnv(savedEnv);
|
||||
});
|
||||
|
||||
it('skips registration gracefully when OPENAI_API_KEY is missing', async () => {
|
||||
const adapter = new OpenAIAdapter(makeRegistry());
|
||||
await expect(adapter.register()).resolves.toBeUndefined();
|
||||
expect(adapter.listModels()).toEqual([]);
|
||||
});
|
||||
|
||||
it('registers and listModels returns Codex model when OPENAI_API_KEY is set', async () => {
|
||||
process.env['OPENAI_API_KEY'] = 'sk-openai-test';
|
||||
const adapter = new OpenAIAdapter(makeRegistry());
|
||||
await adapter.register();
|
||||
|
||||
const models = adapter.listModels();
|
||||
expect(models.length).toBeGreaterThan(0);
|
||||
|
||||
const ids = models.map((m) => m.id);
|
||||
expect(ids).toContain(OpenAIAdapter.CODEX_MODEL_ID);
|
||||
|
||||
const codex = models.find((m) => m.id === OpenAIAdapter.CODEX_MODEL_ID)!;
|
||||
expect(codex.provider).toBe('openai');
|
||||
expect(codex.contextWindow).toBe(128_000);
|
||||
expect(codex.maxTokens).toBe(16_384);
|
||||
});
|
||||
|
||||
it('healthCheck returns down with error when OPENAI_API_KEY is missing', async () => {
|
||||
const adapter = new OpenAIAdapter(makeRegistry());
|
||||
const health = await adapter.healthCheck();
|
||||
expect(health.status).toBe('down');
|
||||
expect(health.error).toMatch(/OPENAI_API_KEY/);
|
||||
});
|
||||
|
||||
it('adapter name is "openai"', () => {
|
||||
expect(new OpenAIAdapter(makeRegistry()).name).toBe('openai');
|
||||
});
|
||||
});
|
||||
|
||||
describe('OpenRouterAdapter', () => {
|
||||
let savedEnv: Map<EnvKey, string | undefined>;
|
||||
|
||||
beforeEach(() => {
|
||||
savedEnv = saveAndClearEnv();
|
||||
// Prevent real network calls during registration — stub global fetch
|
||||
vi.stubGlobal(
|
||||
'fetch',
|
||||
vi.fn().mockResolvedValue({
|
||||
ok: true,
|
||||
json: () =>
|
||||
Promise.resolve({
|
||||
data: [
|
||||
{
|
||||
id: 'openai/gpt-4o',
|
||||
name: 'GPT-4o',
|
||||
context_length: 128000,
|
||||
top_provider: { max_completion_tokens: 4096 },
|
||||
pricing: { prompt: '0.000005', completion: '0.000015' },
|
||||
architecture: { input_modalities: ['text', 'image'] },
|
||||
},
|
||||
],
|
||||
}),
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
restoreEnv(savedEnv);
|
||||
vi.unstubAllGlobals();
|
||||
});
|
||||
|
||||
it('skips registration gracefully when OPENROUTER_API_KEY is missing', async () => {
|
||||
vi.unstubAllGlobals(); // no fetch call expected
|
||||
const adapter = new OpenRouterAdapter();
|
||||
await expect(adapter.register()).resolves.toBeUndefined();
|
||||
expect(adapter.listModels()).toEqual([]);
|
||||
});
|
||||
|
||||
it('registers and listModels returns models when OPENROUTER_API_KEY is set', async () => {
|
||||
process.env['OPENROUTER_API_KEY'] = 'sk-or-test';
|
||||
const adapter = new OpenRouterAdapter();
|
||||
await adapter.register();
|
||||
|
||||
const models = adapter.listModels();
|
||||
expect(models.length).toBeGreaterThan(0);
|
||||
|
||||
const first = models[0]!;
|
||||
expect(first.provider).toBe('openrouter');
|
||||
expect(first.id).toBe('openai/gpt-4o');
|
||||
expect(first.inputTypes).toContain('image');
|
||||
});
|
||||
|
||||
it('healthCheck returns down with error when OPENROUTER_API_KEY is missing', async () => {
|
||||
vi.unstubAllGlobals(); // no fetch call expected
|
||||
const adapter = new OpenRouterAdapter();
|
||||
const health = await adapter.healthCheck();
|
||||
expect(health.status).toBe('down');
|
||||
expect(health.error).toMatch(/OPENROUTER_API_KEY/);
|
||||
});
|
||||
|
||||
it('continues registration with empty model list when model fetch fails', async () => {
|
||||
process.env['OPENROUTER_API_KEY'] = 'sk-or-test';
|
||||
vi.stubGlobal(
|
||||
'fetch',
|
||||
vi.fn().mockResolvedValue({
|
||||
ok: false,
|
||||
status: 500,
|
||||
}),
|
||||
);
|
||||
const adapter = new OpenRouterAdapter();
|
||||
await expect(adapter.register()).resolves.toBeUndefined();
|
||||
expect(adapter.listModels()).toEqual([]);
|
||||
});
|
||||
|
||||
it('adapter name is "openrouter"', () => {
|
||||
expect(new OpenRouterAdapter().name).toBe('openrouter');
|
||||
});
|
||||
});
|
||||
|
||||
describe('ZaiAdapter', () => {
|
||||
let savedEnv: Map<EnvKey, string | undefined>;
|
||||
|
||||
beforeEach(() => {
|
||||
savedEnv = saveAndClearEnv();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
restoreEnv(savedEnv);
|
||||
});
|
||||
|
||||
it('skips registration gracefully when ZAI_API_KEY is missing', async () => {
|
||||
const adapter = new ZaiAdapter();
|
||||
await expect(adapter.register()).resolves.toBeUndefined();
|
||||
expect(adapter.listModels()).toEqual([]);
|
||||
});
|
||||
|
||||
it('registers and listModels returns glm-5 when ZAI_API_KEY is set', async () => {
|
||||
process.env['ZAI_API_KEY'] = 'zai-test-key';
|
||||
const adapter = new ZaiAdapter();
|
||||
await adapter.register();
|
||||
|
||||
const models = adapter.listModels();
|
||||
expect(models.length).toBeGreaterThan(0);
|
||||
|
||||
const ids = models.map((m) => m.id);
|
||||
expect(ids).toContain('glm-5');
|
||||
|
||||
const glm = models.find((m) => m.id === 'glm-5')!;
|
||||
expect(glm.provider).toBe('zai');
|
||||
});
|
||||
|
||||
it('healthCheck returns down with error when ZAI_API_KEY is missing', async () => {
|
||||
const adapter = new ZaiAdapter();
|
||||
const health = await adapter.healthCheck();
|
||||
expect(health.status).toBe('down');
|
||||
expect(health.error).toMatch(/ZAI_API_KEY/);
|
||||
});
|
||||
|
||||
it('adapter name is "zai"', () => {
|
||||
expect(new ZaiAdapter().name).toBe('zai');
|
||||
});
|
||||
});
|
||||
|
||||
describe('OllamaAdapter', () => {
|
||||
let savedEnv: Map<EnvKey, string | undefined>;
|
||||
|
||||
beforeEach(() => {
|
||||
savedEnv = saveAndClearEnv();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
restoreEnv(savedEnv);
|
||||
});
|
||||
|
||||
it('skips registration gracefully when OLLAMA_BASE_URL is missing', async () => {
|
||||
const adapter = new OllamaAdapter(makeRegistry());
|
||||
await expect(adapter.register()).resolves.toBeUndefined();
|
||||
expect(adapter.listModels()).toEqual([]);
|
||||
});
|
||||
|
||||
it('registers via OLLAMA_HOST fallback when OLLAMA_BASE_URL is absent', async () => {
|
||||
process.env['OLLAMA_HOST'] = 'http://localhost:11434';
|
||||
const adapter = new OllamaAdapter(makeRegistry());
|
||||
await adapter.register();
|
||||
const models = adapter.listModels();
|
||||
expect(models.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('registers default models (llama3.2, codellama, mistral) + embedding models', async () => {
|
||||
process.env['OLLAMA_BASE_URL'] = 'http://localhost:11434';
|
||||
const adapter = new OllamaAdapter(makeRegistry());
|
||||
await adapter.register();
|
||||
|
||||
const models = adapter.listModels();
|
||||
const ids = models.map((m) => m.id);
|
||||
|
||||
// Default completion models
|
||||
expect(ids).toContain('llama3.2');
|
||||
expect(ids).toContain('codellama');
|
||||
expect(ids).toContain('mistral');
|
||||
|
||||
// Embedding models
|
||||
expect(ids).toContain('nomic-embed-text');
|
||||
expect(ids).toContain('mxbai-embed-large');
|
||||
|
||||
for (const model of models) {
|
||||
expect(model.provider).toBe('ollama');
|
||||
}
|
||||
});
|
||||
|
||||
it('registers custom OLLAMA_MODELS list', async () => {
|
||||
process.env['OLLAMA_BASE_URL'] = 'http://localhost:11434';
|
||||
process.env['OLLAMA_MODELS'] = 'phi3,gemma2';
|
||||
const adapter = new OllamaAdapter(makeRegistry());
|
||||
await adapter.register();
|
||||
|
||||
const completionIds = adapter.listModels().map((m) => m.id);
|
||||
expect(completionIds).toContain('phi3');
|
||||
expect(completionIds).toContain('gemma2');
|
||||
expect(completionIds).not.toContain('llama3.2');
|
||||
});
|
||||
|
||||
it('healthCheck returns down with error when OLLAMA_BASE_URL is missing', async () => {
|
||||
const adapter = new OllamaAdapter(makeRegistry());
|
||||
const health = await adapter.healthCheck();
|
||||
expect(health.status).toBe('down');
|
||||
expect(health.error).toMatch(/OLLAMA_BASE_URL/);
|
||||
});
|
||||
|
||||
it('adapter name is "ollama"', () => {
|
||||
expect(new OllamaAdapter(makeRegistry()).name).toBe('ollama');
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 2. ProviderService integration
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('ProviderService — adapter array integration', () => {
|
||||
let savedEnv: Map<EnvKey, string | undefined>;
|
||||
|
||||
beforeEach(() => {
|
||||
savedEnv = saveAndClearEnv();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
restoreEnv(savedEnv);
|
||||
});
|
||||
|
||||
it('contains all 5 adapters (ollama, anthropic, openai, openrouter, zai)', async () => {
|
||||
const service = new ProviderService(null);
|
||||
await service.onModuleInit();
|
||||
|
||||
// Exercise getAdapter for all five known provider names
|
||||
const expectedProviders = ['ollama', 'anthropic', 'openai', 'openrouter', 'zai'];
|
||||
for (const name of expectedProviders) {
|
||||
const adapter = service.getAdapter(name);
|
||||
expect(adapter, `Expected adapter "${name}" to be registered`).toBeDefined();
|
||||
expect(adapter!.name).toBe(name);
|
||||
}
|
||||
});
|
||||
|
||||
it('healthCheckAll runs without crashing and returns status for all 5 providers', async () => {
|
||||
const service = new ProviderService(null);
|
||||
await service.onModuleInit();
|
||||
|
||||
const results = await service.healthCheckAll();
|
||||
expect(typeof results).toBe('object');
|
||||
|
||||
const expectedProviders = ['ollama', 'anthropic', 'openai', 'openrouter', 'zai'];
|
||||
for (const name of expectedProviders) {
|
||||
const health = results[name];
|
||||
expect(health, `Expected health result for provider "${name}"`).toBeDefined();
|
||||
expect(['healthy', 'degraded', 'down']).toContain(health!.status);
|
||||
expect(health!.lastChecked).toBeTruthy();
|
||||
}
|
||||
});
|
||||
|
||||
it('healthCheckAll reports "down" for all providers when no keys are set', async () => {
|
||||
const service = new ProviderService(null);
|
||||
await service.onModuleInit();
|
||||
|
||||
const results = await service.healthCheckAll();
|
||||
// All unconfigured providers should be down (not healthy)
|
||||
for (const [, health] of Object.entries(results)) {
|
||||
expect(['down', 'degraded']).toContain(health.status);
|
||||
}
|
||||
});
|
||||
|
||||
it('getProvidersHealth returns entries for all 5 providers', async () => {
|
||||
const service = new ProviderService(null);
|
||||
await service.onModuleInit();
|
||||
|
||||
const healthList = service.getProvidersHealth();
|
||||
const names = healthList.map((h) => h.name);
|
||||
|
||||
for (const expected of ['ollama', 'anthropic', 'openai', 'openrouter', 'zai']) {
|
||||
expect(names).toContain(expected);
|
||||
}
|
||||
|
||||
for (const entry of healthList) {
|
||||
expect(entry).toHaveProperty('name');
|
||||
expect(entry).toHaveProperty('status');
|
||||
expect(entry).toHaveProperty('lastChecked');
|
||||
expect(typeof entry.modelCount).toBe('number');
|
||||
}
|
||||
});
|
||||
|
||||
it('service initialises without error when all env keys are absent', async () => {
|
||||
const service = new ProviderService(null);
|
||||
await expect(service.onModuleInit()).resolves.toBeUndefined();
|
||||
service.onModuleDestroy();
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 3. Model capability matrix
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('Model capability matrix', () => {
|
||||
const expectedModels: Array<{
|
||||
id: string;
|
||||
provider: string;
|
||||
tier: string;
|
||||
contextWindow: number;
|
||||
reasoning?: boolean;
|
||||
vision?: boolean;
|
||||
embedding?: boolean;
|
||||
}> = [
|
||||
{
|
||||
id: 'claude-opus-4-6',
|
||||
provider: 'anthropic',
|
||||
tier: 'premium',
|
||||
contextWindow: 200000,
|
||||
reasoning: true,
|
||||
vision: true,
|
||||
},
|
||||
{
|
||||
id: 'claude-sonnet-4-6',
|
||||
provider: 'anthropic',
|
||||
tier: 'standard',
|
||||
contextWindow: 200000,
|
||||
reasoning: true,
|
||||
vision: true,
|
||||
},
|
||||
{
|
||||
id: 'claude-haiku-4-5',
|
||||
provider: 'anthropic',
|
||||
tier: 'cheap',
|
||||
contextWindow: 200000,
|
||||
reasoning: false,
|
||||
vision: true,
|
||||
},
|
||||
{
|
||||
id: 'codex-gpt-5.4',
|
||||
provider: 'openai',
|
||||
tier: 'premium',
|
||||
contextWindow: 128000,
|
||||
},
|
||||
{
|
||||
id: 'glm-5',
|
||||
provider: 'zai',
|
||||
tier: 'standard',
|
||||
contextWindow: 128000,
|
||||
},
|
||||
{
|
||||
id: 'llama3.2',
|
||||
provider: 'ollama',
|
||||
tier: 'local',
|
||||
contextWindow: 128000,
|
||||
},
|
||||
{
|
||||
id: 'codellama',
|
||||
provider: 'ollama',
|
||||
tier: 'local',
|
||||
contextWindow: 16000,
|
||||
},
|
||||
{
|
||||
id: 'mistral',
|
||||
provider: 'ollama',
|
||||
tier: 'local',
|
||||
contextWindow: 32000,
|
||||
},
|
||||
{
|
||||
id: 'nomic-embed-text',
|
||||
provider: 'ollama',
|
||||
tier: 'local',
|
||||
contextWindow: 8192,
|
||||
embedding: true,
|
||||
},
|
||||
{
|
||||
id: 'mxbai-embed-large',
|
||||
provider: 'ollama',
|
||||
tier: 'local',
|
||||
contextWindow: 8192,
|
||||
embedding: true,
|
||||
},
|
||||
];
|
||||
|
||||
it('MODEL_CAPABILITIES contains all expected model IDs', () => {
|
||||
const allIds = MODEL_CAPABILITIES.map((m) => m.id);
|
||||
for (const { id } of expectedModels) {
|
||||
expect(allIds, `Expected model "${id}" in capability matrix`).toContain(id);
|
||||
}
|
||||
});
|
||||
|
||||
it('getModelCapability() returns correct tier and context window for each model', () => {
|
||||
for (const expected of expectedModels) {
|
||||
const cap = getModelCapability(expected.id);
|
||||
expect(cap, `getModelCapability("${expected.id}") should be defined`).toBeDefined();
|
||||
expect(cap!.provider).toBe(expected.provider);
|
||||
expect(cap!.tier).toBe(expected.tier);
|
||||
expect(cap!.contextWindow).toBe(expected.contextWindow);
|
||||
}
|
||||
});
|
||||
|
||||
it('Anthropic models have correct capability flags (tools, streaming, vision, reasoning)', () => {
|
||||
for (const expected of expectedModels.filter((m) => m.provider === 'anthropic')) {
|
||||
const cap = getModelCapability(expected.id)!;
|
||||
expect(cap.capabilities.tools).toBe(true);
|
||||
expect(cap.capabilities.streaming).toBe(true);
|
||||
if (expected.vision !== undefined) {
|
||||
expect(cap.capabilities.vision).toBe(expected.vision);
|
||||
}
|
||||
if (expected.reasoning !== undefined) {
|
||||
expect(cap.capabilities.reasoning).toBe(expected.reasoning);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('Embedding models have embedding flag=true and other flags=false', () => {
|
||||
for (const expected of expectedModels.filter((m) => m.embedding)) {
|
||||
const cap = getModelCapability(expected.id)!;
|
||||
expect(cap.capabilities.embedding).toBe(true);
|
||||
expect(cap.capabilities.tools).toBe(false);
|
||||
expect(cap.capabilities.streaming).toBe(false);
|
||||
expect(cap.capabilities.reasoning).toBe(false);
|
||||
}
|
||||
});
|
||||
|
||||
it('findModelsByCapability filters by tier correctly', () => {
|
||||
const premiumModels = findModelsByCapability({ tier: 'premium' });
|
||||
expect(premiumModels.length).toBeGreaterThan(0);
|
||||
for (const m of premiumModels) {
|
||||
expect(m.tier).toBe('premium');
|
||||
}
|
||||
});
|
||||
|
||||
it('findModelsByCapability filters by provider correctly', () => {
|
||||
const anthropicModels = findModelsByCapability({ provider: 'anthropic' });
|
||||
expect(anthropicModels.length).toBe(3);
|
||||
for (const m of anthropicModels) {
|
||||
expect(m.provider).toBe('anthropic');
|
||||
}
|
||||
});
|
||||
|
||||
it('findModelsByCapability filters by capability flags correctly', () => {
|
||||
const reasoningModels = findModelsByCapability({ capabilities: { reasoning: true } });
|
||||
expect(reasoningModels.length).toBeGreaterThan(0);
|
||||
for (const m of reasoningModels) {
|
||||
expect(m.capabilities.reasoning).toBe(true);
|
||||
}
|
||||
|
||||
const embeddingModels = findModelsByCapability({ capabilities: { embedding: true } });
|
||||
expect(embeddingModels.length).toBeGreaterThan(0);
|
||||
for (const m of embeddingModels) {
|
||||
expect(m.capabilities.embedding).toBe(true);
|
||||
}
|
||||
});
|
||||
|
||||
it('getModelCapability returns undefined for unknown model IDs', () => {
|
||||
expect(getModelCapability('not-a-real-model')).toBeUndefined();
|
||||
expect(getModelCapability('')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('all Anthropic models have maxOutputTokens > 0', () => {
|
||||
const anthropicModels = MODEL_CAPABILITIES.filter((m) => m.provider === 'anthropic');
|
||||
for (const m of anthropicModels) {
|
||||
expect(m.maxOutputTokens).toBeGreaterThan(0);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 4. ProviderCredentialsService — unit-level tests (encrypt/decrypt logic)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('ProviderCredentialsService — encryption helpers', () => {
|
||||
let savedEnv: Map<EnvKey, string | undefined>;
|
||||
|
||||
beforeEach(() => {
|
||||
savedEnv = saveAndClearEnv();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
restoreEnv(savedEnv);
|
||||
});
|
||||
|
||||
/**
|
||||
* The service uses module-level functions (encrypt/decrypt) that depend on
|
||||
* BETTER_AUTH_SECRET. We test the behaviour through the service's public API
|
||||
* using an in-memory mock DB so no real Postgres connection is needed.
|
||||
*/
|
||||
it('store/retrieve/remove work correctly with mock DB and BETTER_AUTH_SECRET set', async () => {
|
||||
process.env['BETTER_AUTH_SECRET'] = 'test-secret-for-unit-tests-only';
|
||||
|
||||
// Build a minimal in-memory DB mock
|
||||
const rows = new Map<
|
||||
string,
|
||||
{
|
||||
encryptedValue: string;
|
||||
credentialType: string;
|
||||
expiresAt: Date | null;
|
||||
metadata: null;
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
>();
|
||||
|
||||
// We import the service but mock its DB dependency manually
|
||||
// by testing the encrypt/decrypt indirectly — using the real module.
|
||||
const { ProviderCredentialsService } = await import('../provider-credentials.service.js');
|
||||
|
||||
// Capture stored value from upsert call
|
||||
let storedEncryptedValue = '';
|
||||
let storedCredentialType = '';
|
||||
const captureInsert = vi.fn().mockImplementation(() => ({
|
||||
values: vi
|
||||
.fn()
|
||||
.mockImplementation((data: { encryptedValue: string; credentialType: string }) => {
|
||||
storedEncryptedValue = data.encryptedValue;
|
||||
storedCredentialType = data.credentialType;
|
||||
rows.set('user1:anthropic', {
|
||||
encryptedValue: data.encryptedValue,
|
||||
credentialType: data.credentialType,
|
||||
expiresAt: null,
|
||||
metadata: null,
|
||||
createdAt: new Date(),
|
||||
updatedAt: new Date(),
|
||||
});
|
||||
return {
|
||||
onConflictDoUpdate: vi.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
}),
|
||||
}));
|
||||
|
||||
const captureSelect = vi.fn().mockReturnValue({
|
||||
from: vi.fn().mockReturnValue({
|
||||
where: vi.fn().mockReturnValue({
|
||||
limit: vi.fn().mockImplementation(() => {
|
||||
const row = rows.get('user1:anthropic');
|
||||
return Promise.resolve(row ? [row] : []);
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
});
|
||||
|
||||
const captureDelete = vi.fn().mockReturnValue({
|
||||
where: vi.fn().mockResolvedValue(undefined),
|
||||
});
|
||||
|
||||
const db = {
|
||||
insert: captureInsert,
|
||||
select: captureSelect,
|
||||
delete: captureDelete,
|
||||
};
|
||||
|
||||
const service = new ProviderCredentialsService(db as never);
|
||||
|
||||
// store
|
||||
await service.store('user1', 'anthropic', 'api_key', 'sk-ant-secret-value');
|
||||
|
||||
// verify encrypted value is not plain text
|
||||
expect(storedEncryptedValue).not.toBe('sk-ant-secret-value');
|
||||
expect(storedEncryptedValue.length).toBeGreaterThan(0);
|
||||
expect(storedCredentialType).toBe('api_key');
|
||||
|
||||
// retrieve
|
||||
const retrieved = await service.retrieve('user1', 'anthropic');
|
||||
expect(retrieved).toBe('sk-ant-secret-value');
|
||||
|
||||
// remove (clears the row)
|
||||
rows.delete('user1:anthropic');
|
||||
const afterRemove = await service.retrieve('user1', 'anthropic');
|
||||
expect(afterRemove).toBeNull();
|
||||
});
|
||||
|
||||
it('retrieve returns null when no credential is stored', async () => {
|
||||
process.env['BETTER_AUTH_SECRET'] = 'test-secret-for-unit-tests-only';
|
||||
|
||||
const { ProviderCredentialsService } = await import('../provider-credentials.service.js');
|
||||
|
||||
const emptyDb = {
|
||||
select: vi.fn().mockReturnValue({
|
||||
from: vi.fn().mockReturnValue({
|
||||
where: vi.fn().mockReturnValue({
|
||||
limit: vi.fn().mockResolvedValue([]),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
|
||||
const service = new ProviderCredentialsService(emptyDb as never);
|
||||
const result = await service.retrieve('user-nobody', 'anthropic');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
it('listProviders returns only metadata, never decrypted values', async () => {
|
||||
process.env['BETTER_AUTH_SECRET'] = 'test-secret-for-unit-tests-only';
|
||||
|
||||
const { ProviderCredentialsService } = await import('../provider-credentials.service.js');
|
||||
|
||||
const fakeRow = {
|
||||
provider: 'anthropic',
|
||||
credentialType: 'api_key',
|
||||
expiresAt: null,
|
||||
metadata: null,
|
||||
createdAt: new Date(),
|
||||
updatedAt: new Date(),
|
||||
};
|
||||
|
||||
const listDb = {
|
||||
select: vi.fn().mockReturnValue({
|
||||
from: vi.fn().mockReturnValue({
|
||||
where: vi.fn().mockResolvedValue([fakeRow]),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
|
||||
const service = new ProviderCredentialsService(listDb as never);
|
||||
const providers = await service.listProviders('user1');
|
||||
|
||||
expect(providers).toHaveLength(1);
|
||||
expect(providers[0]!.provider).toBe('anthropic');
|
||||
expect(providers[0]!.credentialType).toBe('api_key');
|
||||
expect(providers[0]!.exists).toBe(true);
|
||||
|
||||
// Critically: no encrypted or plain-text value is exposed
|
||||
expect(providers[0]).not.toHaveProperty('encryptedValue');
|
||||
expect(providers[0]).not.toHaveProperty('value');
|
||||
expect(providers[0]).not.toHaveProperty('apiKey');
|
||||
});
|
||||
});
|
||||
@@ -1,142 +0,0 @@
|
||||
import { beforeEach, afterEach, describe, expect, it } from 'vitest';
|
||||
import { ProviderService } from '../provider.service.js';
|
||||
|
||||
const ENV_KEYS = [
|
||||
'ANTHROPIC_API_KEY',
|
||||
'OPENAI_API_KEY',
|
||||
'ZAI_API_KEY',
|
||||
'OLLAMA_BASE_URL',
|
||||
'OLLAMA_HOST',
|
||||
'OLLAMA_MODELS',
|
||||
'MOSAIC_CUSTOM_PROVIDERS',
|
||||
] as const;
|
||||
|
||||
type EnvKey = (typeof ENV_KEYS)[number];
|
||||
|
||||
describe('ProviderService', () => {
|
||||
const savedEnv = new Map<EnvKey, string | undefined>();
|
||||
|
||||
beforeEach(() => {
|
||||
for (const key of ENV_KEYS) {
|
||||
savedEnv.set(key, process.env[key]);
|
||||
delete process.env[key];
|
||||
}
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
for (const key of ENV_KEYS) {
|
||||
const value = savedEnv.get(key);
|
||||
if (value === undefined) {
|
||||
delete process.env[key];
|
||||
} else {
|
||||
process.env[key] = value;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('skips API-key providers when env vars are missing (no models become available)', async () => {
|
||||
const service = new ProviderService(null);
|
||||
await service.onModuleInit();
|
||||
|
||||
// Pi's built-in registry may include model definitions for all providers, but
|
||||
// without API keys none of them should be available (usable).
|
||||
const availableModels = service.listAvailableModels();
|
||||
const availableProviderIds = new Set(availableModels.map((m) => m.provider));
|
||||
|
||||
expect(availableProviderIds).not.toContain('anthropic');
|
||||
expect(availableProviderIds).not.toContain('openai');
|
||||
expect(availableProviderIds).not.toContain('zai');
|
||||
|
||||
// Providers list may show built-in providers, but they should not be marked available
|
||||
const providers = service.listProviders();
|
||||
for (const p of providers.filter((p) => ['anthropic', 'openai', 'zai'].includes(p.id))) {
|
||||
expect(p.available).toBe(false);
|
||||
}
|
||||
});
|
||||
|
||||
it('registers Anthropic provider with correct models when ANTHROPIC_API_KEY is set', async () => {
|
||||
process.env['ANTHROPIC_API_KEY'] = 'test-anthropic';
|
||||
|
||||
const service = new ProviderService(null);
|
||||
await service.onModuleInit();
|
||||
|
||||
const providers = service.listProviders();
|
||||
const anthropic = providers.find((p) => p.id === 'anthropic');
|
||||
expect(anthropic).toBeDefined();
|
||||
expect(anthropic!.available).toBe(true);
|
||||
expect(anthropic!.models.map((m) => m.id)).toEqual([
|
||||
'claude-opus-4-6',
|
||||
'claude-sonnet-4-6',
|
||||
'claude-haiku-4-5',
|
||||
]);
|
||||
// All Anthropic models have 200k context window
|
||||
for (const m of anthropic!.models) {
|
||||
expect(m.contextWindow).toBe(200000);
|
||||
}
|
||||
});
|
||||
|
||||
it('registers OpenAI provider with correct models when OPENAI_API_KEY is set', async () => {
|
||||
process.env['OPENAI_API_KEY'] = 'test-openai';
|
||||
|
||||
const service = new ProviderService(null);
|
||||
await service.onModuleInit();
|
||||
|
||||
const providers = service.listProviders();
|
||||
const openai = providers.find((p) => p.id === 'openai');
|
||||
expect(openai).toBeDefined();
|
||||
expect(openai!.available).toBe(true);
|
||||
expect(openai!.models.map((m) => m.id)).toEqual(['codex-gpt-5-4']);
|
||||
});
|
||||
|
||||
it('registers Z.ai provider with correct models when ZAI_API_KEY is set', async () => {
|
||||
process.env['ZAI_API_KEY'] = 'test-zai';
|
||||
|
||||
const service = new ProviderService(null);
|
||||
await service.onModuleInit();
|
||||
|
||||
const providers = service.listProviders();
|
||||
const zai = providers.find((p) => p.id === 'zai');
|
||||
expect(zai).toBeDefined();
|
||||
expect(zai!.available).toBe(true);
|
||||
// Pi's registry may include additional glm variants; verify our registered model is present
|
||||
expect(zai!.models.map((m) => m.id)).toContain('glm-5');
|
||||
});
|
||||
|
||||
it('registers all three providers when all keys are set', async () => {
|
||||
process.env['ANTHROPIC_API_KEY'] = 'test-anthropic';
|
||||
process.env['OPENAI_API_KEY'] = 'test-openai';
|
||||
process.env['ZAI_API_KEY'] = 'test-zai';
|
||||
|
||||
const service = new ProviderService(null);
|
||||
await service.onModuleInit();
|
||||
|
||||
const providerIds = service.listProviders().map((p) => p.id);
|
||||
expect(providerIds).toContain('anthropic');
|
||||
expect(providerIds).toContain('openai');
|
||||
expect(providerIds).toContain('zai');
|
||||
});
|
||||
|
||||
it('can find registered Anthropic models by provider+id', async () => {
|
||||
process.env['ANTHROPIC_API_KEY'] = 'test-anthropic';
|
||||
|
||||
const service = new ProviderService(null);
|
||||
await service.onModuleInit();
|
||||
|
||||
const sonnet = service.findModel('anthropic', 'claude-sonnet-4-6');
|
||||
expect(sonnet).toBeDefined();
|
||||
expect(sonnet!.provider).toBe('anthropic');
|
||||
expect(sonnet!.id).toBe('claude-sonnet-4-6');
|
||||
});
|
||||
|
||||
it('can find registered Z.ai models by provider+id', async () => {
|
||||
process.env['ZAI_API_KEY'] = 'test-zai';
|
||||
|
||||
const service = new ProviderService(null);
|
||||
await service.onModuleInit();
|
||||
|
||||
const glm = service.findModel('zai', 'glm-4.5');
|
||||
expect(glm).toBeDefined();
|
||||
expect(glm!.provider).toBe('zai');
|
||||
expect(glm!.id).toBe('glm-4.5');
|
||||
});
|
||||
});
|
||||
@@ -1,191 +0,0 @@
|
||||
import { Logger } from '@nestjs/common';
|
||||
import Anthropic from '@anthropic-ai/sdk';
|
||||
import type { ModelRegistry } from '@mariozechner/pi-coding-agent';
|
||||
import type {
|
||||
CompletionEvent,
|
||||
CompletionParams,
|
||||
IProviderAdapter,
|
||||
ModelInfo,
|
||||
ProviderHealth,
|
||||
} from '@mosaic/types';
|
||||
|
||||
/**
|
||||
* Anthropic provider adapter.
|
||||
*
|
||||
* Registers Claude models with the Pi ModelRegistry via the Anthropic SDK.
|
||||
* Configuration is driven by environment variables:
|
||||
* ANTHROPIC_API_KEY — Anthropic API key (required)
|
||||
*/
|
||||
export class AnthropicAdapter implements IProviderAdapter {
|
||||
readonly name = 'anthropic';
|
||||
|
||||
private readonly logger = new Logger(AnthropicAdapter.name);
|
||||
private client: Anthropic | null = null;
|
||||
private registeredModels: ModelInfo[] = [];
|
||||
|
||||
constructor(private readonly registry: ModelRegistry) {}
|
||||
|
||||
async register(): Promise<void> {
|
||||
const apiKey = process.env['ANTHROPIC_API_KEY'];
|
||||
if (!apiKey) {
|
||||
this.logger.warn('Skipping Anthropic provider registration: ANTHROPIC_API_KEY not set');
|
||||
return;
|
||||
}
|
||||
|
||||
this.client = new Anthropic({ apiKey });
|
||||
|
||||
const models: ModelInfo[] = [
|
||||
{
|
||||
id: 'claude-opus-4-6',
|
||||
provider: 'anthropic',
|
||||
name: 'Claude Opus 4.6',
|
||||
reasoning: true,
|
||||
contextWindow: 200000,
|
||||
maxTokens: 32000,
|
||||
inputTypes: ['text', 'image'],
|
||||
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
|
||||
},
|
||||
{
|
||||
id: 'claude-sonnet-4-6',
|
||||
provider: 'anthropic',
|
||||
name: 'Claude Sonnet 4.6',
|
||||
reasoning: true,
|
||||
contextWindow: 200000,
|
||||
maxTokens: 16000,
|
||||
inputTypes: ['text', 'image'],
|
||||
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
|
||||
},
|
||||
{
|
||||
id: 'claude-haiku-4-5',
|
||||
provider: 'anthropic',
|
||||
name: 'Claude Haiku 4.5',
|
||||
reasoning: false,
|
||||
contextWindow: 200000,
|
||||
maxTokens: 8192,
|
||||
inputTypes: ['text', 'image'],
|
||||
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
|
||||
},
|
||||
];
|
||||
|
||||
this.registry.registerProvider('anthropic', {
|
||||
apiKey,
|
||||
baseUrl: 'https://api.anthropic.com',
|
||||
api: 'anthropic' as never,
|
||||
models: models.map((m) => ({
|
||||
id: m.id,
|
||||
name: m.name,
|
||||
reasoning: m.reasoning,
|
||||
input: m.inputTypes as ('text' | 'image')[],
|
||||
cost: m.cost,
|
||||
contextWindow: m.contextWindow,
|
||||
maxTokens: m.maxTokens,
|
||||
})),
|
||||
});
|
||||
|
||||
this.registeredModels = models;
|
||||
|
||||
this.logger.log(
|
||||
`Anthropic provider registered with models: ${models.map((m) => m.id).join(', ')}`,
|
||||
);
|
||||
}
|
||||
|
||||
listModels(): ModelInfo[] {
|
||||
return this.registeredModels;
|
||||
}
|
||||
|
||||
async healthCheck(): Promise<ProviderHealth> {
|
||||
const apiKey = process.env['ANTHROPIC_API_KEY'];
|
||||
if (!apiKey) {
|
||||
return {
|
||||
status: 'down',
|
||||
lastChecked: new Date().toISOString(),
|
||||
error: 'ANTHROPIC_API_KEY not configured',
|
||||
};
|
||||
}
|
||||
|
||||
const start = Date.now();
|
||||
|
||||
try {
|
||||
const client = this.client ?? new Anthropic({ apiKey });
|
||||
await client.models.list({ limit: 1 });
|
||||
const latencyMs = Date.now() - start;
|
||||
return { status: 'healthy', latencyMs, lastChecked: new Date().toISOString() };
|
||||
} catch (err) {
|
||||
const latencyMs = Date.now() - start;
|
||||
const error = err instanceof Error ? err.message : String(err);
|
||||
const status = error.includes('401') || error.includes('403') ? 'degraded' : 'down';
|
||||
return { status, latencyMs, lastChecked: new Date().toISOString(), error };
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stream a completion from Anthropic using the messages API.
|
||||
* Maps Anthropic streaming events to the CompletionEvent format.
|
||||
*
|
||||
* Note: Currently reserved for future direct-completion use. The Pi SDK
|
||||
* integration routes completions through ModelRegistry / AgentSession.
|
||||
*/
|
||||
async *createCompletion(params: CompletionParams): AsyncIterable<CompletionEvent> {
|
||||
const apiKey = process.env['ANTHROPIC_API_KEY'];
|
||||
if (!apiKey) {
|
||||
throw new Error('AnthropicAdapter: ANTHROPIC_API_KEY not configured');
|
||||
}
|
||||
|
||||
const client = this.client ?? new Anthropic({ apiKey });
|
||||
|
||||
// Separate system messages from user/assistant messages
|
||||
const systemMessages = params.messages.filter((m) => m.role === 'system');
|
||||
const conversationMessages = params.messages.filter((m) => m.role !== 'system');
|
||||
|
||||
const systemPrompt =
|
||||
systemMessages.length > 0 ? systemMessages.map((m) => m.content).join('\n') : undefined;
|
||||
|
||||
const stream = await client.messages.stream({
|
||||
model: params.model,
|
||||
max_tokens: params.maxTokens ?? 1024,
|
||||
...(systemPrompt !== undefined ? { system: systemPrompt } : {}),
|
||||
messages: conversationMessages.map((m) => ({
|
||||
role: m.role as 'user' | 'assistant',
|
||||
content: m.content,
|
||||
})),
|
||||
...(params.temperature !== undefined ? { temperature: params.temperature } : {}),
|
||||
...(params.tools && params.tools.length > 0
|
||||
? {
|
||||
tools: params.tools.map((t) => ({
|
||||
name: t.name,
|
||||
description: t.description,
|
||||
input_schema: t.parameters as Anthropic.Tool['input_schema'],
|
||||
})),
|
||||
}
|
||||
: {}),
|
||||
});
|
||||
|
||||
for await (const event of stream) {
|
||||
if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
|
||||
yield { type: 'text_delta', content: event.delta.text };
|
||||
} else if (event.type === 'content_block_delta' && event.delta.type === 'input_json_delta') {
|
||||
yield { type: 'tool_call', name: '', arguments: event.delta.partial_json };
|
||||
} else if (event.type === 'message_delta' && event.usage) {
|
||||
yield {
|
||||
type: 'done',
|
||||
usage: {
|
||||
inputTokens:
|
||||
(event as { usage: { input_tokens?: number; output_tokens: number } }).usage
|
||||
.input_tokens ?? 0,
|
||||
outputTokens: event.usage.output_tokens,
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Emit final done event with full usage from the completed message
|
||||
const finalMessage = await stream.finalMessage();
|
||||
yield {
|
||||
type: 'done',
|
||||
usage: {
|
||||
inputTokens: finalMessage.usage.input_tokens,
|
||||
outputTokens: finalMessage.usage.output_tokens,
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
export { OllamaAdapter } from './ollama.adapter.js';
|
||||
export { AnthropicAdapter } from './anthropic.adapter.js';
|
||||
export { OpenAIAdapter } from './openai.adapter.js';
|
||||
export { OpenRouterAdapter } from './openrouter.adapter.js';
|
||||
export { ZaiAdapter } from './zai.adapter.js';
|
||||
@@ -1,197 +0,0 @@
|
||||
import { Logger } from '@nestjs/common';
|
||||
import type { ModelRegistry } from '@mariozechner/pi-coding-agent';
|
||||
import type {
|
||||
CompletionEvent,
|
||||
CompletionParams,
|
||||
IProviderAdapter,
|
||||
ModelInfo,
|
||||
ProviderHealth,
|
||||
} from '@mosaic/types';
|
||||
|
||||
/** Embedding models that Ollama ships with out of the box */
|
||||
const OLLAMA_EMBEDDING_MODELS: ReadonlyArray<{
|
||||
id: string;
|
||||
contextWindow: number;
|
||||
dimensions: number;
|
||||
}> = [
|
||||
{ id: 'nomic-embed-text', contextWindow: 8192, dimensions: 768 },
|
||||
{ id: 'mxbai-embed-large', contextWindow: 512, dimensions: 1024 },
|
||||
];
|
||||
|
||||
interface OllamaEmbeddingResponse {
|
||||
embedding?: number[];
|
||||
}
|
||||
|
||||
/**
|
||||
* Ollama provider adapter.
|
||||
*
|
||||
* Registers local Ollama models with the Pi ModelRegistry via the OpenAI-compatible
|
||||
* completions API. Also exposes embedding models and an `embed()` method for
|
||||
* vector generation (used by EmbeddingService / M3-009).
|
||||
*
|
||||
* Configuration is driven by environment variables:
|
||||
* OLLAMA_BASE_URL or OLLAMA_HOST — base URL of the Ollama instance
|
||||
* OLLAMA_MODELS — comma-separated list of model IDs (default: llama3.2,codellama,mistral)
|
||||
*/
|
||||
export class OllamaAdapter implements IProviderAdapter {
|
||||
readonly name = 'ollama';
|
||||
|
||||
private readonly logger = new Logger(OllamaAdapter.name);
|
||||
private registeredModels: ModelInfo[] = [];
|
||||
|
||||
constructor(private readonly registry: ModelRegistry) {}
|
||||
|
||||
async register(): Promise<void> {
|
||||
const ollamaUrl = process.env['OLLAMA_BASE_URL'] ?? process.env['OLLAMA_HOST'];
|
||||
if (!ollamaUrl) {
|
||||
this.logger.debug('Skipping Ollama provider registration: OLLAMA_BASE_URL not set');
|
||||
return;
|
||||
}
|
||||
|
||||
const modelsEnv = process.env['OLLAMA_MODELS'] ?? 'llama3.2,codellama,mistral';
|
||||
const modelIds = modelsEnv
|
||||
.split(',')
|
||||
.map((id: string) => id.trim())
|
||||
.filter(Boolean);
|
||||
|
||||
this.registry.registerProvider('ollama', {
|
||||
baseUrl: `${ollamaUrl}/v1`,
|
||||
apiKey: 'ollama',
|
||||
api: 'openai-completions' as never,
|
||||
models: modelIds.map((id) => ({
|
||||
id,
|
||||
name: id,
|
||||
reasoning: false,
|
||||
input: ['text'] as ('text' | 'image')[],
|
||||
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
|
||||
contextWindow: 8192,
|
||||
maxTokens: 4096,
|
||||
})),
|
||||
});
|
||||
|
||||
// Chat / completion models
|
||||
const completionModels: ModelInfo[] = modelIds.map((id) => ({
|
||||
id,
|
||||
provider: 'ollama',
|
||||
name: id,
|
||||
reasoning: false,
|
||||
contextWindow: 8192,
|
||||
maxTokens: 4096,
|
||||
inputTypes: ['text'] as ('text' | 'image')[],
|
||||
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
|
||||
}));
|
||||
|
||||
// Embedding models (tracked in registeredModels but not in Pi registry,
|
||||
// which only handles completion models)
|
||||
const embeddingModels: ModelInfo[] = OLLAMA_EMBEDDING_MODELS.map((em) => ({
|
||||
id: em.id,
|
||||
provider: 'ollama',
|
||||
name: em.id,
|
||||
reasoning: false,
|
||||
contextWindow: em.contextWindow,
|
||||
maxTokens: 0,
|
||||
inputTypes: ['text'] as ('text' | 'image')[],
|
||||
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
|
||||
}));
|
||||
|
||||
this.registeredModels = [...completionModels, ...embeddingModels];
|
||||
|
||||
this.logger.log(
|
||||
`Ollama provider registered at ${ollamaUrl} with models: ${modelIds.join(', ')} ` +
|
||||
`and embedding models: ${OLLAMA_EMBEDDING_MODELS.map((em) => em.id).join(', ')}`,
|
||||
);
|
||||
}
|
||||
|
||||
listModels(): ModelInfo[] {
|
||||
return this.registeredModels;
|
||||
}
|
||||
|
||||
async healthCheck(): Promise<ProviderHealth> {
|
||||
const ollamaUrl = process.env['OLLAMA_BASE_URL'] ?? process.env['OLLAMA_HOST'];
|
||||
if (!ollamaUrl) {
|
||||
return {
|
||||
status: 'down',
|
||||
lastChecked: new Date().toISOString(),
|
||||
error: 'OLLAMA_BASE_URL not configured',
|
||||
};
|
||||
}
|
||||
|
||||
const checkUrl = `${ollamaUrl}/v1/models`;
|
||||
const start = Date.now();
|
||||
|
||||
try {
|
||||
const res = await fetch(checkUrl, {
|
||||
method: 'GET',
|
||||
headers: { Accept: 'application/json' },
|
||||
signal: AbortSignal.timeout(5000),
|
||||
});
|
||||
const latencyMs = Date.now() - start;
|
||||
|
||||
if (!res.ok) {
|
||||
return {
|
||||
status: 'degraded',
|
||||
latencyMs,
|
||||
lastChecked: new Date().toISOString(),
|
||||
error: `HTTP ${res.status}`,
|
||||
};
|
||||
}
|
||||
|
||||
return { status: 'healthy', latencyMs, lastChecked: new Date().toISOString() };
|
||||
} catch (err) {
|
||||
const latencyMs = Date.now() - start;
|
||||
const error = err instanceof Error ? err.message : String(err);
|
||||
return { status: 'down', latencyMs, lastChecked: new Date().toISOString(), error };
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate an embedding vector for the given text using Ollama's /api/embeddings endpoint.
|
||||
*
|
||||
* Defaults to 'nomic-embed-text' when no model is specified.
|
||||
* Intended for use by EmbeddingService (M3-009).
|
||||
*
|
||||
* @param text - The input text to embed.
|
||||
* @param model - Optional embedding model ID (default: 'nomic-embed-text').
|
||||
* @returns A float array representing the embedding vector.
|
||||
*/
|
||||
async embed(text: string, model = 'nomic-embed-text'): Promise<number[]> {
|
||||
const ollamaUrl = process.env['OLLAMA_BASE_URL'] ?? process.env['OLLAMA_HOST'];
|
||||
if (!ollamaUrl) {
|
||||
throw new Error('OllamaAdapter: OLLAMA_BASE_URL not configured');
|
||||
}
|
||||
|
||||
const embeddingUrl = `${ollamaUrl}/api/embeddings`;
|
||||
|
||||
const res = await fetch(embeddingUrl, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ model, prompt: text }),
|
||||
signal: AbortSignal.timeout(30000),
|
||||
});
|
||||
|
||||
if (!res.ok) {
|
||||
throw new Error(`OllamaAdapter.embed: request failed with HTTP ${res.status}`);
|
||||
}
|
||||
|
||||
const json = (await res.json()) as OllamaEmbeddingResponse;
|
||||
|
||||
if (!Array.isArray(json.embedding)) {
|
||||
throw new Error('OllamaAdapter.embed: unexpected response — missing embedding array');
|
||||
}
|
||||
|
||||
return json.embedding;
|
||||
}
|
||||
|
||||
/**
|
||||
* createCompletion is reserved for future direct-completion use.
|
||||
* The current integration routes completions through Pi SDK's ModelRegistry/AgentSession.
|
||||
*/
|
||||
async *createCompletion(_params: CompletionParams): AsyncIterable<CompletionEvent> {
|
||||
throw new Error(
|
||||
'OllamaAdapter.createCompletion is not yet implemented. ' +
|
||||
'Use Pi SDK AgentSession for completions.',
|
||||
);
|
||||
// Satisfy the AsyncGenerator return type — unreachable but required for TypeScript.
|
||||
yield undefined as never;
|
||||
}
|
||||
}
|
||||
@@ -1,201 +0,0 @@
|
||||
import { Logger } from '@nestjs/common';
|
||||
import OpenAI from 'openai';
|
||||
import type { ModelRegistry } from '@mariozechner/pi-coding-agent';
|
||||
import type {
|
||||
CompletionEvent,
|
||||
CompletionParams,
|
||||
IProviderAdapter,
|
||||
ModelInfo,
|
||||
ProviderHealth,
|
||||
} from '@mosaic/types';
|
||||
|
||||
/**
|
||||
* OpenAI provider adapter.
|
||||
*
|
||||
* Registers OpenAI models (including Codex gpt-5.4) with the Pi ModelRegistry.
|
||||
* Configuration is driven by environment variables:
|
||||
* OPENAI_API_KEY — OpenAI API key (required; adapter skips registration when absent)
|
||||
*/
|
||||
export class OpenAIAdapter implements IProviderAdapter {
|
||||
readonly name = 'openai';
|
||||
|
||||
private readonly logger = new Logger(OpenAIAdapter.name);
|
||||
private registeredModels: ModelInfo[] = [];
|
||||
private client: OpenAI | null = null;
|
||||
|
||||
/** Model ID used for Codex gpt-5.4 in the Pi registry. */
|
||||
static readonly CODEX_MODEL_ID = 'codex-gpt-5-4';
|
||||
|
||||
constructor(private readonly registry: ModelRegistry) {}
|
||||
|
||||
async register(): Promise<void> {
|
||||
const apiKey = process.env['OPENAI_API_KEY'];
|
||||
if (!apiKey) {
|
||||
this.logger.debug('Skipping OpenAI provider registration: OPENAI_API_KEY not set');
|
||||
return;
|
||||
}
|
||||
|
||||
this.client = new OpenAI({ apiKey });
|
||||
|
||||
const codexModel = {
|
||||
id: OpenAIAdapter.CODEX_MODEL_ID,
|
||||
name: 'Codex gpt-5.4',
|
||||
/** OpenAI-compatible completions API */
|
||||
api: 'openai-completions' as never,
|
||||
reasoning: false,
|
||||
input: ['text', 'image'] as ('text' | 'image')[],
|
||||
cost: { input: 0.003, output: 0.012, cacheRead: 0.0015, cacheWrite: 0 },
|
||||
contextWindow: 128_000,
|
||||
maxTokens: 16_384,
|
||||
};
|
||||
|
||||
this.registry.registerProvider('openai', {
|
||||
apiKey,
|
||||
baseUrl: 'https://api.openai.com/v1',
|
||||
models: [codexModel],
|
||||
});
|
||||
|
||||
this.registeredModels = [
|
||||
{
|
||||
id: OpenAIAdapter.CODEX_MODEL_ID,
|
||||
provider: 'openai',
|
||||
name: 'Codex gpt-5.4',
|
||||
reasoning: false,
|
||||
contextWindow: 128_000,
|
||||
maxTokens: 16_384,
|
||||
inputTypes: ['text', 'image'] as ('text' | 'image')[],
|
||||
cost: { input: 0.003, output: 0.012, cacheRead: 0.0015, cacheWrite: 0 },
|
||||
},
|
||||
];
|
||||
|
||||
this.logger.log(`OpenAI provider registered with model: ${OpenAIAdapter.CODEX_MODEL_ID}`);
|
||||
}
|
||||
|
||||
listModels(): ModelInfo[] {
|
||||
return this.registeredModels;
|
||||
}
|
||||
|
||||
async healthCheck(): Promise<ProviderHealth> {
|
||||
const apiKey = process.env['OPENAI_API_KEY'];
|
||||
if (!apiKey) {
|
||||
return {
|
||||
status: 'down',
|
||||
lastChecked: new Date().toISOString(),
|
||||
error: 'OPENAI_API_KEY not configured',
|
||||
};
|
||||
}
|
||||
|
||||
const start = Date.now();
|
||||
try {
|
||||
// Lightweight call — list models to verify key validity
|
||||
const res = await fetch('https://api.openai.com/v1/models', {
|
||||
method: 'GET',
|
||||
headers: {
|
||||
Authorization: `Bearer ${apiKey}`,
|
||||
'Content-Type': 'application/json',
|
||||
},
|
||||
signal: AbortSignal.timeout(5000),
|
||||
});
|
||||
const latencyMs = Date.now() - start;
|
||||
|
||||
if (!res.ok) {
|
||||
return {
|
||||
status: 'degraded',
|
||||
latencyMs,
|
||||
lastChecked: new Date().toISOString(),
|
||||
error: `HTTP ${res.status}`,
|
||||
};
|
||||
}
|
||||
|
||||
return { status: 'healthy', latencyMs, lastChecked: new Date().toISOString() };
|
||||
} catch (err) {
|
||||
const latencyMs = Date.now() - start;
|
||||
const error = err instanceof Error ? err.message : String(err);
|
||||
return { status: 'down', latencyMs, lastChecked: new Date().toISOString(), error };
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stream a completion from OpenAI using the chat completions API.
|
||||
*
|
||||
* Maps OpenAI streaming chunks to the Mosaic CompletionEvent format.
|
||||
*/
|
||||
async *createCompletion(params: CompletionParams): AsyncIterable<CompletionEvent> {
|
||||
if (!this.client) {
|
||||
throw new Error(
|
||||
'OpenAIAdapter: client not initialized. ' +
|
||||
'Ensure OPENAI_API_KEY is set and register() was called.',
|
||||
);
|
||||
}
|
||||
|
||||
const stream = await this.client.chat.completions.create({
|
||||
model: params.model,
|
||||
messages: params.messages.map((m) => ({
|
||||
role: m.role,
|
||||
content: m.content,
|
||||
})),
|
||||
...(params.temperature !== undefined && { temperature: params.temperature }),
|
||||
...(params.maxTokens !== undefined && { max_tokens: params.maxTokens }),
|
||||
...(params.tools &&
|
||||
params.tools.length > 0 && {
|
||||
tools: params.tools.map((t) => ({
|
||||
type: 'function' as const,
|
||||
function: {
|
||||
name: t.name,
|
||||
description: t.description,
|
||||
parameters: t.parameters,
|
||||
},
|
||||
})),
|
||||
}),
|
||||
stream: true,
|
||||
stream_options: { include_usage: true },
|
||||
});
|
||||
|
||||
let inputTokens = 0;
|
||||
let outputTokens = 0;
|
||||
|
||||
for await (const chunk of stream) {
|
||||
const choice = chunk.choices[0];
|
||||
|
||||
// Accumulate usage when present (final chunk with stream_options.include_usage)
|
||||
if (chunk.usage) {
|
||||
inputTokens = chunk.usage.prompt_tokens;
|
||||
outputTokens = chunk.usage.completion_tokens;
|
||||
}
|
||||
|
||||
if (!choice) continue;
|
||||
|
||||
const delta = choice.delta;
|
||||
|
||||
// Text content delta
|
||||
if (delta.content) {
|
||||
yield { type: 'text_delta', content: delta.content };
|
||||
}
|
||||
|
||||
// Tool call delta — emit when arguments are complete
|
||||
if (delta.tool_calls) {
|
||||
for (const toolCallDelta of delta.tool_calls) {
|
||||
if (toolCallDelta.function?.name && toolCallDelta.function.arguments !== undefined) {
|
||||
yield {
|
||||
type: 'tool_call',
|
||||
name: toolCallDelta.function.name,
|
||||
arguments: toolCallDelta.function.arguments,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Stream finished
|
||||
if (choice.finish_reason === 'stop' || choice.finish_reason === 'tool_calls') {
|
||||
yield {
|
||||
type: 'done',
|
||||
usage: { inputTokens, outputTokens },
|
||||
};
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback done event when stream ends without explicit finish_reason
|
||||
yield { type: 'done', usage: { inputTokens, outputTokens } };
|
||||
}
|
||||
}
|
||||
@@ -1,212 +0,0 @@
|
||||
import { Logger } from '@nestjs/common';
|
||||
import OpenAI from 'openai';
|
||||
import type {
|
||||
CompletionEvent,
|
||||
CompletionParams,
|
||||
IProviderAdapter,
|
||||
ModelInfo,
|
||||
ProviderHealth,
|
||||
} from '@mosaic/types';
|
||||
|
||||
const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
|
||||
|
||||
interface OpenRouterModel {
|
||||
id: string;
|
||||
name?: string;
|
||||
context_length?: number;
|
||||
top_provider?: {
|
||||
max_completion_tokens?: number;
|
||||
};
|
||||
pricing?: {
|
||||
prompt?: string | number;
|
||||
completion?: string | number;
|
||||
};
|
||||
architecture?: {
|
||||
input_modalities?: string[];
|
||||
};
|
||||
}
|
||||
|
||||
interface OpenRouterModelsResponse {
|
||||
data?: OpenRouterModel[];
|
||||
}
|
||||
|
||||
/**
|
||||
* OpenRouter provider adapter.
|
||||
*
|
||||
* Routes completions through OpenRouter's OpenAI-compatible API.
|
||||
* Configuration is driven by the OPENROUTER_API_KEY environment variable.
|
||||
*/
|
||||
export class OpenRouterAdapter implements IProviderAdapter {
|
||||
readonly name = 'openrouter';
|
||||
|
||||
private readonly logger = new Logger(OpenRouterAdapter.name);
|
||||
private client: OpenAI | null = null;
|
||||
private registeredModels: ModelInfo[] = [];
|
||||
|
||||
async register(): Promise<void> {
|
||||
const apiKey = process.env['OPENROUTER_API_KEY'];
|
||||
if (!apiKey) {
|
||||
this.logger.debug('Skipping OpenRouter provider registration: OPENROUTER_API_KEY not set');
|
||||
return;
|
||||
}
|
||||
|
||||
this.client = new OpenAI({
|
||||
apiKey,
|
||||
baseURL: OPENROUTER_BASE_URL,
|
||||
defaultHeaders: {
|
||||
'HTTP-Referer': 'https://mosaic.ai',
|
||||
'X-Title': 'Mosaic',
|
||||
},
|
||||
});
|
||||
|
||||
try {
|
||||
this.registeredModels = await this.fetchModels(apiKey);
|
||||
this.logger.log(`OpenRouter provider registered with ${this.registeredModels.length} models`);
|
||||
} catch (err) {
|
||||
this.logger.warn(
|
||||
`OpenRouter model discovery failed: ${err instanceof Error ? err.message : String(err)}. Registering with empty model list.`,
|
||||
);
|
||||
this.registeredModels = [];
|
||||
}
|
||||
}
|
||||
|
||||
listModels(): ModelInfo[] {
|
||||
return this.registeredModels;
|
||||
}
|
||||
|
||||
async healthCheck(): Promise<ProviderHealth> {
|
||||
const apiKey = process.env['OPENROUTER_API_KEY'];
|
||||
if (!apiKey) {
|
||||
return {
|
||||
status: 'down',
|
||||
lastChecked: new Date().toISOString(),
|
||||
error: 'OPENROUTER_API_KEY not configured',
|
||||
};
|
||||
}
|
||||
|
||||
const start = Date.now();
|
||||
try {
|
||||
const res = await fetch(`${OPENROUTER_BASE_URL}/models`, {
|
||||
method: 'GET',
|
||||
headers: {
|
||||
Authorization: `Bearer ${apiKey}`,
|
||||
Accept: 'application/json',
|
||||
},
|
||||
signal: AbortSignal.timeout(5000),
|
||||
});
|
||||
const latencyMs = Date.now() - start;
|
||||
|
||||
if (!res.ok) {
|
||||
return {
|
||||
status: 'degraded',
|
||||
latencyMs,
|
||||
lastChecked: new Date().toISOString(),
|
||||
error: `HTTP ${res.status}`,
|
||||
};
|
||||
}
|
||||
|
||||
return { status: 'healthy', latencyMs, lastChecked: new Date().toISOString() };
|
||||
} catch (err) {
|
||||
const latencyMs = Date.now() - start;
|
||||
const error = err instanceof Error ? err.message : String(err);
|
||||
return { status: 'down', latencyMs, lastChecked: new Date().toISOString(), error };
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stream a completion through OpenRouter's OpenAI-compatible API.
|
||||
*/
|
||||
async *createCompletion(params: CompletionParams): AsyncIterable<CompletionEvent> {
|
||||
if (!this.client) {
|
||||
throw new Error('OpenRouterAdapter is not initialized. Ensure OPENROUTER_API_KEY is set.');
|
||||
}
|
||||
|
||||
const stream = await this.client.chat.completions.create({
|
||||
model: params.model,
|
||||
messages: params.messages.map((m) => ({ role: m.role, content: m.content })),
|
||||
temperature: params.temperature,
|
||||
max_tokens: params.maxTokens,
|
||||
stream: true,
|
||||
});
|
||||
|
||||
let inputTokens = 0;
|
||||
let outputTokens = 0;
|
||||
|
||||
for await (const chunk of stream) {
|
||||
const choice = chunk.choices[0];
|
||||
if (!choice) continue;
|
||||
|
||||
const delta = choice.delta;
|
||||
|
||||
if (delta.content) {
|
||||
yield { type: 'text_delta', content: delta.content };
|
||||
}
|
||||
|
||||
if (choice.finish_reason === 'stop') {
|
||||
const usage = (chunk as { usage?: { prompt_tokens?: number; completion_tokens?: number } })
|
||||
.usage;
|
||||
if (usage) {
|
||||
inputTokens = usage.prompt_tokens ?? 0;
|
||||
outputTokens = usage.completion_tokens ?? 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
yield {
|
||||
type: 'done',
|
||||
usage: { inputTokens, outputTokens },
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Private helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
private async fetchModels(apiKey: string): Promise<ModelInfo[]> {
|
||||
const res = await fetch(`${OPENROUTER_BASE_URL}/models`, {
|
||||
method: 'GET',
|
||||
headers: {
|
||||
Authorization: `Bearer ${apiKey}`,
|
||||
Accept: 'application/json',
|
||||
},
|
||||
signal: AbortSignal.timeout(10000),
|
||||
});
|
||||
|
||||
if (!res.ok) {
|
||||
throw new Error(`OpenRouter models endpoint returned HTTP ${res.status}`);
|
||||
}
|
||||
|
||||
const json = (await res.json()) as OpenRouterModelsResponse;
|
||||
const data = json.data ?? [];
|
||||
|
||||
return data.map((model): ModelInfo => {
|
||||
const inputPrice = model.pricing?.prompt
|
||||
? parseFloat(String(model.pricing.prompt)) * 1000
|
||||
: 0;
|
||||
const outputPrice = model.pricing?.completion
|
||||
? parseFloat(String(model.pricing.completion)) * 1000
|
||||
: 0;
|
||||
|
||||
const inputModalities = model.architecture?.input_modalities ?? ['text'];
|
||||
const inputTypes = inputModalities.includes('image')
|
||||
? (['text', 'image'] as const)
|
||||
: (['text'] as const);
|
||||
|
||||
return {
|
||||
id: model.id,
|
||||
provider: 'openrouter',
|
||||
name: model.name ?? model.id,
|
||||
reasoning: false,
|
||||
contextWindow: model.context_length ?? 4096,
|
||||
maxTokens: model.top_provider?.max_completion_tokens ?? 4096,
|
||||
inputTypes: [...inputTypes],
|
||||
cost: {
|
||||
input: inputPrice,
|
||||
output: outputPrice,
|
||||
cacheRead: 0,
|
||||
cacheWrite: 0,
|
||||
},
|
||||
};
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -1,187 +0,0 @@
|
||||
import { Logger } from '@nestjs/common';
|
||||
import OpenAI from 'openai';
|
||||
import type {
|
||||
CompletionEvent,
|
||||
CompletionParams,
|
||||
IProviderAdapter,
|
||||
ModelInfo,
|
||||
ProviderHealth,
|
||||
} from '@mosaic/types';
|
||||
import { getModelCapability } from '../model-capabilities.js';
|
||||
|
||||
/**
|
||||
* Default Z.ai API base URL.
|
||||
* Z.ai (BigModel / Zhipu AI) exposes an OpenAI-compatible API at this endpoint.
|
||||
* Can be overridden via the ZAI_BASE_URL environment variable.
|
||||
*/
|
||||
const DEFAULT_ZAI_BASE_URL = 'https://open.bigmodel.cn/api/paas/v4';
|
||||
|
||||
/**
|
||||
* GLM-5 model identifier on the Z.ai platform.
|
||||
*/
|
||||
const GLM5_MODEL_ID = 'glm-5';
|
||||
|
||||
/**
|
||||
* Z.ai (Zhipu AI / BigModel) provider adapter.
|
||||
*
|
||||
* Z.ai exposes an OpenAI-compatible REST API. This adapter uses the `openai`
|
||||
* SDK with a custom base URL and the ZAI_API_KEY environment variable.
|
||||
*
|
||||
* Configuration:
|
||||
* ZAI_API_KEY — required; Z.ai API key
|
||||
* ZAI_BASE_URL — optional; override the default API base URL
|
||||
*/
|
||||
export class ZaiAdapter implements IProviderAdapter {
|
||||
readonly name = 'zai';
|
||||
|
||||
private readonly logger = new Logger(ZaiAdapter.name);
|
||||
private client: OpenAI | null = null;
|
||||
private registeredModels: ModelInfo[] = [];
|
||||
|
||||
async register(): Promise<void> {
|
||||
const apiKey = process.env['ZAI_API_KEY'];
|
||||
if (!apiKey) {
|
||||
this.logger.debug('Skipping Z.ai provider registration: ZAI_API_KEY not set');
|
||||
return;
|
||||
}
|
||||
|
||||
const baseURL = process.env['ZAI_BASE_URL'] ?? DEFAULT_ZAI_BASE_URL;
|
||||
|
||||
this.client = new OpenAI({ apiKey, baseURL });
|
||||
|
||||
this.registeredModels = this.buildModelList();
|
||||
this.logger.log(`Z.ai provider registered with ${this.registeredModels.length} model(s)`);
|
||||
}
|
||||
|
||||
listModels(): ModelInfo[] {
|
||||
return this.registeredModels;
|
||||
}
|
||||
|
||||
async healthCheck(): Promise<ProviderHealth> {
|
||||
const apiKey = process.env['ZAI_API_KEY'];
|
||||
if (!apiKey) {
|
||||
return {
|
||||
status: 'down',
|
||||
lastChecked: new Date().toISOString(),
|
||||
error: 'ZAI_API_KEY not configured',
|
||||
};
|
||||
}
|
||||
|
||||
const baseURL = process.env['ZAI_BASE_URL'] ?? DEFAULT_ZAI_BASE_URL;
|
||||
const start = Date.now();
|
||||
|
||||
try {
|
||||
const res = await fetch(`${baseURL}/models`, {
|
||||
method: 'GET',
|
||||
headers: {
|
||||
Authorization: `Bearer ${apiKey}`,
|
||||
Accept: 'application/json',
|
||||
},
|
||||
signal: AbortSignal.timeout(5000),
|
||||
});
|
||||
const latencyMs = Date.now() - start;
|
||||
|
||||
if (!res.ok) {
|
||||
return {
|
||||
status: 'degraded',
|
||||
latencyMs,
|
||||
lastChecked: new Date().toISOString(),
|
||||
error: `HTTP ${res.status}`,
|
||||
};
|
||||
}
|
||||
|
||||
return { status: 'healthy', latencyMs, lastChecked: new Date().toISOString() };
|
||||
} catch (err) {
|
||||
const latencyMs = Date.now() - start;
|
||||
const error = err instanceof Error ? err.message : String(err);
|
||||
return { status: 'down', latencyMs, lastChecked: new Date().toISOString(), error };
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stream a completion through Z.ai's OpenAI-compatible API.
|
||||
*/
|
||||
async *createCompletion(params: CompletionParams): AsyncIterable<CompletionEvent> {
|
||||
if (!this.client) {
|
||||
throw new Error('ZaiAdapter is not initialized. Ensure ZAI_API_KEY is set.');
|
||||
}
|
||||
|
||||
const stream = await this.client.chat.completions.create({
|
||||
model: params.model,
|
||||
messages: params.messages.map((m) => ({ role: m.role, content: m.content })),
|
||||
temperature: params.temperature,
|
||||
max_tokens: params.maxTokens,
|
||||
stream: true,
|
||||
});
|
||||
|
||||
let inputTokens = 0;
|
||||
let outputTokens = 0;
|
||||
|
||||
for await (const chunk of stream) {
|
||||
const choice = chunk.choices[0];
|
||||
if (!choice) continue;
|
||||
|
||||
const delta = choice.delta;
|
||||
|
||||
if (delta.content) {
|
||||
yield { type: 'text_delta', content: delta.content };
|
||||
}
|
||||
|
||||
if (choice.finish_reason === 'stop') {
|
||||
const usage = (chunk as { usage?: { prompt_tokens?: number; completion_tokens?: number } })
|
||||
.usage;
|
||||
if (usage) {
|
||||
inputTokens = usage.prompt_tokens ?? 0;
|
||||
outputTokens = usage.completion_tokens ?? 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
yield {
|
||||
type: 'done',
|
||||
usage: { inputTokens, outputTokens },
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Private helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
private buildModelList(): ModelInfo[] {
|
||||
const capability = getModelCapability(GLM5_MODEL_ID);
|
||||
|
||||
if (!capability) {
|
||||
this.logger.warn(`Model capability entry not found for '${GLM5_MODEL_ID}'; using defaults`);
|
||||
return [
|
||||
{
|
||||
id: GLM5_MODEL_ID,
|
||||
provider: 'zai',
|
||||
name: 'GLM-5',
|
||||
reasoning: false,
|
||||
contextWindow: 128000,
|
||||
maxTokens: 8192,
|
||||
inputTypes: ['text'],
|
||||
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
return [
|
||||
{
|
||||
id: capability.id,
|
||||
provider: 'zai',
|
||||
name: capability.displayName,
|
||||
reasoning: capability.capabilities.reasoning,
|
||||
contextWindow: capability.contextWindow,
|
||||
maxTokens: capability.maxOutputTokens,
|
||||
inputTypes: capability.capabilities.vision ? ['text', 'image'] : ['text'],
|
||||
cost: {
|
||||
input: capability.costPer1kInput ?? 0,
|
||||
output: capability.costPer1kOutput ?? 0,
|
||||
cacheRead: 0,
|
||||
cacheWrite: 0,
|
||||
},
|
||||
},
|
||||
];
|
||||
}
|
||||
}
|
||||
@@ -1,197 +0,0 @@
|
||||
import {
|
||||
IsArray,
|
||||
IsBoolean,
|
||||
IsIn,
|
||||
IsObject,
|
||||
IsOptional,
|
||||
IsString,
|
||||
IsUUID,
|
||||
MaxLength,
|
||||
} from 'class-validator';
|
||||
|
||||
const agentStatuses = ['idle', 'active', 'error', 'offline'] as const;
|
||||
|
||||
// ─── Agent Capability Declarations (M4-011) ───────────────────────────────────
|
||||
|
||||
/**
|
||||
* Agent specialization capability fields.
|
||||
* Stored inside the agent's `config` JSON as `capabilities`.
|
||||
*/
|
||||
export class AgentCapabilitiesDto {
|
||||
/**
|
||||
* Domains this agent specializes in, e.g. ['frontend', 'backend', 'devops'].
|
||||
* Used by the routing engine to bias toward this agent for matching domains.
|
||||
*/
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsString({ each: true })
|
||||
domains?: string[];
|
||||
|
||||
/**
|
||||
* Default model identifier for this agent.
|
||||
* Influences routing when no explicit rule overrides the choice.
|
||||
*/
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
preferredModel?: string;
|
||||
|
||||
/**
|
||||
* Default provider for this agent.
|
||||
* Influences routing when no explicit rule overrides the choice.
|
||||
*/
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
preferredProvider?: string;
|
||||
|
||||
/**
|
||||
* Tool categories this agent has access to, e.g. ['web-search', 'code-exec'].
|
||||
*/
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsString({ each: true })
|
||||
toolSets?: string[];
|
||||
}
|
||||
|
||||
// ─── Create DTO ───────────────────────────────────────────────────────────────
|
||||
|
||||
export class CreateAgentConfigDto {
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
name!: string;
|
||||
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
provider!: string;
|
||||
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
model!: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsIn(agentStatuses)
|
||||
status?: 'idle' | 'active' | 'error' | 'offline';
|
||||
|
||||
@IsOptional()
|
||||
@IsUUID()
|
||||
projectId?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(50_000)
|
||||
systemPrompt?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
allowedTools?: string[];
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
skills?: string[];
|
||||
|
||||
@IsOptional()
|
||||
@IsBoolean()
|
||||
isSystem?: boolean;
|
||||
|
||||
/**
|
||||
* General config blob. May include `capabilities` (AgentCapabilitiesDto)
|
||||
* for agent specialization declarations (M4-011).
|
||||
*/
|
||||
@IsOptional()
|
||||
@IsObject()
|
||||
config?: Record<string, unknown>;
|
||||
|
||||
// ─── Capability shorthand fields (M4-011) ──────────────────────────────────
|
||||
// These are convenience top-level fields that get merged into config.capabilities.
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsString({ each: true })
|
||||
domains?: string[];
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
preferredModel?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
preferredProvider?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsString({ each: true })
|
||||
toolSets?: string[];
|
||||
}
|
||||
|
||||
// ─── Update DTO ───────────────────────────────────────────────────────────────
|
||||
|
||||
export class UpdateAgentConfigDto {
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
name?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
provider?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
model?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsIn(agentStatuses)
|
||||
status?: 'idle' | 'active' | 'error' | 'offline';
|
||||
|
||||
@IsOptional()
|
||||
@IsUUID()
|
||||
projectId?: string | null;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(50_000)
|
||||
systemPrompt?: string | null;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
allowedTools?: string[] | null;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
skills?: string[] | null;
|
||||
|
||||
/**
|
||||
* General config blob. May include `capabilities` (AgentCapabilitiesDto)
|
||||
* for agent specialization declarations (M4-011).
|
||||
*/
|
||||
@IsOptional()
|
||||
@IsObject()
|
||||
config?: Record<string, unknown> | null;
|
||||
|
||||
// ─── Capability shorthand fields (M4-011) ──────────────────────────────────
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsString({ each: true })
|
||||
domains?: string[] | null;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
preferredModel?: string | null;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
preferredProvider?: string | null;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsString({ each: true })
|
||||
toolSets?: string[] | null;
|
||||
}
|
||||
@@ -1,170 +0,0 @@
|
||||
import {
|
||||
Body,
|
||||
Controller,
|
||||
Delete,
|
||||
ForbiddenException,
|
||||
Get,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
Inject,
|
||||
NotFoundException,
|
||||
Param,
|
||||
Patch,
|
||||
Post,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import type { Brain } from '@mosaic/brain';
|
||||
import { BRAIN } from '../brain/brain.tokens.js';
|
||||
import { AuthGuard } from '../auth/auth.guard.js';
|
||||
import { CurrentUser } from '../auth/current-user.decorator.js';
|
||||
import { CreateAgentConfigDto, UpdateAgentConfigDto } from './agent-config.dto.js';
|
||||
|
||||
// ─── M4-011 helpers ──────────────────────────────────────────────────────────
|
||||
|
||||
type CapabilityFields = {
|
||||
domains?: string[] | null;
|
||||
preferredModel?: string | null;
|
||||
preferredProvider?: string | null;
|
||||
toolSets?: string[] | null;
|
||||
};
|
||||
|
||||
/** Extract capability shorthand fields from the DTO (undefined if none provided). */
|
||||
function buildCapabilities(dto: CapabilityFields): Record<string, unknown> | undefined {
|
||||
const hasAny =
|
||||
dto.domains !== undefined ||
|
||||
dto.preferredModel !== undefined ||
|
||||
dto.preferredProvider !== undefined ||
|
||||
dto.toolSets !== undefined;
|
||||
|
||||
if (!hasAny) return undefined;
|
||||
|
||||
const cap: Record<string, unknown> = {};
|
||||
if (dto.domains !== undefined) cap['domains'] = dto.domains;
|
||||
if (dto.preferredModel !== undefined) cap['preferredModel'] = dto.preferredModel;
|
||||
if (dto.preferredProvider !== undefined) cap['preferredProvider'] = dto.preferredProvider;
|
||||
if (dto.toolSets !== undefined) cap['toolSets'] = dto.toolSets;
|
||||
return cap;
|
||||
}
|
||||
|
||||
/** Merge capabilities into the config object, preserving other config keys. */
|
||||
function mergeCapabilities(
|
||||
existing: Record<string, unknown> | null | undefined,
|
||||
capabilities: Record<string, unknown> | undefined,
|
||||
): Record<string, unknown> | undefined {
|
||||
if (capabilities === undefined && existing === undefined) return undefined;
|
||||
if (capabilities === undefined) return existing ?? undefined;
|
||||
|
||||
const base = existing ?? {};
|
||||
const existingCap =
|
||||
typeof base['capabilities'] === 'object' && base['capabilities'] !== null
|
||||
? (base['capabilities'] as Record<string, unknown>)
|
||||
: {};
|
||||
|
||||
return {
|
||||
...base,
|
||||
capabilities: { ...existingCap, ...capabilities },
|
||||
};
|
||||
}
|
||||
|
||||
@Controller('api/agents')
|
||||
@UseGuards(AuthGuard)
|
||||
export class AgentConfigsController {
|
||||
constructor(@Inject(BRAIN) private readonly brain: Brain) {}
|
||||
|
||||
@Get()
|
||||
async list(@CurrentUser() user: { id: string; role?: string }) {
|
||||
return this.brain.agents.findAccessible(user.id);
|
||||
}
|
||||
|
||||
@Get(':id')
|
||||
async findOne(@Param('id') id: string, @CurrentUser() user: { id: string }) {
|
||||
const agent = await this.brain.agents.findById(id);
|
||||
if (!agent) throw new NotFoundException('Agent not found');
|
||||
if (!agent.isSystem && agent.ownerId !== user.id) {
|
||||
throw new ForbiddenException('Agent does not belong to the current user');
|
||||
}
|
||||
return agent;
|
||||
}
|
||||
|
||||
@Post()
|
||||
async create(@Body() dto: CreateAgentConfigDto, @CurrentUser() user: { id: string }) {
|
||||
// Merge capability shorthand fields into config.capabilities (M4-011)
|
||||
const capabilities = buildCapabilities(dto);
|
||||
const config = mergeCapabilities(dto.config, capabilities);
|
||||
|
||||
return this.brain.agents.create({
|
||||
name: dto.name,
|
||||
provider: dto.provider,
|
||||
model: dto.model,
|
||||
status: dto.status,
|
||||
projectId: dto.projectId,
|
||||
systemPrompt: dto.systemPrompt,
|
||||
allowedTools: dto.allowedTools,
|
||||
skills: dto.skills,
|
||||
isSystem: false,
|
||||
config,
|
||||
ownerId: user.id,
|
||||
});
|
||||
}
|
||||
|
||||
@Patch(':id')
|
||||
async update(
|
||||
@Param('id') id: string,
|
||||
@Body() dto: UpdateAgentConfigDto,
|
||||
@CurrentUser() user: { id: string; role?: string },
|
||||
) {
|
||||
const agent = await this.brain.agents.findById(id);
|
||||
if (!agent) throw new NotFoundException('Agent not found');
|
||||
if (agent.isSystem && user.role !== 'admin') {
|
||||
throw new ForbiddenException('Only admins can update system agents');
|
||||
}
|
||||
if (!agent.isSystem && agent.ownerId !== user.id) {
|
||||
throw new ForbiddenException('Agent does not belong to the current user');
|
||||
}
|
||||
|
||||
// Merge capability shorthand fields into config.capabilities (M4-011)
|
||||
const capabilities = buildCapabilities(dto);
|
||||
const baseConfig =
|
||||
dto.config !== undefined
|
||||
? dto.config
|
||||
: (agent.config as Record<string, unknown> | null | undefined);
|
||||
const config = mergeCapabilities(baseConfig ?? undefined, capabilities);
|
||||
|
||||
// Pass ownerId for user agents so the repo WHERE clause enforces ownership.
|
||||
// For system agents (admin path) pass undefined so the WHERE matches only on id.
|
||||
const ownerId = agent.isSystem ? undefined : user.id;
|
||||
const updated = await this.brain.agents.update(
|
||||
id,
|
||||
{
|
||||
name: dto.name,
|
||||
provider: dto.provider,
|
||||
model: dto.model,
|
||||
status: dto.status,
|
||||
projectId: dto.projectId,
|
||||
systemPrompt: dto.systemPrompt,
|
||||
allowedTools: dto.allowedTools,
|
||||
skills: dto.skills,
|
||||
config: capabilities !== undefined || dto.config !== undefined ? config : undefined,
|
||||
},
|
||||
ownerId,
|
||||
);
|
||||
if (!updated) throw new NotFoundException('Agent not found');
|
||||
return updated;
|
||||
}
|
||||
|
||||
@Delete(':id')
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
async remove(@Param('id') id: string, @CurrentUser() user: { id: string; role?: string }) {
|
||||
const agent = await this.brain.agents.findById(id);
|
||||
if (!agent) throw new NotFoundException('Agent not found');
|
||||
if (agent.isSystem) {
|
||||
throw new ForbiddenException('Cannot delete system agents');
|
||||
}
|
||||
if (agent.ownerId !== user.id) {
|
||||
throw new ForbiddenException('Agent does not belong to the current user');
|
||||
}
|
||||
// Pass ownerId so the repo WHERE clause enforces ownership at the DB level.
|
||||
const deleted = await this.brain.agents.remove(id, user.id);
|
||||
if (!deleted) throw new NotFoundException('Agent not found');
|
||||
}
|
||||
}
|
||||
@@ -1,38 +1,16 @@
|
||||
import { Global, Module } from '@nestjs/common';
|
||||
import { AgentService } from './agent.service.js';
|
||||
import { ProviderService } from './provider.service.js';
|
||||
import { ProviderCredentialsService } from './provider-credentials.service.js';
|
||||
import { RoutingService } from './routing.service.js';
|
||||
import { RoutingEngineService } from './routing/routing-engine.service.js';
|
||||
import { SkillLoaderService } from './skill-loader.service.js';
|
||||
import { ProvidersController } from './providers.controller.js';
|
||||
import { SessionsController } from './sessions.controller.js';
|
||||
import { AgentConfigsController } from './agent-configs.controller.js';
|
||||
import { RoutingController } from './routing/routing.controller.js';
|
||||
import { CoordModule } from '../coord/coord.module.js';
|
||||
import { McpClientModule } from '../mcp-client/mcp-client.module.js';
|
||||
import { SkillsModule } from '../skills/skills.module.js';
|
||||
import { GCModule } from '../gc/gc.module.js';
|
||||
|
||||
@Global()
|
||||
@Module({
|
||||
imports: [CoordModule, McpClientModule, SkillsModule, GCModule],
|
||||
providers: [
|
||||
ProviderService,
|
||||
ProviderCredentialsService,
|
||||
RoutingService,
|
||||
RoutingEngineService,
|
||||
SkillLoaderService,
|
||||
AgentService,
|
||||
],
|
||||
controllers: [ProvidersController, SessionsController, AgentConfigsController, RoutingController],
|
||||
exports: [
|
||||
AgentService,
|
||||
ProviderService,
|
||||
ProviderCredentialsService,
|
||||
RoutingService,
|
||||
RoutingEngineService,
|
||||
SkillLoaderService,
|
||||
],
|
||||
imports: [CoordModule],
|
||||
providers: [ProviderService, RoutingService, AgentService],
|
||||
controllers: [ProvidersController, SessionsController],
|
||||
exports: [AgentService, ProviderService, RoutingService],
|
||||
})
|
||||
export class AgentModule {}
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
import { Inject, Injectable, Logger, Optional, type OnModuleDestroy } from '@nestjs/common';
|
||||
import { Inject, Injectable, Logger, type OnModuleDestroy } from '@nestjs/common';
|
||||
import {
|
||||
createAgentSession,
|
||||
DefaultResourceLoader,
|
||||
SessionManager,
|
||||
type AgentSession as PiAgentSession,
|
||||
type AgentSessionEvent,
|
||||
@@ -14,66 +13,14 @@ import { MEMORY } from '../memory/memory.tokens.js';
|
||||
import { EmbeddingService } from '../memory/embedding.service.js';
|
||||
import { CoordService } from '../coord/coord.service.js';
|
||||
import { ProviderService } from './provider.service.js';
|
||||
import { McpClientService } from '../mcp-client/mcp-client.service.js';
|
||||
import { SkillLoaderService } from './skill-loader.service.js';
|
||||
import { createBrainTools } from './tools/brain-tools.js';
|
||||
import { createCoordTools } from './tools/coord-tools.js';
|
||||
import { createMemoryTools } from './tools/memory-tools.js';
|
||||
import { createFileTools } from './tools/file-tools.js';
|
||||
import { createGitTools } from './tools/git-tools.js';
|
||||
import { createShellTools } from './tools/shell-tools.js';
|
||||
import { createWebTools } from './tools/web-tools.js';
|
||||
import { createSearchTools } from './tools/search-tools.js';
|
||||
import type { SessionInfoDto, SessionMetrics } from './session.dto.js';
|
||||
import { SystemOverrideService } from '../preferences/system-override.service.js';
|
||||
import { PreferencesService } from '../preferences/preferences.service.js';
|
||||
import { SessionGCService } from '../gc/session-gc.service.js';
|
||||
|
||||
/** A single message from DB conversation history, used for context injection. */
|
||||
export interface ConversationHistoryMessage {
|
||||
role: 'user' | 'assistant' | 'system';
|
||||
content: string;
|
||||
createdAt: Date;
|
||||
}
|
||||
import type { SessionInfoDto } from './session.dto.js';
|
||||
|
||||
export interface AgentSessionOptions {
|
||||
provider?: string;
|
||||
modelId?: string;
|
||||
/**
|
||||
* Sandbox working directory for the session.
|
||||
* File, git, and shell tools will be restricted to this directory.
|
||||
* Falls back to AGENT_FILE_SANDBOX_DIR env var or process.cwd().
|
||||
*/
|
||||
sandboxDir?: string;
|
||||
/**
|
||||
* Platform-level system prompt for this session.
|
||||
* Merged with skill prompt additions (platform prompt first, then skills).
|
||||
* Falls back to AGENT_SYSTEM_PROMPT env var when omitted.
|
||||
*/
|
||||
systemPrompt?: string;
|
||||
/**
|
||||
* Explicit allowlist of tool names available in this session.
|
||||
* When set, only listed tools are registered with the agent.
|
||||
* When omitted for non-admin users, falls back to AGENT_USER_TOOLS env var.
|
||||
* Admins (isAdmin=true) always receive the full tool set unless explicitly restricted.
|
||||
*/
|
||||
allowedTools?: string[];
|
||||
/** Whether the requesting user has admin privileges. Controls default tool access. */
|
||||
isAdmin?: boolean;
|
||||
/**
|
||||
* DB agent config ID. When provided, loads agent config from DB and merges
|
||||
* provider, model, systemPrompt, and allowedTools. Explicit call-site options
|
||||
* take precedence over config values.
|
||||
*/
|
||||
agentConfigId?: string;
|
||||
/** ID of the user who owns this session. Used for preferences and system override lookups. */
|
||||
userId?: string;
|
||||
/**
|
||||
* Prior conversation messages to inject as context when resuming a session.
|
||||
* These messages are formatted and prepended to the system prompt so the
|
||||
* agent is aware of what was discussed in previous sessions.
|
||||
*/
|
||||
conversationHistory?: ConversationHistoryMessage[];
|
||||
}
|
||||
|
||||
export interface AgentSession {
|
||||
@@ -86,20 +33,6 @@ export interface AgentSession {
|
||||
createdAt: number;
|
||||
promptCount: number;
|
||||
channels: Set<string>;
|
||||
/** System prompt additions injected from enabled prompt-type skills. */
|
||||
skillPromptAdditions: string[];
|
||||
/** Resolved sandbox directory for this session. */
|
||||
sandboxDir: string;
|
||||
/** Tool names available in this session, or null when all tools are available. */
|
||||
allowedTools: string[] | null;
|
||||
/** User ID that owns this session, used for preference lookups. */
|
||||
userId?: string;
|
||||
/** Agent config ID applied to this session, if any (M5-001). */
|
||||
agentConfigId?: string;
|
||||
/** Human-readable agent name applied to this session, if any (M5-001). */
|
||||
agentName?: string;
|
||||
/** M5-007: per-session metrics. */
|
||||
metrics: SessionMetrics;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
@@ -108,70 +41,21 @@ export class AgentService implements OnModuleDestroy {
|
||||
private readonly sessions = new Map<string, AgentSession>();
|
||||
private readonly creating = new Map<string, Promise<AgentSession>>();
|
||||
|
||||
private readonly customTools: ToolDefinition[];
|
||||
|
||||
constructor(
|
||||
@Inject(ProviderService) private readonly providerService: ProviderService,
|
||||
@Inject(BRAIN) private readonly brain: Brain,
|
||||
@Inject(MEMORY) private readonly memory: Memory,
|
||||
@Inject(EmbeddingService) private readonly embeddingService: EmbeddingService,
|
||||
@Inject(CoordService) private readonly coordService: CoordService,
|
||||
@Inject(McpClientService) private readonly mcpClientService: McpClientService,
|
||||
@Inject(SkillLoaderService) private readonly skillLoaderService: SkillLoaderService,
|
||||
@Optional()
|
||||
@Inject(SystemOverrideService)
|
||||
private readonly systemOverride: SystemOverrideService | null,
|
||||
@Optional()
|
||||
@Inject(PreferencesService)
|
||||
private readonly preferencesService: PreferencesService | null,
|
||||
@Inject(SessionGCService) private readonly gc: SessionGCService,
|
||||
) {}
|
||||
|
||||
/**
|
||||
* Build the full set of custom tools scoped to the given sandbox directory and session user.
|
||||
* Brain/coord/memory/web tools are stateless with respect to cwd; file/git/shell
|
||||
* tools receive the resolved sandboxDir so they operate within the sandbox.
|
||||
* Memory tools are bound to sessionUserId so the LLM cannot access another user's data.
|
||||
*/
|
||||
private buildToolsForSandbox(
|
||||
sandboxDir: string,
|
||||
sessionUserId: string | undefined,
|
||||
): ToolDefinition[] {
|
||||
return [
|
||||
...createBrainTools(this.brain),
|
||||
...createCoordTools(this.coordService),
|
||||
...createMemoryTools(
|
||||
this.memory,
|
||||
this.embeddingService.available ? this.embeddingService : null,
|
||||
sessionUserId,
|
||||
),
|
||||
...createFileTools(sandboxDir),
|
||||
...createGitTools(sandboxDir),
|
||||
...createShellTools(sandboxDir),
|
||||
...createWebTools(),
|
||||
...createSearchTools(),
|
||||
) {
|
||||
this.customTools = [
|
||||
...createBrainTools(brain),
|
||||
...createCoordTools(coordService),
|
||||
...createMemoryTools(memory, embeddingService.available ? embeddingService : null),
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve the tool allowlist for a session.
|
||||
* - Admin users: all tools unless an explicit allowedTools list is passed.
|
||||
* - Regular users: use allowedTools if provided, otherwise parse AGENT_USER_TOOLS env var.
|
||||
* Returns null when all tools should be available.
|
||||
*/
|
||||
private resolveAllowedTools(isAdmin: boolean, allowedTools?: string[]): string[] | null {
|
||||
if (allowedTools !== undefined) {
|
||||
return allowedTools.length === 0 ? [] : allowedTools;
|
||||
}
|
||||
if (isAdmin) {
|
||||
return null; // admins get everything
|
||||
}
|
||||
const envTools = process.env['AGENT_USER_TOOLS'];
|
||||
if (!envTools) {
|
||||
return null; // no restriction configured
|
||||
}
|
||||
return envTools
|
||||
.split(',')
|
||||
.map((t) => t.trim())
|
||||
.filter((t) => t.length > 0);
|
||||
this.logger.log(`Registered ${this.customTools.length} custom tools`);
|
||||
}
|
||||
|
||||
async createSession(sessionId: string, options?: AgentSessionOptions): Promise<AgentSession> {
|
||||
@@ -192,120 +76,22 @@ export class AgentService implements OnModuleDestroy {
|
||||
sessionId: string,
|
||||
options?: AgentSessionOptions,
|
||||
): Promise<AgentSession> {
|
||||
// Merge DB agent config when agentConfigId is provided (M5-001)
|
||||
let mergedOptions = options;
|
||||
let resolvedAgentName: string | undefined;
|
||||
if (options?.agentConfigId) {
|
||||
const agentConfig = await this.brain.agents.findById(options.agentConfigId);
|
||||
if (agentConfig) {
|
||||
resolvedAgentName = agentConfig.name;
|
||||
mergedOptions = {
|
||||
provider: options.provider ?? agentConfig.provider,
|
||||
modelId: options.modelId ?? agentConfig.model,
|
||||
systemPrompt: options.systemPrompt ?? agentConfig.systemPrompt ?? undefined,
|
||||
allowedTools: options.allowedTools ?? agentConfig.allowedTools ?? undefined,
|
||||
sandboxDir: options.sandboxDir,
|
||||
isAdmin: options.isAdmin,
|
||||
agentConfigId: options.agentConfigId,
|
||||
userId: options.userId,
|
||||
conversationHistory: options.conversationHistory,
|
||||
};
|
||||
this.logger.log(
|
||||
`Merged agent config "${agentConfig.name}" (${agentConfig.id}) into session ${sessionId}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
const model = this.resolveModel(mergedOptions);
|
||||
const model = this.resolveModel(options);
|
||||
const providerName = model?.provider ?? 'default';
|
||||
const modelId = model?.id ?? 'default';
|
||||
|
||||
// Resolve sandbox directory: option > env var > process.cwd()
|
||||
const sandboxDir =
|
||||
mergedOptions?.sandboxDir ?? process.env['AGENT_FILE_SANDBOX_DIR'] ?? process.cwd();
|
||||
|
||||
// Resolve allowed tool set
|
||||
const allowedTools = this.resolveAllowedTools(
|
||||
mergedOptions?.isAdmin ?? false,
|
||||
mergedOptions?.allowedTools,
|
||||
);
|
||||
|
||||
this.logger.log(
|
||||
`Creating agent session: ${sessionId} (provider=${providerName}, model=${modelId}, sandbox=${sandboxDir}, tools=${allowedTools === null ? 'all' : allowedTools.join(',') || 'none'})`,
|
||||
`Creating agent session: ${sessionId} (provider=${providerName}, model=${modelId})`,
|
||||
);
|
||||
|
||||
// Load skill tools from the catalog
|
||||
const { metaTools: skillMetaTools, promptAdditions } =
|
||||
await this.skillLoaderService.loadForSession();
|
||||
if (skillMetaTools.length > 0) {
|
||||
this.logger.log(`Attaching ${skillMetaTools.length} skill tool(s) to session ${sessionId}`);
|
||||
}
|
||||
if (promptAdditions.length > 0) {
|
||||
this.logger.log(
|
||||
`Injecting ${promptAdditions.length} skill prompt addition(s) into session ${sessionId}`,
|
||||
);
|
||||
}
|
||||
|
||||
// Build per-session tools scoped to the sandbox directory and authenticated user
|
||||
const sandboxTools = this.buildToolsForSandbox(sandboxDir, mergedOptions?.userId);
|
||||
|
||||
// Combine static tools with dynamically discovered MCP client tools and skill tools
|
||||
const mcpTools = this.mcpClientService.getToolDefinitions();
|
||||
let allCustomTools = [...sandboxTools, ...skillMetaTools, ...mcpTools];
|
||||
if (mcpTools.length > 0) {
|
||||
this.logger.log(`Attaching ${mcpTools.length} MCP client tool(s) to session ${sessionId}`);
|
||||
}
|
||||
|
||||
// Filter tools by allowlist when a restriction is in effect
|
||||
if (allowedTools !== null) {
|
||||
const allowedSet = new Set(allowedTools);
|
||||
const before = allCustomTools.length;
|
||||
allCustomTools = allCustomTools.filter((t) => allowedSet.has(t.name));
|
||||
this.logger.log(
|
||||
`Tool restriction applied: ${allCustomTools.length}/${before} tools allowed for session ${sessionId}`,
|
||||
);
|
||||
}
|
||||
|
||||
// Build system prompt: platform prompt + skill additions appended
|
||||
const platformPrompt =
|
||||
mergedOptions?.systemPrompt ?? process.env['AGENT_SYSTEM_PROMPT'] ?? undefined;
|
||||
|
||||
// Format conversation history for context injection (M1-004 / M1-005)
|
||||
const historyPromptSection = mergedOptions?.conversationHistory?.length
|
||||
? this.buildHistoryPromptSection(
|
||||
mergedOptions.conversationHistory,
|
||||
model?.contextWindow ?? 8192,
|
||||
sessionId,
|
||||
)
|
||||
: undefined;
|
||||
|
||||
const appendParts: string[] = [];
|
||||
if (promptAdditions.length > 0) appendParts.push(promptAdditions.join('\n\n'));
|
||||
if (historyPromptSection) appendParts.push(historyPromptSection);
|
||||
const appendSystemPrompt = appendParts.length > 0 ? appendParts.join('\n\n') : undefined;
|
||||
|
||||
// Construct a resource loader that injects the configured system prompt
|
||||
const resourceLoader = new DefaultResourceLoader({
|
||||
cwd: sandboxDir,
|
||||
noExtensions: true,
|
||||
noSkills: true,
|
||||
noPromptTemplates: true,
|
||||
noThemes: true,
|
||||
systemPrompt: platformPrompt,
|
||||
appendSystemPrompt: appendSystemPrompt,
|
||||
});
|
||||
await resourceLoader.reload();
|
||||
|
||||
let piSession: PiAgentSession;
|
||||
try {
|
||||
const result = await createAgentSession({
|
||||
sessionManager: SessionManager.inMemory(),
|
||||
modelRegistry: this.providerService.getRegistry(),
|
||||
model: model ?? undefined,
|
||||
cwd: sandboxDir,
|
||||
tools: [],
|
||||
customTools: allCustomTools,
|
||||
resourceLoader,
|
||||
customTools: this.customTools,
|
||||
});
|
||||
piSession = result.session;
|
||||
} catch (err) {
|
||||
@@ -338,117 +124,14 @@ export class AgentService implements OnModuleDestroy {
|
||||
createdAt: Date.now(),
|
||||
promptCount: 0,
|
||||
channels: new Set(),
|
||||
skillPromptAdditions: promptAdditions,
|
||||
sandboxDir,
|
||||
allowedTools,
|
||||
userId: mergedOptions?.userId,
|
||||
agentConfigId: mergedOptions?.agentConfigId,
|
||||
agentName: resolvedAgentName,
|
||||
metrics: {
|
||||
tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
|
||||
modelSwitches: 0,
|
||||
messageCount: 0,
|
||||
lastActivityAt: new Date().toISOString(),
|
||||
},
|
||||
};
|
||||
|
||||
this.sessions.set(sessionId, session);
|
||||
this.logger.log(`Agent session ${sessionId} ready (${providerName}/${modelId})`);
|
||||
if (resolvedAgentName) {
|
||||
this.logger.log(
|
||||
`Agent session ${sessionId} using agent config "${resolvedAgentName}" (M5-001)`,
|
||||
);
|
||||
}
|
||||
|
||||
return session;
|
||||
}
|
||||
|
||||
/**
|
||||
* Estimate token count for a string using a rough 4-chars-per-token heuristic.
|
||||
*/
|
||||
private estimateTokens(text: string): number {
|
||||
return Math.ceil(text.length / 4);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build a conversation history section for injection into the system prompt.
|
||||
* Implements M1-004 (history loading) and M1-005 (context window management).
|
||||
*
|
||||
* - Formats messages as a readable conversation transcript.
|
||||
* - If the full history exceeds 80% of the model's context window, older messages
|
||||
* are summarized and only the most recent messages are kept verbatim.
|
||||
* - Summarization is a simple extractive approach (no LLM required).
|
||||
*/
|
||||
private buildHistoryPromptSection(
|
||||
history: ConversationHistoryMessage[],
|
||||
contextWindow: number,
|
||||
sessionId: string,
|
||||
): string {
|
||||
const TOKEN_BUDGET = Math.floor(contextWindow * 0.8);
|
||||
const HISTORY_HEADER = '## Conversation History (resumed session)\n\n';
|
||||
|
||||
const formatMessage = (msg: ConversationHistoryMessage): string => {
|
||||
const roleLabel =
|
||||
msg.role === 'user' ? 'User' : msg.role === 'assistant' ? 'Assistant' : 'System';
|
||||
return `**${roleLabel}:** ${msg.content}`;
|
||||
};
|
||||
|
||||
const formatted = history.map((msg) => formatMessage(msg));
|
||||
const fullHistory = formatted.join('\n\n');
|
||||
const fullTokens = this.estimateTokens(HISTORY_HEADER + fullHistory);
|
||||
|
||||
if (fullTokens <= TOKEN_BUDGET) {
|
||||
this.logger.debug(
|
||||
`Session ${sessionId}: injecting full history (${history.length} msgs, ~${fullTokens} tokens)`,
|
||||
);
|
||||
return HISTORY_HEADER + fullHistory;
|
||||
}
|
||||
|
||||
// History exceeds budget — summarize oldest messages, keep recent verbatim
|
||||
this.logger.log(
|
||||
`Session ${sessionId}: history (~${fullTokens} tokens) exceeds ${TOKEN_BUDGET} token budget; summarizing oldest messages`,
|
||||
);
|
||||
|
||||
// Reserve 20% of the budget for the summary prefix, rest for verbatim messages
|
||||
const SUMMARY_RESERVE = Math.floor(TOKEN_BUDGET * 0.2);
|
||||
const verbatimBudget = TOKEN_BUDGET - SUMMARY_RESERVE;
|
||||
|
||||
let verbatimTokens = 0;
|
||||
let verbatimCutIndex = history.length;
|
||||
for (let i = history.length - 1; i >= 0; i--) {
|
||||
const t = this.estimateTokens(formatted[i]!);
|
||||
if (verbatimTokens + t > verbatimBudget) break;
|
||||
verbatimTokens += t;
|
||||
verbatimCutIndex = i;
|
||||
}
|
||||
|
||||
const summarizedMessages = history.slice(0, verbatimCutIndex);
|
||||
const verbatimMessages = history.slice(verbatimCutIndex);
|
||||
|
||||
let summaryText = '';
|
||||
if (summarizedMessages.length > 0) {
|
||||
const topics = summarizedMessages
|
||||
.filter((m) => m.role === 'user')
|
||||
.map((m) => m.content.slice(0, 120).replace(/\n/g, ' '))
|
||||
.join('; ');
|
||||
summaryText =
|
||||
`**Previous conversation summary** (${summarizedMessages.length} messages omitted for brevity):\n` +
|
||||
`Topics discussed: ${topics || '(no user messages in summarized portion)'}`;
|
||||
}
|
||||
|
||||
const verbatimSection = verbatimMessages.map((m) => formatMessage(m)).join('\n\n');
|
||||
|
||||
const parts: string[] = [HISTORY_HEADER];
|
||||
if (summaryText) parts.push(summaryText);
|
||||
if (verbatimSection) parts.push(verbatimSection);
|
||||
|
||||
const result = parts.join('\n\n');
|
||||
this.logger.log(
|
||||
`Session ${sessionId}: summarized ${summarizedMessages.length} messages, kept ${verbatimMessages.length} verbatim (~${this.estimateTokens(result)} tokens)`,
|
||||
);
|
||||
return result;
|
||||
}
|
||||
|
||||
private resolveModel(options?: AgentSessionOptions) {
|
||||
if (!options?.provider && !options?.modelId) {
|
||||
return this.providerService.getDefaultModel() ?? null;
|
||||
@@ -483,12 +166,10 @@ export class AgentService implements OnModuleDestroy {
|
||||
id: s.id,
|
||||
provider: s.provider,
|
||||
modelId: s.modelId,
|
||||
...(s.agentName ? { agentName: s.agentName } : {}),
|
||||
createdAt: new Date(s.createdAt).toISOString(),
|
||||
promptCount: s.promptCount,
|
||||
channels: Array.from(s.channels),
|
||||
durationMs: now - s.createdAt,
|
||||
metrics: { ...s.metrics },
|
||||
}));
|
||||
}
|
||||
|
||||
@@ -499,93 +180,13 @@ export class AgentService implements OnModuleDestroy {
|
||||
id: s.id,
|
||||
provider: s.provider,
|
||||
modelId: s.modelId,
|
||||
...(s.agentName ? { agentName: s.agentName } : {}),
|
||||
createdAt: new Date(s.createdAt).toISOString(),
|
||||
promptCount: s.promptCount,
|
||||
channels: Array.from(s.channels),
|
||||
durationMs: Date.now() - s.createdAt,
|
||||
metrics: { ...s.metrics },
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Record token usage for a session turn (M5-007).
|
||||
* Accumulates tokens across the session lifetime.
|
||||
*/
|
||||
recordTokenUsage(
|
||||
sessionId: string,
|
||||
tokens: { input: number; output: number; cacheRead: number; cacheWrite: number; total: number },
|
||||
): void {
|
||||
const session = this.sessions.get(sessionId);
|
||||
if (!session) return;
|
||||
session.metrics.tokens.input += tokens.input;
|
||||
session.metrics.tokens.output += tokens.output;
|
||||
session.metrics.tokens.cacheRead += tokens.cacheRead;
|
||||
session.metrics.tokens.cacheWrite += tokens.cacheWrite;
|
||||
session.metrics.tokens.total += tokens.total;
|
||||
session.metrics.lastActivityAt = new Date().toISOString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Record a model switch event for a session (M5-007).
|
||||
*/
|
||||
recordModelSwitch(sessionId: string): void {
|
||||
const session = this.sessions.get(sessionId);
|
||||
if (!session) return;
|
||||
session.metrics.modelSwitches += 1;
|
||||
session.metrics.lastActivityAt = new Date().toISOString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Increment message count for a session (M5-007).
|
||||
*/
|
||||
recordMessage(sessionId: string): void {
|
||||
const session = this.sessions.get(sessionId);
|
||||
if (!session) return;
|
||||
session.metrics.messageCount += 1;
|
||||
session.metrics.lastActivityAt = new Date().toISOString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Update the model tracked on a live session (M5-002).
|
||||
* This records the model change in the session metadata so subsequent
|
||||
* session:info emissions reflect the new model. The Pi session itself is
|
||||
* not reconstructed — the model is used on the next createSession call for
|
||||
* the same conversationId when the session is torn down or a new one is created.
|
||||
*/
|
||||
updateSessionModel(sessionId: string, modelId: string): void {
|
||||
const session = this.sessions.get(sessionId);
|
||||
if (!session) return;
|
||||
const prev = session.modelId;
|
||||
session.modelId = modelId;
|
||||
this.recordModelSwitch(sessionId);
|
||||
this.logger.log(`Session ${sessionId}: model updated ${prev} → ${modelId} (M5-002)`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply a new agent config to a live session mid-conversation (M5-003).
|
||||
* Updates agentName, agentConfigId, and modelId on the session object.
|
||||
* System prompt and tools take effect when the next session is created for
|
||||
* this conversationId (they are baked in at session creation time).
|
||||
*/
|
||||
applyAgentConfig(
|
||||
sessionId: string,
|
||||
agentConfigId: string,
|
||||
agentName: string,
|
||||
modelId?: string,
|
||||
): void {
|
||||
const session = this.sessions.get(sessionId);
|
||||
if (!session) return;
|
||||
session.agentConfigId = agentConfigId;
|
||||
session.agentName = agentName;
|
||||
if (modelId) {
|
||||
this.updateSessionModel(sessionId, modelId);
|
||||
}
|
||||
this.logger.log(
|
||||
`Session ${sessionId}: agent switched to "${agentName}" (${agentConfigId}) (M5-003)`,
|
||||
);
|
||||
}
|
||||
|
||||
addChannel(sessionId: string, channel: string): void {
|
||||
const session = this.sessions.get(sessionId);
|
||||
if (session) {
|
||||
@@ -606,20 +207,8 @@ export class AgentService implements OnModuleDestroy {
|
||||
throw new Error(`No agent session found: ${sessionId}`);
|
||||
}
|
||||
session.promptCount += 1;
|
||||
|
||||
// Prepend session-scoped system override if present (renew TTL on each turn)
|
||||
let effectiveMessage = message;
|
||||
if (this.systemOverride) {
|
||||
const override = await this.systemOverride.get(sessionId);
|
||||
if (override) {
|
||||
effectiveMessage = `[System Override]\n${override}\n\n${message}`;
|
||||
await this.systemOverride.renew(sessionId);
|
||||
this.logger.debug(`Applied system override for session ${sessionId}`);
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
await session.piSession.prompt(effectiveMessage);
|
||||
await session.piSession.prompt(message);
|
||||
} catch (err) {
|
||||
this.logger.error(
|
||||
`Prompt failed for session=${sessionId}, messageLength=${message.length}`,
|
||||
@@ -655,14 +244,6 @@ export class AgentService implements OnModuleDestroy {
|
||||
session.listeners.clear();
|
||||
session.channels.clear();
|
||||
this.sessions.delete(sessionId);
|
||||
|
||||
// Run GC cleanup for this session (fire and forget, errors are logged)
|
||||
this.gc.collect(sessionId).catch((err: unknown) => {
|
||||
this.logger.error(
|
||||
`GC collect failed for session ${sessionId}`,
|
||||
err instanceof Error ? err.stack : String(err),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
async onModuleDestroy(): Promise<void> {
|
||||
|
||||
@@ -1,204 +0,0 @@
|
||||
import type { ModelCapability } from '@mosaic/types';
|
||||
|
||||
/**
|
||||
* Comprehensive capability matrix for all target models.
|
||||
* Cost fields are optional and will be filled in when real pricing data is available.
|
||||
*/
|
||||
export const MODEL_CAPABILITIES: ModelCapability[] = [
|
||||
{
|
||||
id: 'claude-opus-4-6',
|
||||
provider: 'anthropic',
|
||||
displayName: 'Claude Opus 4.6',
|
||||
tier: 'premium',
|
||||
contextWindow: 200000,
|
||||
maxOutputTokens: 32000,
|
||||
capabilities: {
|
||||
tools: true,
|
||||
vision: true,
|
||||
streaming: true,
|
||||
reasoning: true,
|
||||
embedding: false,
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'claude-sonnet-4-6',
|
||||
provider: 'anthropic',
|
||||
displayName: 'Claude Sonnet 4.6',
|
||||
tier: 'standard',
|
||||
contextWindow: 200000,
|
||||
maxOutputTokens: 16000,
|
||||
capabilities: {
|
||||
tools: true,
|
||||
vision: true,
|
||||
streaming: true,
|
||||
reasoning: true,
|
||||
embedding: false,
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'claude-haiku-4-5',
|
||||
provider: 'anthropic',
|
||||
displayName: 'Claude Haiku 4.5',
|
||||
tier: 'cheap',
|
||||
contextWindow: 200000,
|
||||
maxOutputTokens: 8192,
|
||||
capabilities: {
|
||||
tools: true,
|
||||
vision: true,
|
||||
streaming: true,
|
||||
reasoning: false,
|
||||
embedding: false,
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'codex-gpt-5.4',
|
||||
provider: 'openai',
|
||||
displayName: 'Codex gpt-5.4',
|
||||
tier: 'premium',
|
||||
contextWindow: 128000,
|
||||
maxOutputTokens: 16384,
|
||||
capabilities: {
|
||||
tools: true,
|
||||
vision: true,
|
||||
streaming: true,
|
||||
reasoning: true,
|
||||
embedding: false,
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'glm-5',
|
||||
provider: 'zai',
|
||||
displayName: 'GLM-5',
|
||||
tier: 'standard',
|
||||
contextWindow: 128000,
|
||||
maxOutputTokens: 8192,
|
||||
capabilities: {
|
||||
tools: true,
|
||||
vision: false,
|
||||
streaming: true,
|
||||
reasoning: false,
|
||||
embedding: false,
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'llama3.2',
|
||||
provider: 'ollama',
|
||||
displayName: 'llama3.2',
|
||||
tier: 'local',
|
||||
contextWindow: 128000,
|
||||
maxOutputTokens: 8192,
|
||||
capabilities: {
|
||||
tools: true,
|
||||
vision: false,
|
||||
streaming: true,
|
||||
reasoning: false,
|
||||
embedding: false,
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'codellama',
|
||||
provider: 'ollama',
|
||||
displayName: 'codellama',
|
||||
tier: 'local',
|
||||
contextWindow: 16000,
|
||||
maxOutputTokens: 4096,
|
||||
capabilities: {
|
||||
tools: true,
|
||||
vision: false,
|
||||
streaming: true,
|
||||
reasoning: false,
|
||||
embedding: false,
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'mistral',
|
||||
provider: 'ollama',
|
||||
displayName: 'mistral',
|
||||
tier: 'local',
|
||||
contextWindow: 32000,
|
||||
maxOutputTokens: 8192,
|
||||
capabilities: {
|
||||
tools: true,
|
||||
vision: false,
|
||||
streaming: true,
|
||||
reasoning: false,
|
||||
embedding: false,
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'nomic-embed-text',
|
||||
provider: 'ollama',
|
||||
displayName: 'nomic-embed-text',
|
||||
tier: 'local',
|
||||
contextWindow: 8192,
|
||||
maxOutputTokens: 0,
|
||||
capabilities: {
|
||||
tools: false,
|
||||
vision: false,
|
||||
streaming: false,
|
||||
reasoning: false,
|
||||
embedding: true,
|
||||
},
|
||||
},
|
||||
{
|
||||
id: 'mxbai-embed-large',
|
||||
provider: 'ollama',
|
||||
displayName: 'mxbai-embed-large',
|
||||
tier: 'local',
|
||||
contextWindow: 8192,
|
||||
maxOutputTokens: 0,
|
||||
capabilities: {
|
||||
tools: false,
|
||||
vision: false,
|
||||
streaming: false,
|
||||
reasoning: false,
|
||||
embedding: true,
|
||||
},
|
||||
},
|
||||
];
|
||||
|
||||
/**
|
||||
* Look up a model by its ID.
|
||||
* Returns undefined if the model is not found.
|
||||
*/
|
||||
export function getModelCapability(modelId: string): ModelCapability | undefined {
|
||||
return MODEL_CAPABILITIES.find((m) => m.id === modelId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find models matching a partial capability filter.
|
||||
* All provided filter keys must match for a model to be included.
|
||||
*/
|
||||
export function findModelsByCapability(
|
||||
filter: Partial<Pick<ModelCapability, 'tier' | 'provider'>> & {
|
||||
capabilities?: Partial<ModelCapability['capabilities']>;
|
||||
},
|
||||
): ModelCapability[] {
|
||||
return MODEL_CAPABILITIES.filter((model) => {
|
||||
if (filter.tier !== undefined && model.tier !== filter.tier) return false;
|
||||
if (filter.provider !== undefined && model.provider !== filter.provider) return false;
|
||||
if (filter.capabilities) {
|
||||
for (const [key, value] of Object.entries(filter.capabilities) as [
|
||||
keyof ModelCapability['capabilities'],
|
||||
boolean,
|
||||
][]) {
|
||||
if (model.capabilities[key] !== value) return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all models for a specific provider.
|
||||
*/
|
||||
export function getModelsByProvider(provider: string): ModelCapability[] {
|
||||
return MODEL_CAPABILITIES.filter((m) => m.provider === provider);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the full list of all known models.
|
||||
*/
|
||||
export function getAllModels(): ModelCapability[] {
|
||||
return MODEL_CAPABILITIES;
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
/** DTO for storing a provider credential. */
|
||||
export interface StoreCredentialDto {
|
||||
/** Provider identifier (e.g., 'anthropic', 'openai', 'openrouter', 'zai') */
|
||||
provider: string;
|
||||
/** Credential type */
|
||||
type: 'api_key' | 'oauth_token';
|
||||
/** Plain-text credential value — will be encrypted before storage */
|
||||
value: string;
|
||||
/** Optional extra config (e.g., base URL overrides) */
|
||||
metadata?: Record<string, unknown>;
|
||||
}
|
||||
|
||||
/** DTO returned in list/existence responses — never contains decrypted values. */
|
||||
export interface ProviderCredentialSummaryDto {
|
||||
provider: string;
|
||||
credentialType: 'api_key' | 'oauth_token';
|
||||
/** Whether a credential is stored for this provider */
|
||||
exists: boolean;
|
||||
expiresAt?: string | null;
|
||||
metadata?: Record<string, unknown> | null;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
}
|
||||
@@ -1,175 +0,0 @@
|
||||
import { Inject, Injectable, Logger } from '@nestjs/common';
|
||||
import { createCipheriv, createDecipheriv, createHash, randomBytes } from 'node:crypto';
|
||||
import type { Db } from '@mosaic/db';
|
||||
import { providerCredentials, eq, and } from '@mosaic/db';
|
||||
import { DB } from '../database/database.module.js';
|
||||
import type { ProviderCredentialSummaryDto } from './provider-credentials.dto.js';
|
||||
|
||||
const ALGORITHM = 'aes-256-gcm';
|
||||
const IV_LENGTH = 12; // 96-bit IV for GCM
|
||||
const TAG_LENGTH = 16; // 128-bit auth tag
|
||||
|
||||
/**
|
||||
* Derive a 32-byte AES-256 key from BETTER_AUTH_SECRET using SHA-256.
|
||||
* The secret is assumed to be set in the environment.
|
||||
*/
|
||||
function deriveEncryptionKey(): Buffer {
|
||||
const secret = process.env['BETTER_AUTH_SECRET'];
|
||||
if (!secret) {
|
||||
throw new Error('BETTER_AUTH_SECRET is not set — cannot derive encryption key');
|
||||
}
|
||||
return createHash('sha256').update(secret).digest();
|
||||
}
|
||||
|
||||
/**
|
||||
* Encrypt a plain-text value using AES-256-GCM.
|
||||
* Output format: base64(iv + authTag + ciphertext)
|
||||
*/
|
||||
function encrypt(plaintext: string): string {
|
||||
const key = deriveEncryptionKey();
|
||||
const iv = randomBytes(IV_LENGTH);
|
||||
const cipher = createCipheriv(ALGORITHM, key, iv);
|
||||
|
||||
const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
|
||||
const authTag = cipher.getAuthTag();
|
||||
|
||||
// Combine iv (12) + authTag (16) + ciphertext and base64-encode
|
||||
const combined = Buffer.concat([iv, authTag, encrypted]);
|
||||
return combined.toString('base64');
|
||||
}
|
||||
|
||||
/**
|
||||
* Decrypt a value encrypted by `encrypt()`.
|
||||
* Throws on authentication failure (tampered data).
|
||||
*/
|
||||
function decrypt(encoded: string): string {
|
||||
const key = deriveEncryptionKey();
|
||||
const combined = Buffer.from(encoded, 'base64');
|
||||
|
||||
const iv = combined.subarray(0, IV_LENGTH);
|
||||
const authTag = combined.subarray(IV_LENGTH, IV_LENGTH + TAG_LENGTH);
|
||||
const ciphertext = combined.subarray(IV_LENGTH + TAG_LENGTH);
|
||||
|
||||
const decipher = createDecipheriv(ALGORITHM, key, iv);
|
||||
decipher.setAuthTag(authTag);
|
||||
|
||||
const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
|
||||
return decrypted.toString('utf8');
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class ProviderCredentialsService {
|
||||
private readonly logger = new Logger(ProviderCredentialsService.name);
|
||||
|
||||
constructor(@Inject(DB) private readonly db: Db) {}
|
||||
|
||||
/**
|
||||
* Encrypt and store (or update) a credential for the given user + provider.
|
||||
* Uses an upsert pattern: one row per (userId, provider).
|
||||
*/
|
||||
async store(
|
||||
userId: string,
|
||||
provider: string,
|
||||
type: 'api_key' | 'oauth_token',
|
||||
value: string,
|
||||
metadata?: Record<string, unknown>,
|
||||
): Promise<void> {
|
||||
const encryptedValue = encrypt(value);
|
||||
|
||||
await this.db
|
||||
.insert(providerCredentials)
|
||||
.values({
|
||||
userId,
|
||||
provider,
|
||||
credentialType: type,
|
||||
encryptedValue,
|
||||
metadata: metadata ?? null,
|
||||
})
|
||||
.onConflictDoUpdate({
|
||||
target: [providerCredentials.userId, providerCredentials.provider],
|
||||
set: {
|
||||
credentialType: type,
|
||||
encryptedValue,
|
||||
metadata: metadata ?? null,
|
||||
updatedAt: new Date(),
|
||||
},
|
||||
});
|
||||
|
||||
this.logger.log(`Credential stored for user=${userId} provider=${provider}`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Decrypt and return the plain-text credential value for the given user + provider.
|
||||
* Returns null if no credential is stored.
|
||||
*/
|
||||
async retrieve(userId: string, provider: string): Promise<string | null> {
|
||||
const rows = await this.db
|
||||
.select()
|
||||
.from(providerCredentials)
|
||||
.where(
|
||||
and(eq(providerCredentials.userId, userId), eq(providerCredentials.provider, provider)),
|
||||
)
|
||||
.limit(1);
|
||||
|
||||
if (rows.length === 0) return null;
|
||||
|
||||
const row = rows[0]!;
|
||||
|
||||
// Skip expired OAuth tokens
|
||||
if (row.expiresAt && row.expiresAt < new Date()) {
|
||||
this.logger.warn(`Credential for user=${userId} provider=${provider} has expired`);
|
||||
return null;
|
||||
}
|
||||
|
||||
try {
|
||||
return decrypt(row.encryptedValue);
|
||||
} catch (err) {
|
||||
this.logger.error(
|
||||
`Failed to decrypt credential for user=${userId} provider=${provider}`,
|
||||
err instanceof Error ? err.message : String(err),
|
||||
);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete the stored credential for the given user + provider.
|
||||
*/
|
||||
async remove(userId: string, provider: string): Promise<void> {
|
||||
await this.db
|
||||
.delete(providerCredentials)
|
||||
.where(
|
||||
and(eq(providerCredentials.userId, userId), eq(providerCredentials.provider, provider)),
|
||||
);
|
||||
|
||||
this.logger.log(`Credential removed for user=${userId} provider=${provider}`);
|
||||
}
|
||||
|
||||
/**
|
||||
* List all providers for which the user has stored credentials.
|
||||
* Never returns decrypted values.
|
||||
*/
|
||||
async listProviders(userId: string): Promise<ProviderCredentialSummaryDto[]> {
|
||||
const rows = await this.db
|
||||
.select({
|
||||
provider: providerCredentials.provider,
|
||||
credentialType: providerCredentials.credentialType,
|
||||
expiresAt: providerCredentials.expiresAt,
|
||||
metadata: providerCredentials.metadata,
|
||||
createdAt: providerCredentials.createdAt,
|
||||
updatedAt: providerCredentials.updatedAt,
|
||||
})
|
||||
.from(providerCredentials)
|
||||
.where(eq(providerCredentials.userId, userId));
|
||||
|
||||
return rows.map((row) => ({
|
||||
provider: row.provider,
|
||||
credentialType: row.credentialType,
|
||||
exists: true,
|
||||
expiresAt: row.expiresAt?.toISOString() ?? null,
|
||||
metadata: row.metadata as Record<string, unknown> | null,
|
||||
createdAt: row.createdAt.toISOString(),
|
||||
updatedAt: row.updatedAt.toISOString(),
|
||||
}));
|
||||
}
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
export interface TestConnectionDto {
|
||||
/** Provider identifier to test (e.g. 'ollama', custom provider id) */
|
||||
providerId: string;
|
||||
/** Optional base URL override for ad-hoc testing */
|
||||
baseUrl?: string;
|
||||
}
|
||||
|
||||
export interface TestConnectionResultDto {
|
||||
providerId: string;
|
||||
reachable: boolean;
|
||||
/** Round-trip latency in milliseconds (present when reachable) */
|
||||
latencyMs?: number;
|
||||
/** Human-readable error when unreachable */
|
||||
error?: string;
|
||||
/** Model ids discovered at the remote endpoint (present when reachable) */
|
||||
discoveredModels?: string[];
|
||||
}
|
||||
@@ -1,234 +1,24 @@
|
||||
import {
|
||||
Inject,
|
||||
Injectable,
|
||||
Logger,
|
||||
Optional,
|
||||
type OnModuleDestroy,
|
||||
type OnModuleInit,
|
||||
} from '@nestjs/common';
|
||||
import { Injectable, Logger, type OnModuleInit } from '@nestjs/common';
|
||||
import { ModelRegistry, AuthStorage } from '@mariozechner/pi-coding-agent';
|
||||
import { getModel, type Model, type Api } from '@mariozechner/pi-ai';
|
||||
import type {
|
||||
CustomProviderConfig,
|
||||
IProviderAdapter,
|
||||
ModelInfo,
|
||||
ProviderHealth,
|
||||
ProviderInfo,
|
||||
} from '@mosaic/types';
|
||||
import {
|
||||
AnthropicAdapter,
|
||||
OllamaAdapter,
|
||||
OpenAIAdapter,
|
||||
OpenRouterAdapter,
|
||||
ZaiAdapter,
|
||||
} from './adapters/index.js';
|
||||
import type { TestConnectionResultDto } from './provider.dto.js';
|
||||
import { ProviderCredentialsService } from './provider-credentials.service.js';
|
||||
|
||||
/** Default health check interval in seconds */
|
||||
const DEFAULT_HEALTH_INTERVAL_SECS = 60;
|
||||
|
||||
/** DI injection token for the provider adapter array. */
|
||||
export const PROVIDER_ADAPTERS = Symbol('PROVIDER_ADAPTERS');
|
||||
|
||||
/** Environment variable names for well-known providers */
|
||||
const PROVIDER_ENV_KEYS: Record<string, string> = {
|
||||
anthropic: 'ANTHROPIC_API_KEY',
|
||||
openai: 'OPENAI_API_KEY',
|
||||
openrouter: 'OPENROUTER_API_KEY',
|
||||
zai: 'ZAI_API_KEY',
|
||||
};
|
||||
import type { Model, Api } from '@mariozechner/pi-ai';
|
||||
import type { ModelInfo, ProviderInfo, CustomProviderConfig } from '@mosaic/types';
|
||||
|
||||
@Injectable()
|
||||
export class ProviderService implements OnModuleInit, OnModuleDestroy {
|
||||
export class ProviderService implements OnModuleInit {
|
||||
private readonly logger = new Logger(ProviderService.name);
|
||||
private registry!: ModelRegistry;
|
||||
|
||||
constructor(
|
||||
@Optional()
|
||||
@Inject(ProviderCredentialsService)
|
||||
private readonly credentialsService: ProviderCredentialsService | null,
|
||||
) {}
|
||||
|
||||
/**
|
||||
* Adapters registered with this service.
|
||||
* Built-in adapters (Ollama) are always present; additional adapters can be
|
||||
* supplied via the PROVIDER_ADAPTERS injection token in the future.
|
||||
*/
|
||||
private adapters: IProviderAdapter[] = [];
|
||||
|
||||
/**
|
||||
* Cached health status per provider, updated by the health check scheduler.
|
||||
*/
|
||||
private healthCache: Map<string, ProviderHealth & { modelCount: number }> = new Map();
|
||||
|
||||
/** Timer handle for the periodic health check scheduler */
|
||||
private healthCheckTimer: ReturnType<typeof setInterval> | null = null;
|
||||
|
||||
async onModuleInit(): Promise<void> {
|
||||
const authStorage = AuthStorage.inMemory();
|
||||
const authStorage = AuthStorage.create();
|
||||
this.registry = new ModelRegistry(authStorage);
|
||||
|
||||
// Build the default set of adapters that rely on the registry
|
||||
this.adapters = [
|
||||
new OllamaAdapter(this.registry),
|
||||
new AnthropicAdapter(this.registry),
|
||||
new OpenAIAdapter(this.registry),
|
||||
new OpenRouterAdapter(),
|
||||
new ZaiAdapter(),
|
||||
];
|
||||
|
||||
// Run all adapter registrations first (Ollama, Anthropic, OpenAI, OpenRouter, Z.ai)
|
||||
await this.registerAll();
|
||||
|
||||
// Register API-key providers directly (custom)
|
||||
this.registerOllamaProvider();
|
||||
this.registerCustomProviders();
|
||||
|
||||
const available = this.registry.getAvailable();
|
||||
this.logger.log(`Providers initialized: ${available.length} models available`);
|
||||
|
||||
// Kick off the health check scheduler
|
||||
this.startHealthCheckScheduler();
|
||||
}
|
||||
|
||||
onModuleDestroy(): void {
|
||||
if (this.healthCheckTimer !== null) {
|
||||
clearInterval(this.healthCheckTimer);
|
||||
this.healthCheckTimer = null;
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Health check scheduler
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Start periodic health checks on all adapters.
|
||||
* Interval is configurable via PROVIDER_HEALTH_INTERVAL env (seconds, default 60).
|
||||
*/
|
||||
private startHealthCheckScheduler(): void {
|
||||
const intervalSecs =
|
||||
parseInt(process.env['PROVIDER_HEALTH_INTERVAL'] ?? '', 10) || DEFAULT_HEALTH_INTERVAL_SECS;
|
||||
const intervalMs = intervalSecs * 1000;
|
||||
|
||||
// Run an initial check immediately (non-blocking)
|
||||
void this.runScheduledHealthChecks();
|
||||
|
||||
this.healthCheckTimer = setInterval(() => {
|
||||
void this.runScheduledHealthChecks();
|
||||
}, intervalMs);
|
||||
|
||||
this.logger.log(`Provider health check scheduler started (interval: ${intervalSecs}s)`);
|
||||
}
|
||||
|
||||
private async runScheduledHealthChecks(): Promise<void> {
|
||||
for (const adapter of this.adapters) {
|
||||
try {
|
||||
const health = await adapter.healthCheck();
|
||||
const modelCount = adapter.listModels().length;
|
||||
this.healthCache.set(adapter.name, { ...health, modelCount });
|
||||
this.logger.debug(
|
||||
`Health check [${adapter.name}]: ${health.status} (${health.latencyMs ?? 'n/a'}ms)`,
|
||||
);
|
||||
} catch (err) {
|
||||
const modelCount = adapter.listModels().length;
|
||||
this.healthCache.set(adapter.name, {
|
||||
status: 'down',
|
||||
lastChecked: new Date().toISOString(),
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
modelCount,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the cached health status for all adapters.
|
||||
* Format: array of { name, status, latencyMs, lastChecked, modelCount }
|
||||
*/
|
||||
getProvidersHealth(): Array<{
|
||||
name: string;
|
||||
status: string;
|
||||
latencyMs?: number;
|
||||
lastChecked: string;
|
||||
modelCount: number;
|
||||
error?: string;
|
||||
}> {
|
||||
return this.adapters.map((adapter) => {
|
||||
const cached = this.healthCache.get(adapter.name);
|
||||
if (cached) {
|
||||
return {
|
||||
name: adapter.name,
|
||||
status: cached.status,
|
||||
latencyMs: cached.latencyMs,
|
||||
lastChecked: cached.lastChecked,
|
||||
modelCount: cached.modelCount,
|
||||
error: cached.error,
|
||||
};
|
||||
}
|
||||
// Not yet checked — return a pending placeholder
|
||||
return {
|
||||
name: adapter.name,
|
||||
status: 'unknown',
|
||||
lastChecked: new Date().toISOString(),
|
||||
modelCount: adapter.listModels().length,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Adapter-pattern API
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Call register() on each adapter in order.
|
||||
* Errors from individual adapters are logged and do not abort the others.
|
||||
*/
|
||||
async registerAll(): Promise<void> {
|
||||
for (const adapter of this.adapters) {
|
||||
try {
|
||||
await adapter.register();
|
||||
} catch (err) {
|
||||
this.logger.error(
|
||||
`Adapter "${adapter.name}" registration failed`,
|
||||
err instanceof Error ? err.stack : String(err),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the adapter registered under the given provider name, or undefined.
|
||||
*/
|
||||
getAdapter(providerName: string): IProviderAdapter | undefined {
|
||||
return this.adapters.find((a) => a.name === providerName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Run healthCheck() on all adapters and return results keyed by provider name.
|
||||
*/
|
||||
async healthCheckAll(): Promise<Record<string, ProviderHealth>> {
|
||||
const results: Record<string, ProviderHealth> = {};
|
||||
await Promise.all(
|
||||
this.adapters.map(async (adapter) => {
|
||||
try {
|
||||
results[adapter.name] = await adapter.healthCheck();
|
||||
} catch (err) {
|
||||
results[adapter.name] = {
|
||||
status: 'down',
|
||||
lastChecked: new Date().toISOString(),
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
};
|
||||
}
|
||||
}),
|
||||
);
|
||||
return results;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Legacy / Pi-SDK-facing API (preserved for AgentService and RoutingService)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
getRegistry(): ModelRegistry {
|
||||
return this.registry;
|
||||
}
|
||||
@@ -274,75 +64,6 @@ export class ProviderService implements OnModuleInit, OnModuleDestroy {
|
||||
return this.registry.getAvailable().map((m) => this.toModelInfo(m));
|
||||
}
|
||||
|
||||
async testConnection(providerId: string, baseUrl?: string): Promise<TestConnectionResultDto> {
|
||||
// Delegate to the adapter when one exists and no URL override is given
|
||||
const adapter = this.getAdapter(providerId);
|
||||
if (adapter && !baseUrl) {
|
||||
const health = await adapter.healthCheck();
|
||||
return {
|
||||
providerId,
|
||||
reachable: health.status !== 'down',
|
||||
latencyMs: health.latencyMs,
|
||||
error: health.error,
|
||||
};
|
||||
}
|
||||
|
||||
// Resolve baseUrl: explicit override > registered provider > ollama env
|
||||
let resolvedUrl = baseUrl;
|
||||
|
||||
if (!resolvedUrl) {
|
||||
const allModels = this.registry.getAll();
|
||||
const providerModels = allModels.filter((m) => m.provider === providerId);
|
||||
if (providerModels.length === 0) {
|
||||
return { providerId, reachable: false, error: `Provider '${providerId}' not found` };
|
||||
}
|
||||
// For Ollama, derive the base URL from environment
|
||||
if (providerId === 'ollama') {
|
||||
const ollamaUrl = process.env['OLLAMA_BASE_URL'] ?? process.env['OLLAMA_HOST'];
|
||||
if (!ollamaUrl) {
|
||||
return { providerId, reachable: false, error: 'OLLAMA_BASE_URL not configured' };
|
||||
}
|
||||
resolvedUrl = `${ollamaUrl}/v1/models`;
|
||||
} else {
|
||||
// For other providers, we can only do a basic check
|
||||
return { providerId, reachable: true, discoveredModels: providerModels.map((m) => m.id) };
|
||||
}
|
||||
} else {
|
||||
resolvedUrl = resolvedUrl.replace(/\/?$/, '') + '/models';
|
||||
}
|
||||
|
||||
const start = Date.now();
|
||||
try {
|
||||
const res = await fetch(resolvedUrl, {
|
||||
method: 'GET',
|
||||
headers: { Accept: 'application/json' },
|
||||
signal: AbortSignal.timeout(5000),
|
||||
});
|
||||
|
||||
const latencyMs = Date.now() - start;
|
||||
|
||||
if (!res.ok) {
|
||||
return { providerId, reachable: false, latencyMs, error: `HTTP ${res.status}` };
|
||||
}
|
||||
|
||||
let discoveredModels: string[] | undefined;
|
||||
try {
|
||||
const json = (await res.json()) as { models?: Array<{ id?: string; name?: string }> };
|
||||
if (Array.isArray(json.models)) {
|
||||
discoveredModels = json.models.map((m) => m.id ?? m.name ?? '').filter(Boolean);
|
||||
}
|
||||
} catch {
|
||||
// ignore parse errors — endpoint was reachable
|
||||
}
|
||||
|
||||
return { providerId, reachable: true, latencyMs, discoveredModels };
|
||||
} catch (err) {
|
||||
const latencyMs = Date.now() - start;
|
||||
const message = err instanceof Error ? err.message : String(err);
|
||||
return { providerId, reachable: false, latencyMs, error: message };
|
||||
}
|
||||
}
|
||||
|
||||
registerCustomProvider(config: CustomProviderConfig): void {
|
||||
this.registry.registerProvider(config.id, {
|
||||
baseUrl: config.baseUrl,
|
||||
@@ -361,9 +82,33 @@ export class ProviderService implements OnModuleInit, OnModuleDestroy {
|
||||
this.logger.log(`Registered custom provider: ${config.id} (${config.models.length} models)`);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Private helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
private registerOllamaProvider(): void {
|
||||
const ollamaUrl = process.env['OLLAMA_BASE_URL'] ?? process.env['OLLAMA_HOST'];
|
||||
if (!ollamaUrl) return;
|
||||
|
||||
const modelsEnv = process.env['OLLAMA_MODELS'] ?? 'llama3.2,codellama,mistral';
|
||||
const modelIds = modelsEnv
|
||||
.split(',')
|
||||
.map((modelId: string) => modelId.trim())
|
||||
.filter(Boolean);
|
||||
|
||||
this.registerCustomProvider({
|
||||
id: 'ollama',
|
||||
name: 'Ollama',
|
||||
baseUrl: `${ollamaUrl}/v1`,
|
||||
models: modelIds.map((id) => ({
|
||||
id,
|
||||
name: id,
|
||||
reasoning: false,
|
||||
contextWindow: 8192,
|
||||
maxTokens: 4096,
|
||||
})),
|
||||
});
|
||||
|
||||
this.logger.log(
|
||||
`Ollama provider registered at ${ollamaUrl} with models: ${modelIds.join(', ')}`,
|
||||
);
|
||||
}
|
||||
|
||||
private registerCustomProviders(): void {
|
||||
const customJson = process.env['MOSAIC_CUSTOM_PROVIDERS'];
|
||||
@@ -379,42 +124,6 @@ export class ProviderService implements OnModuleInit, OnModuleDestroy {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve an API key for a provider, scoped to a specific user.
|
||||
* User-stored credentials take precedence over environment variables.
|
||||
* Returns null if no key is available from either source.
|
||||
*/
|
||||
async resolveApiKey(userId: string, provider: string): Promise<string | null> {
|
||||
if (this.credentialsService) {
|
||||
const userKey = await this.credentialsService.retrieve(userId, provider);
|
||||
if (userKey) {
|
||||
this.logger.debug(`Using user-scoped credential for user=${userId} provider=${provider}`);
|
||||
return userKey;
|
||||
}
|
||||
}
|
||||
|
||||
// Fall back to environment variable
|
||||
const envVar = PROVIDER_ENV_KEYS[provider];
|
||||
const envKey = envVar ? (process.env[envVar] ?? null) : null;
|
||||
if (envKey) {
|
||||
this.logger.debug(`Using env-var credential for provider=${provider}`);
|
||||
}
|
||||
return envKey;
|
||||
}
|
||||
|
||||
private cloneBuiltInModel(
|
||||
provider: string,
|
||||
modelId: string,
|
||||
overrides: Partial<Model<Api>> = {},
|
||||
): Model<Api> {
|
||||
const model = getModel(provider as never, modelId as never) as Model<Api> | undefined;
|
||||
if (!model) {
|
||||
throw new Error(`Built-in model not found: ${provider}:${modelId}`);
|
||||
}
|
||||
|
||||
return { ...model, ...overrides };
|
||||
}
|
||||
|
||||
private toModelInfo(model: Model<Api>): ModelInfo {
|
||||
return {
|
||||
id: model.id,
|
||||
|
||||
@@ -1,23 +1,14 @@
|
||||
import { Body, Controller, Delete, Get, Inject, Param, Post, UseGuards } from '@nestjs/common';
|
||||
import { Body, Controller, Get, Inject, Post, UseGuards } from '@nestjs/common';
|
||||
import type { RoutingCriteria } from '@mosaic/types';
|
||||
import { AuthGuard } from '../auth/auth.guard.js';
|
||||
import { CurrentUser } from '../auth/current-user.decorator.js';
|
||||
import { ProviderService } from './provider.service.js';
|
||||
import { ProviderCredentialsService } from './provider-credentials.service.js';
|
||||
import { RoutingService } from './routing.service.js';
|
||||
import type { TestConnectionDto, TestConnectionResultDto } from './provider.dto.js';
|
||||
import type {
|
||||
StoreCredentialDto,
|
||||
ProviderCredentialSummaryDto,
|
||||
} from './provider-credentials.dto.js';
|
||||
|
||||
@Controller('api/providers')
|
||||
@UseGuards(AuthGuard)
|
||||
export class ProvidersController {
|
||||
constructor(
|
||||
@Inject(ProviderService) private readonly providerService: ProviderService,
|
||||
@Inject(ProviderCredentialsService)
|
||||
private readonly credentialsService: ProviderCredentialsService,
|
||||
@Inject(RoutingService) private readonly routingService: RoutingService,
|
||||
) {}
|
||||
|
||||
@@ -31,16 +22,6 @@ export class ProvidersController {
|
||||
return this.providerService.listAvailableModels();
|
||||
}
|
||||
|
||||
@Get('health')
|
||||
health() {
|
||||
return { providers: this.providerService.getProvidersHealth() };
|
||||
}
|
||||
|
||||
@Post('test')
|
||||
testConnection(@Body() body: TestConnectionDto): Promise<TestConnectionResultDto> {
|
||||
return this.providerService.testConnection(body.providerId, body.baseUrl);
|
||||
}
|
||||
|
||||
@Post('route')
|
||||
route(@Body() criteria: RoutingCriteria) {
|
||||
return this.routingService.route(criteria);
|
||||
@@ -50,49 +31,4 @@ export class ProvidersController {
|
||||
rank(@Body() criteria: RoutingCriteria) {
|
||||
return this.routingService.rank(criteria);
|
||||
}
|
||||
|
||||
// ── Credential CRUD ──────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* GET /api/providers/credentials
|
||||
* List all provider credentials for the authenticated user.
|
||||
* Returns provider names, types, and metadata — never decrypted values.
|
||||
*/
|
||||
@Get('credentials')
|
||||
listCredentials(@CurrentUser() user: { id: string }): Promise<ProviderCredentialSummaryDto[]> {
|
||||
return this.credentialsService.listProviders(user.id);
|
||||
}
|
||||
|
||||
/**
|
||||
* POST /api/providers/credentials
|
||||
* Store or update a provider credential for the authenticated user.
|
||||
* The value is encrypted before storage and never returned.
|
||||
*/
|
||||
@Post('credentials')
|
||||
async storeCredential(
|
||||
@CurrentUser() user: { id: string },
|
||||
@Body() body: StoreCredentialDto,
|
||||
): Promise<{ success: boolean; provider: string }> {
|
||||
await this.credentialsService.store(
|
||||
user.id,
|
||||
body.provider,
|
||||
body.type,
|
||||
body.value,
|
||||
body.metadata,
|
||||
);
|
||||
return { success: true, provider: body.provider };
|
||||
}
|
||||
|
||||
/**
|
||||
* DELETE /api/providers/credentials/:provider
|
||||
* Remove a stored credential for the authenticated user.
|
||||
*/
|
||||
@Delete('credentials/:provider')
|
||||
async removeCredential(
|
||||
@CurrentUser() user: { id: string },
|
||||
@Param('provider') provider: string,
|
||||
): Promise<{ success: boolean; provider: string }> {
|
||||
await this.credentialsService.remove(user.id, provider);
|
||||
return { success: true, provider };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,8 +8,6 @@ const COST_TIER_THRESHOLDS: Record<CostTier, { maxInput: number }> = {
|
||||
cheap: { maxInput: 1 },
|
||||
standard: { maxInput: 10 },
|
||||
premium: { maxInput: Infinity },
|
||||
// local = self-hosted; treat as cheapest tier for cost scoring purposes
|
||||
local: { maxInput: 0 },
|
||||
};
|
||||
|
||||
@Injectable()
|
||||
|
||||
@@ -1,138 +0,0 @@
|
||||
import { Inject, Injectable, Logger, type OnModuleInit } from '@nestjs/common';
|
||||
import { routingRules, type Db, sql } from '@mosaic/db';
|
||||
import { DB } from '../../database/database.module.js';
|
||||
import type { RoutingCondition, RoutingAction } from './routing.types.js';
|
||||
|
||||
/** Seed-time routing rule descriptor */
|
||||
interface RoutingRuleSeed {
|
||||
name: string;
|
||||
priority: number;
|
||||
conditions: RoutingCondition[];
|
||||
action: RoutingAction;
|
||||
}
|
||||
|
||||
export const DEFAULT_ROUTING_RULES: RoutingRuleSeed[] = [
|
||||
{
|
||||
name: 'Complex coding → Opus',
|
||||
priority: 1,
|
||||
conditions: [
|
||||
{ field: 'taskType', operator: 'eq', value: 'coding' },
|
||||
{ field: 'complexity', operator: 'eq', value: 'complex' },
|
||||
],
|
||||
action: { provider: 'anthropic', model: 'claude-opus-4-6' },
|
||||
},
|
||||
{
|
||||
name: 'Moderate coding → Sonnet',
|
||||
priority: 2,
|
||||
conditions: [
|
||||
{ field: 'taskType', operator: 'eq', value: 'coding' },
|
||||
{ field: 'complexity', operator: 'eq', value: 'moderate' },
|
||||
],
|
||||
action: { provider: 'anthropic', model: 'claude-sonnet-4-6' },
|
||||
},
|
||||
{
|
||||
name: 'Simple coding → Codex',
|
||||
priority: 3,
|
||||
conditions: [
|
||||
{ field: 'taskType', operator: 'eq', value: 'coding' },
|
||||
{ field: 'complexity', operator: 'eq', value: 'simple' },
|
||||
],
|
||||
action: { provider: 'openai', model: 'codex-gpt-5-4' },
|
||||
},
|
||||
{
|
||||
name: 'Research → Codex',
|
||||
priority: 4,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'research' }],
|
||||
action: { provider: 'openai', model: 'codex-gpt-5-4' },
|
||||
},
|
||||
{
|
||||
name: 'Summarization → GLM-5',
|
||||
priority: 5,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'summarization' }],
|
||||
action: { provider: 'zai', model: 'glm-5' },
|
||||
},
|
||||
{
|
||||
name: 'Analysis with reasoning → Opus',
|
||||
priority: 6,
|
||||
conditions: [
|
||||
{ field: 'taskType', operator: 'eq', value: 'analysis' },
|
||||
{ field: 'requiredCapabilities', operator: 'includes', value: 'reasoning' },
|
||||
],
|
||||
action: { provider: 'anthropic', model: 'claude-opus-4-6' },
|
||||
},
|
||||
{
|
||||
name: 'Conversation → Sonnet',
|
||||
priority: 7,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'conversation' }],
|
||||
action: { provider: 'anthropic', model: 'claude-sonnet-4-6' },
|
||||
},
|
||||
{
|
||||
name: 'Creative → Sonnet',
|
||||
priority: 8,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'creative' }],
|
||||
action: { provider: 'anthropic', model: 'claude-sonnet-4-6' },
|
||||
},
|
||||
{
|
||||
name: 'Cheap/general → Haiku',
|
||||
priority: 9,
|
||||
conditions: [{ field: 'costTier', operator: 'eq', value: 'cheap' }],
|
||||
action: { provider: 'anthropic', model: 'claude-haiku-4-5' },
|
||||
},
|
||||
{
|
||||
name: 'Fallback → Sonnet',
|
||||
priority: 10,
|
||||
conditions: [],
|
||||
action: { provider: 'anthropic', model: 'claude-sonnet-4-6' },
|
||||
},
|
||||
{
|
||||
name: 'Offline → Ollama',
|
||||
priority: 99,
|
||||
conditions: [{ field: 'costTier', operator: 'eq', value: 'local' }],
|
||||
action: { provider: 'ollama', model: 'llama3.2' },
|
||||
},
|
||||
];
|
||||
|
||||
@Injectable()
|
||||
export class DefaultRoutingRulesSeed implements OnModuleInit {
|
||||
private readonly logger = new Logger(DefaultRoutingRulesSeed.name);
|
||||
|
||||
constructor(@Inject(DB) private readonly db: Db) {}
|
||||
|
||||
async onModuleInit(): Promise<void> {
|
||||
await this.seedDefaultRules();
|
||||
}
|
||||
|
||||
/**
|
||||
* Insert default routing rules into the database if the table is empty.
|
||||
* Skips seeding if any system-scoped rules already exist.
|
||||
*/
|
||||
async seedDefaultRules(): Promise<void> {
|
||||
const rows = await this.db
|
||||
.select({ count: sql<number>`count(*)::int` })
|
||||
.from(routingRules)
|
||||
.where(sql`scope = 'system'`);
|
||||
|
||||
const count = rows[0]?.count ?? 0;
|
||||
if (count > 0) {
|
||||
this.logger.debug(
|
||||
`Skipping default routing rules seed — ${count} system rule(s) already exist`,
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
this.logger.log(`Seeding ${DEFAULT_ROUTING_RULES.length} default routing rules`);
|
||||
|
||||
await this.db.insert(routingRules).values(
|
||||
DEFAULT_ROUTING_RULES.map((rule) => ({
|
||||
name: rule.name,
|
||||
priority: rule.priority,
|
||||
scope: 'system' as const,
|
||||
conditions: rule.conditions as unknown as Record<string, unknown>[],
|
||||
action: rule.action as unknown as Record<string, unknown>,
|
||||
enabled: true,
|
||||
})),
|
||||
);
|
||||
|
||||
this.logger.log('Default routing rules seeded successfully');
|
||||
}
|
||||
}
|
||||
@@ -1,260 +0,0 @@
|
||||
/**
|
||||
* M4-013: Routing end-to-end integration tests.
|
||||
*
|
||||
* These tests exercise the full pipeline:
|
||||
* classifyTask (task-classifier) → matchConditions (routing-engine) → RoutingDecision
|
||||
*
|
||||
* All tests use a mocked DB (rule store) and mocked ProviderService (health map)
|
||||
* to avoid real I/O — they verify the complete classify → match → decide path.
|
||||
*/
|
||||
import { describe, it, expect, vi } from 'vitest';
|
||||
import { RoutingEngineService } from './routing-engine.service.js';
|
||||
import { DEFAULT_ROUTING_RULES } from '../routing/default-rules.js';
|
||||
import type { RoutingRule } from './routing.types.js';
|
||||
|
||||
// ─── Test helpers ─────────────────────────────────────────────────────────────
|
||||
|
||||
/** Build a RoutingEngineService backed by the given rule set and health map. */
|
||||
function makeService(
|
||||
rules: RoutingRule[],
|
||||
healthMap: Record<string, { status: string }>,
|
||||
): RoutingEngineService {
|
||||
const mockDb = {
|
||||
select: vi.fn().mockReturnValue({
|
||||
from: vi.fn().mockReturnValue({
|
||||
where: vi.fn().mockReturnValue({
|
||||
orderBy: vi.fn().mockResolvedValue(
|
||||
rules.map((r) => ({
|
||||
id: r.id,
|
||||
name: r.name,
|
||||
priority: r.priority,
|
||||
scope: r.scope,
|
||||
userId: r.userId ?? null,
|
||||
conditions: r.conditions,
|
||||
action: r.action,
|
||||
enabled: r.enabled,
|
||||
createdAt: new Date(),
|
||||
updatedAt: new Date(),
|
||||
})),
|
||||
),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
|
||||
const mockProviderService = {
|
||||
healthCheckAll: vi.fn().mockResolvedValue(healthMap),
|
||||
};
|
||||
|
||||
return new (RoutingEngineService as unknown as new (
|
||||
db: unknown,
|
||||
ps: unknown,
|
||||
) => RoutingEngineService)(mockDb, mockProviderService);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert DEFAULT_ROUTING_RULES (seed format, no id) to RoutingRule objects
|
||||
* so we can use them in tests.
|
||||
*/
|
||||
function defaultRules(): RoutingRule[] {
|
||||
return DEFAULT_ROUTING_RULES.map((r, i) => ({
|
||||
id: `rule-${i + 1}`,
|
||||
scope: 'system' as const,
|
||||
userId: undefined,
|
||||
enabled: true,
|
||||
...r,
|
||||
}));
|
||||
}
|
||||
|
||||
/** A health map where anthropic, openai, and zai are all healthy. */
|
||||
const allHealthy: Record<string, { status: string }> = {
|
||||
anthropic: { status: 'up' },
|
||||
openai: { status: 'up' },
|
||||
zai: { status: 'up' },
|
||||
ollama: { status: 'up' },
|
||||
};
|
||||
|
||||
// ─── M4-013 E2E tests ─────────────────────────────────────────────────────────
|
||||
|
||||
describe('M4-013: routing end-to-end pipeline', () => {
|
||||
// Test 1: coding message → should route to Opus (complex coding rule)
|
||||
it('coding message routes to Opus via task classifier + routing rules', async () => {
|
||||
// Use a message that classifies as coding + complex
|
||||
// "architecture" triggers complex; "implement" triggers coding
|
||||
const message =
|
||||
'Implement an architecture for a multi-tenant system with database isolation and role-based access control. The system needs to support multiple organizations.';
|
||||
|
||||
const service = makeService(defaultRules(), allHealthy);
|
||||
const decision = await service.resolve(message);
|
||||
|
||||
// Classifier should detect: taskType=coding, complexity=complex
|
||||
// That matches "Complex coding → Opus" rule at priority 1
|
||||
expect(decision.provider).toBe('anthropic');
|
||||
expect(decision.model).toBe('claude-opus-4-6');
|
||||
expect(decision.ruleName).toBe('Complex coding → Opus');
|
||||
});
|
||||
|
||||
// Test 2: "Summarize this" → routes to GLM-5
|
||||
it('"Summarize this" routes to GLM-5 via summarization rule', async () => {
|
||||
const message = 'Summarize this document for me please';
|
||||
|
||||
const service = makeService(defaultRules(), allHealthy);
|
||||
const decision = await service.resolve(message);
|
||||
|
||||
// Classifier should detect: taskType=summarization
|
||||
// Matches "Summarization → GLM-5" rule (priority 5)
|
||||
expect(decision.provider).toBe('zai');
|
||||
expect(decision.model).toBe('glm-5');
|
||||
expect(decision.ruleName).toBe('Summarization → GLM-5');
|
||||
});
|
||||
|
||||
// Test 3: simple question → routes to cheap tier (Haiku)
|
||||
// Note: the "Cheap/general → Haiku" rule uses costTier=cheap condition.
|
||||
// Since costTier is not part of TaskClassification (it's a request-level field),
|
||||
// it won't auto-match. Instead we test that a simple conversation falls through
|
||||
// to the "Conversation → Sonnet" rule — which IS the cheap-tier routing path
|
||||
// for simple conversational questions.
|
||||
// We also verify that routing using a user-scoped cheap-tier rule overrides correctly.
|
||||
it('simple conversational question routes to Sonnet (conversation rule)', async () => {
|
||||
const message = 'What time is it?';
|
||||
|
||||
const service = makeService(defaultRules(), allHealthy);
|
||||
const decision = await service.resolve(message);
|
||||
|
||||
// Classifier: taskType=conversation (no strong signals), complexity=simple
|
||||
// Matches "Conversation → Sonnet" rule (priority 7)
|
||||
expect(decision.provider).toBe('anthropic');
|
||||
expect(decision.model).toBe('claude-sonnet-4-6');
|
||||
expect(decision.ruleName).toBe('Conversation → Sonnet');
|
||||
});
|
||||
|
||||
// Test 3b: explicit cheap-tier rule via user-scoped override
|
||||
it('cheap-tier rule routes to Haiku when costTier=cheap condition matches', async () => {
|
||||
// Build a cheap-tier user rule that has a conversation condition overlapping
|
||||
// with what we send, but give it lower priority so we can test explicitly
|
||||
const cheapRule: RoutingRule = {
|
||||
id: 'cheap-rule-1',
|
||||
name: 'Cheap/general → Haiku',
|
||||
priority: 1,
|
||||
scope: 'system',
|
||||
enabled: true,
|
||||
// This rule matches any simple conversation when costTier is set by the resolver.
|
||||
// We test the rule condition matching directly here:
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'conversation' }],
|
||||
action: { provider: 'anthropic', model: 'claude-haiku-4-5' },
|
||||
};
|
||||
|
||||
const service = makeService([cheapRule], allHealthy);
|
||||
const decision = await service.resolve('Hello, how are you doing today?');
|
||||
|
||||
// Simple greeting → conversation → matches cheapRule → Haiku
|
||||
expect(decision.provider).toBe('anthropic');
|
||||
expect(decision.model).toBe('claude-haiku-4-5');
|
||||
expect(decision.ruleName).toBe('Cheap/general → Haiku');
|
||||
});
|
||||
|
||||
// Test 4: /model override bypasses routing
|
||||
// This test verifies that when a model override is set (stored in chatGateway.modelOverrides),
|
||||
// the routing engine is NOT called. We simulate this by verifying that the routing engine
|
||||
// service is not consulted when the override path is taken.
|
||||
it('/model override bypasses routing engine (no classify → route call)', async () => {
|
||||
// Build a service that would route to Opus for a coding message
|
||||
const mockHealthCheckAll = vi.fn().mockResolvedValue(allHealthy);
|
||||
const mockSelect = vi.fn();
|
||||
const mockDb = {
|
||||
select: mockSelect.mockReturnValue({
|
||||
from: vi.fn().mockReturnValue({
|
||||
where: vi.fn().mockReturnValue({
|
||||
orderBy: vi.fn().mockResolvedValue(defaultRules()),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
const mockProviderService = { healthCheckAll: mockHealthCheckAll };
|
||||
|
||||
const service = new (RoutingEngineService as unknown as new (
|
||||
db: unknown,
|
||||
ps: unknown,
|
||||
) => RoutingEngineService)(mockDb, mockProviderService);
|
||||
|
||||
// Simulate the ChatGateway model-override logic:
|
||||
// When a /model override exists, the gateway skips calling routingEngine.resolve().
|
||||
// We verify this by checking that if we do NOT call resolve(), the DB is never queried.
|
||||
// (This is the same guarantee the ChatGateway code provides.)
|
||||
expect(mockSelect).not.toHaveBeenCalled();
|
||||
expect(mockHealthCheckAll).not.toHaveBeenCalled();
|
||||
|
||||
// Now if we DO call resolve (no override), it hits the DB and health check
|
||||
await service.resolve('implement a function');
|
||||
expect(mockSelect).toHaveBeenCalled();
|
||||
expect(mockHealthCheckAll).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
// Test 5: full pipeline classification accuracy — "Summarize this" message
|
||||
it('full pipeline: classify → match rules → summarization decision', async () => {
|
||||
const message = 'Can you give me a brief summary of the last meeting notes?';
|
||||
|
||||
const service = makeService(defaultRules(), allHealthy);
|
||||
const decision = await service.resolve(message);
|
||||
|
||||
// "brief" keyword → summarization; "brief" is < 100 chars... check length
|
||||
// message length is ~68 chars → simple complexity but summarization type wins
|
||||
expect(decision.ruleName).toBe('Summarization → GLM-5');
|
||||
expect(decision.provider).toBe('zai');
|
||||
expect(decision.model).toBe('glm-5');
|
||||
expect(decision.reason).toContain('Summarization → GLM-5');
|
||||
});
|
||||
|
||||
// Test 6: pipeline with unhealthy provider — falls through to fallback
|
||||
it('when all matched rule providers are unhealthy, falls through to openai fallback', async () => {
|
||||
// The message classifies as: taskType=coding, complexity=moderate (implement + no architecture keyword,
|
||||
// moderate length ~60 chars → simple threshold is < 100 → actually simple since it is < 100 chars)
|
||||
// Let's use a simple coding message to target Simple coding → Codex (openai)
|
||||
const message = 'implement a sort function';
|
||||
|
||||
const unhealthyHealth = {
|
||||
anthropic: { status: 'down' },
|
||||
openai: { status: 'up' },
|
||||
zai: { status: 'up' },
|
||||
ollama: { status: 'down' },
|
||||
};
|
||||
|
||||
const service = makeService(defaultRules(), unhealthyHealth);
|
||||
const decision = await service.resolve(message);
|
||||
|
||||
// "implement" → coding; 26 chars → simple; so: coding+simple → "Simple coding → Codex" (openai)
|
||||
// openai is up → should match
|
||||
expect(decision.provider).toBe('openai');
|
||||
expect(decision.model).toBe('codex-gpt-5-4');
|
||||
});
|
||||
|
||||
// Test 7: research message routing
|
||||
it('research message routes to Codex via research rule', async () => {
|
||||
const message = 'Research the best approaches for distributed caching systems';
|
||||
|
||||
const service = makeService(defaultRules(), allHealthy);
|
||||
const decision = await service.resolve(message);
|
||||
|
||||
// "research" keyword → taskType=research → "Research → Codex" rule (priority 4)
|
||||
expect(decision.ruleName).toBe('Research → Codex');
|
||||
expect(decision.provider).toBe('openai');
|
||||
expect(decision.model).toBe('codex-gpt-5-4');
|
||||
});
|
||||
|
||||
// Test 8: full pipeline integrity — decision includes all required fields
|
||||
it('routing decision includes provider, model, ruleName, and reason', async () => {
|
||||
const message = 'implement a new feature';
|
||||
|
||||
const service = makeService(defaultRules(), allHealthy);
|
||||
const decision = await service.resolve(message);
|
||||
|
||||
expect(decision).toHaveProperty('provider');
|
||||
expect(decision).toHaveProperty('model');
|
||||
expect(decision).toHaveProperty('ruleName');
|
||||
expect(decision).toHaveProperty('reason');
|
||||
expect(typeof decision.provider).toBe('string');
|
||||
expect(typeof decision.model).toBe('string');
|
||||
expect(typeof decision.ruleName).toBe('string');
|
||||
expect(typeof decision.reason).toBe('string');
|
||||
});
|
||||
});
|
||||
@@ -1,216 +0,0 @@
|
||||
import { Inject, Injectable, Logger } from '@nestjs/common';
|
||||
import { routingRules, type Db, and, asc, eq, or } from '@mosaic/db';
|
||||
import { DB } from '../../database/database.module.js';
|
||||
import { ProviderService } from '../provider.service.js';
|
||||
import { classifyTask } from './task-classifier.js';
|
||||
import type {
|
||||
RoutingCondition,
|
||||
RoutingRule,
|
||||
RoutingDecision,
|
||||
TaskClassification,
|
||||
} from './routing.types.js';
|
||||
|
||||
// ─── Injection tokens ────────────────────────────────────────────────────────
|
||||
|
||||
export const PROVIDER_SERVICE = Symbol('ProviderService');
|
||||
|
||||
// ─── Fallback chain ──────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Ordered fallback providers tried when no rule matches or all matched
|
||||
* providers are unhealthy.
|
||||
*/
|
||||
const FALLBACK_CHAIN: Array<{ provider: string; model: string }> = [
|
||||
{ provider: 'anthropic', model: 'claude-sonnet-4-6' },
|
||||
{ provider: 'anthropic', model: 'claude-haiku-4-5' },
|
||||
{ provider: 'ollama', model: 'llama3.2' },
|
||||
];
|
||||
|
||||
// ─── Service ─────────────────────────────────────────────────────────────────
|
||||
|
||||
@Injectable()
|
||||
export class RoutingEngineService {
|
||||
private readonly logger = new Logger(RoutingEngineService.name);
|
||||
|
||||
constructor(
|
||||
@Inject(DB) private readonly db: Db,
|
||||
@Inject(ProviderService) private readonly providerService: ProviderService,
|
||||
) {}
|
||||
|
||||
/**
|
||||
* Classify the message, evaluate routing rules in priority order, and return
|
||||
* the best routing decision.
|
||||
*
|
||||
* @param message - Raw user message text used for classification.
|
||||
* @param userId - Optional user ID for loading user-scoped rules.
|
||||
* @param availableProviders - Optional pre-fetched provider health map to
|
||||
* avoid redundant health checks inside tight loops.
|
||||
*/
|
||||
async resolve(
|
||||
message: string,
|
||||
userId?: string,
|
||||
availableProviders?: Record<string, { status: string }>,
|
||||
): Promise<RoutingDecision> {
|
||||
const classification = classifyTask(message);
|
||||
this.logger.debug(
|
||||
`Classification: taskType=${classification.taskType} complexity=${classification.complexity} domain=${classification.domain}`,
|
||||
);
|
||||
|
||||
// Load health data once (re-use caller-supplied map if provided)
|
||||
const health = availableProviders ?? (await this.providerService.healthCheckAll());
|
||||
|
||||
// Load all applicable rules ordered by priority
|
||||
const rules = await this.loadRules(userId);
|
||||
|
||||
// Evaluate rules in priority order
|
||||
for (const rule of rules) {
|
||||
if (!rule.enabled) continue;
|
||||
|
||||
if (!this.matchConditions(rule, classification)) continue;
|
||||
|
||||
const providerStatus = health[rule.action.provider]?.status;
|
||||
const isHealthy = providerStatus === 'up' || providerStatus === 'ok';
|
||||
|
||||
if (!isHealthy) {
|
||||
this.logger.debug(
|
||||
`Rule "${rule.name}" matched but provider "${rule.action.provider}" is unhealthy (status: ${providerStatus ?? 'unknown'})`,
|
||||
);
|
||||
continue;
|
||||
}
|
||||
|
||||
this.logger.debug(
|
||||
`Rule matched: "${rule.name}" → ${rule.action.provider}/${rule.action.model}`,
|
||||
);
|
||||
|
||||
return {
|
||||
provider: rule.action.provider,
|
||||
model: rule.action.model,
|
||||
agentConfigId: rule.action.agentConfigId,
|
||||
ruleName: rule.name,
|
||||
reason: `Matched routing rule "${rule.name}"`,
|
||||
};
|
||||
}
|
||||
|
||||
// No rule matched (or all matched providers were unhealthy) — apply fallback chain
|
||||
this.logger.debug('No rule matched; applying fallback chain');
|
||||
return this.applyFallbackChain(health);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether all conditions of a rule match the given task classification.
|
||||
* An empty conditions array always matches (catch-all / fallback rule).
|
||||
*/
|
||||
matchConditions(
|
||||
rule: Pick<RoutingRule, 'conditions'>,
|
||||
classification: TaskClassification,
|
||||
): boolean {
|
||||
if (rule.conditions.length === 0) return true;
|
||||
|
||||
return rule.conditions.every((condition) => this.evaluateCondition(condition, classification));
|
||||
}
|
||||
|
||||
// ─── Private helpers ───────────────────────────────────────────────────────
|
||||
|
||||
private evaluateCondition(
|
||||
condition: RoutingCondition,
|
||||
classification: TaskClassification,
|
||||
): boolean {
|
||||
// `costTier` is a valid condition field but is not part of TaskClassification
|
||||
// (it is supplied via userOverrides / request context). Treat unknown fields as
|
||||
// undefined so conditions referencing them simply do not match.
|
||||
const fieldValue = (classification as unknown as Record<string, unknown>)[condition.field];
|
||||
|
||||
switch (condition.operator) {
|
||||
case 'eq': {
|
||||
// Scalar equality: field value must equal condition value (string)
|
||||
if (typeof condition.value !== 'string') return false;
|
||||
return fieldValue === condition.value;
|
||||
}
|
||||
|
||||
case 'in': {
|
||||
// Set membership: condition value (array) contains field value
|
||||
if (!Array.isArray(condition.value)) return false;
|
||||
return condition.value.includes(fieldValue as string);
|
||||
}
|
||||
|
||||
case 'includes': {
|
||||
// Array containment: field value (array) includes condition value (string)
|
||||
if (!Array.isArray(fieldValue)) return false;
|
||||
if (typeof condition.value !== 'string') return false;
|
||||
return (fieldValue as string[]).includes(condition.value);
|
||||
}
|
||||
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Load routing rules from the database.
|
||||
* System rules + user-scoped rules (when userId is provided) are returned,
|
||||
* ordered by priority ascending.
|
||||
*/
|
||||
private async loadRules(userId?: string): Promise<RoutingRule[]> {
|
||||
const whereClause = userId
|
||||
? or(
|
||||
eq(routingRules.scope, 'system'),
|
||||
and(eq(routingRules.scope, 'user'), eq(routingRules.userId, userId)),
|
||||
)
|
||||
: eq(routingRules.scope, 'system');
|
||||
|
||||
const rows = await this.db
|
||||
.select()
|
||||
.from(routingRules)
|
||||
.where(whereClause)
|
||||
.orderBy(asc(routingRules.priority));
|
||||
|
||||
return rows.map((row) => ({
|
||||
id: row.id,
|
||||
name: row.name,
|
||||
priority: row.priority,
|
||||
scope: row.scope as 'system' | 'user',
|
||||
userId: row.userId ?? undefined,
|
||||
conditions: (row.conditions as unknown as RoutingCondition[]) ?? [],
|
||||
action: row.action as unknown as {
|
||||
provider: string;
|
||||
model: string;
|
||||
agentConfigId?: string;
|
||||
systemPromptOverride?: string;
|
||||
toolAllowlist?: string[];
|
||||
},
|
||||
enabled: row.enabled,
|
||||
}));
|
||||
}
|
||||
|
||||
/**
|
||||
* Walk the fallback chain and return the first healthy provider/model pair.
|
||||
* If none are healthy, return the first entry unconditionally (last resort).
|
||||
*/
|
||||
private applyFallbackChain(health: Record<string, { status: string }>): RoutingDecision {
|
||||
for (const candidate of FALLBACK_CHAIN) {
|
||||
const providerStatus = health[candidate.provider]?.status;
|
||||
const isHealthy = providerStatus === 'up' || providerStatus === 'ok';
|
||||
if (isHealthy) {
|
||||
this.logger.debug(`Fallback resolved: ${candidate.provider}/${candidate.model}`);
|
||||
return {
|
||||
provider: candidate.provider,
|
||||
model: candidate.model,
|
||||
ruleName: 'fallback',
|
||||
reason: `Fallback chain — no matching rule; selected ${candidate.provider}/${candidate.model}`,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// All providers in the fallback chain are unhealthy — use the first entry
|
||||
const lastResort = FALLBACK_CHAIN[0]!;
|
||||
this.logger.warn(
|
||||
`All fallback providers unhealthy; using last resort: ${lastResort.provider}/${lastResort.model}`,
|
||||
);
|
||||
return {
|
||||
provider: lastResort.provider,
|
||||
model: lastResort.model,
|
||||
ruleName: 'fallback',
|
||||
reason: `Fallback chain exhausted (all providers unhealthy); using ${lastResort.provider}/${lastResort.model}`,
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -1,460 +0,0 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
||||
import { RoutingEngineService } from './routing-engine.service.js';
|
||||
import type { RoutingRule, TaskClassification } from './routing.types.js';
|
||||
|
||||
// ─── Helpers ─────────────────────────────────────────────────────────────────
|
||||
|
||||
function makeRule(
|
||||
overrides: Partial<RoutingRule> &
|
||||
Pick<RoutingRule, 'name' | 'priority' | 'conditions' | 'action'>,
|
||||
): RoutingRule {
|
||||
return {
|
||||
id: overrides.id ?? crypto.randomUUID(),
|
||||
scope: 'system',
|
||||
enabled: true,
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function makeClassification(overrides: Partial<TaskClassification> = {}): TaskClassification {
|
||||
return {
|
||||
taskType: 'conversation',
|
||||
complexity: 'simple',
|
||||
domain: 'general',
|
||||
requiredCapabilities: [],
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
/** Build a minimal RoutingEngineService with mocked DB and ProviderService. */
|
||||
function makeService(
|
||||
rules: RoutingRule[] = [],
|
||||
healthMap: Record<string, { status: string }> = {},
|
||||
): RoutingEngineService {
|
||||
const mockDb = {
|
||||
select: vi.fn().mockReturnValue({
|
||||
from: vi.fn().mockReturnValue({
|
||||
where: vi.fn().mockReturnValue({
|
||||
orderBy: vi.fn().mockResolvedValue(
|
||||
rules.map((r) => ({
|
||||
id: r.id,
|
||||
name: r.name,
|
||||
priority: r.priority,
|
||||
scope: r.scope,
|
||||
userId: r.userId ?? null,
|
||||
conditions: r.conditions,
|
||||
action: r.action,
|
||||
enabled: r.enabled,
|
||||
createdAt: new Date(),
|
||||
updatedAt: new Date(),
|
||||
})),
|
||||
),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
|
||||
const mockProviderService = {
|
||||
healthCheckAll: vi.fn().mockResolvedValue(healthMap),
|
||||
};
|
||||
|
||||
// Inject mocked dependencies directly (bypass NestJS DI for unit tests)
|
||||
const service = new (RoutingEngineService as unknown as new (
|
||||
db: unknown,
|
||||
ps: unknown,
|
||||
) => RoutingEngineService)(mockDb, mockProviderService);
|
||||
|
||||
return service;
|
||||
}
|
||||
|
||||
// ─── matchConditions ──────────────────────────────────────────────────────────
|
||||
|
||||
describe('RoutingEngineService.matchConditions', () => {
|
||||
let service: RoutingEngineService;
|
||||
|
||||
beforeEach(() => {
|
||||
service = makeService();
|
||||
});
|
||||
|
||||
it('returns true for empty conditions array (catch-all rule)', () => {
|
||||
const rule = makeRule({
|
||||
name: 'fallback',
|
||||
priority: 99,
|
||||
conditions: [],
|
||||
action: { provider: 'anthropic', model: 'claude-sonnet-4-6' },
|
||||
});
|
||||
expect(service.matchConditions(rule, makeClassification())).toBe(true);
|
||||
});
|
||||
|
||||
it('matches eq operator on scalar field', () => {
|
||||
const rule = makeRule({
|
||||
name: 'coding',
|
||||
priority: 1,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'coding' }],
|
||||
action: { provider: 'anthropic', model: 'claude-opus-4-6' },
|
||||
});
|
||||
expect(service.matchConditions(rule, makeClassification({ taskType: 'coding' }))).toBe(true);
|
||||
expect(service.matchConditions(rule, makeClassification({ taskType: 'conversation' }))).toBe(
|
||||
false,
|
||||
);
|
||||
});
|
||||
|
||||
it('matches in operator: field value is in the condition array', () => {
|
||||
const rule = makeRule({
|
||||
name: 'simple or moderate',
|
||||
priority: 2,
|
||||
conditions: [{ field: 'complexity', operator: 'in', value: ['simple', 'moderate'] }],
|
||||
action: { provider: 'anthropic', model: 'claude-haiku-4-5' },
|
||||
});
|
||||
expect(service.matchConditions(rule, makeClassification({ complexity: 'simple' }))).toBe(true);
|
||||
expect(service.matchConditions(rule, makeClassification({ complexity: 'moderate' }))).toBe(
|
||||
true,
|
||||
);
|
||||
expect(service.matchConditions(rule, makeClassification({ complexity: 'complex' }))).toBe(
|
||||
false,
|
||||
);
|
||||
});
|
||||
|
||||
it('matches includes operator: field array includes the condition value', () => {
|
||||
const rule = makeRule({
|
||||
name: 'reasoning required',
|
||||
priority: 3,
|
||||
conditions: [{ field: 'requiredCapabilities', operator: 'includes', value: 'reasoning' }],
|
||||
action: { provider: 'anthropic', model: 'claude-opus-4-6' },
|
||||
});
|
||||
expect(
|
||||
service.matchConditions(rule, makeClassification({ requiredCapabilities: ['reasoning'] })),
|
||||
).toBe(true);
|
||||
expect(
|
||||
service.matchConditions(
|
||||
rule,
|
||||
makeClassification({ requiredCapabilities: ['tools', 'reasoning'] }),
|
||||
),
|
||||
).toBe(true);
|
||||
expect(
|
||||
service.matchConditions(rule, makeClassification({ requiredCapabilities: ['tools'] })),
|
||||
).toBe(false);
|
||||
expect(service.matchConditions(rule, makeClassification({ requiredCapabilities: [] }))).toBe(
|
||||
false,
|
||||
);
|
||||
});
|
||||
|
||||
it('requires ALL conditions to match (AND logic)', () => {
|
||||
const rule = makeRule({
|
||||
name: 'complex coding',
|
||||
priority: 1,
|
||||
conditions: [
|
||||
{ field: 'taskType', operator: 'eq', value: 'coding' },
|
||||
{ field: 'complexity', operator: 'eq', value: 'complex' },
|
||||
],
|
||||
action: { provider: 'anthropic', model: 'claude-opus-4-6' },
|
||||
});
|
||||
|
||||
// Both match
|
||||
expect(
|
||||
service.matchConditions(
|
||||
rule,
|
||||
makeClassification({ taskType: 'coding', complexity: 'complex' }),
|
||||
),
|
||||
).toBe(true);
|
||||
|
||||
// Only one matches
|
||||
expect(
|
||||
service.matchConditions(
|
||||
rule,
|
||||
makeClassification({ taskType: 'coding', complexity: 'simple' }),
|
||||
),
|
||||
).toBe(false);
|
||||
|
||||
// Neither matches
|
||||
expect(
|
||||
service.matchConditions(
|
||||
rule,
|
||||
makeClassification({ taskType: 'conversation', complexity: 'simple' }),
|
||||
),
|
||||
).toBe(false);
|
||||
});
|
||||
|
||||
it('returns false for eq when condition value is an array (type mismatch)', () => {
|
||||
const rule = makeRule({
|
||||
name: 'bad eq',
|
||||
priority: 1,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: ['coding', 'research'] }],
|
||||
action: { provider: 'anthropic', model: 'claude-sonnet-4-6' },
|
||||
});
|
||||
expect(service.matchConditions(rule, makeClassification({ taskType: 'coding' }))).toBe(false);
|
||||
});
|
||||
|
||||
it('returns false for includes when field is not an array', () => {
|
||||
const rule = makeRule({
|
||||
name: 'bad includes',
|
||||
priority: 1,
|
||||
conditions: [{ field: 'taskType', operator: 'includes', value: 'coding' }],
|
||||
action: { provider: 'anthropic', model: 'claude-sonnet-4-6' },
|
||||
});
|
||||
// taskType is a string, not an array — should be false
|
||||
expect(service.matchConditions(rule, makeClassification({ taskType: 'coding' }))).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── resolve — priority ordering ─────────────────────────────────────────────
|
||||
|
||||
describe('RoutingEngineService.resolve — priority ordering', () => {
|
||||
it('selects the highest-priority matching rule', async () => {
|
||||
// Rules are supplied in priority-ascending order, as the DB would return them.
|
||||
const rules = [
|
||||
makeRule({
|
||||
name: 'high priority',
|
||||
priority: 1,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'coding' }],
|
||||
action: { provider: 'anthropic', model: 'claude-opus-4-6' },
|
||||
}),
|
||||
makeRule({
|
||||
name: 'low priority',
|
||||
priority: 10,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'coding' }],
|
||||
action: { provider: 'openai', model: 'gpt-4o' },
|
||||
}),
|
||||
];
|
||||
|
||||
const service = makeService(rules, { anthropic: { status: 'up' }, openai: { status: 'up' } });
|
||||
|
||||
const decision = await service.resolve('implement a function');
|
||||
expect(decision.ruleName).toBe('high priority');
|
||||
expect(decision.provider).toBe('anthropic');
|
||||
expect(decision.model).toBe('claude-opus-4-6');
|
||||
});
|
||||
|
||||
it('skips non-matching rules and picks first match', async () => {
|
||||
const rules = [
|
||||
makeRule({
|
||||
name: 'research rule',
|
||||
priority: 1,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'research' }],
|
||||
action: { provider: 'openai', model: 'gpt-4o' },
|
||||
}),
|
||||
makeRule({
|
||||
name: 'coding rule',
|
||||
priority: 2,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'coding' }],
|
||||
action: { provider: 'anthropic', model: 'claude-sonnet-4-6' },
|
||||
}),
|
||||
];
|
||||
|
||||
const service = makeService(rules, { anthropic: { status: 'up' }, openai: { status: 'up' } });
|
||||
|
||||
const decision = await service.resolve('implement a function');
|
||||
expect(decision.ruleName).toBe('coding rule');
|
||||
expect(decision.provider).toBe('anthropic');
|
||||
});
|
||||
});
|
||||
|
||||
// ─── resolve — unhealthy provider fallback ────────────────────────────────────
|
||||
|
||||
describe('RoutingEngineService.resolve — unhealthy provider handling', () => {
|
||||
it('skips matched rule when provider is unhealthy, tries next rule', async () => {
|
||||
const rules = [
|
||||
makeRule({
|
||||
name: 'primary rule',
|
||||
priority: 1,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'coding' }],
|
||||
action: { provider: 'anthropic', model: 'claude-opus-4-6' },
|
||||
}),
|
||||
makeRule({
|
||||
name: 'secondary rule',
|
||||
priority: 2,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'coding' }],
|
||||
action: { provider: 'openai', model: 'gpt-4o' },
|
||||
}),
|
||||
];
|
||||
|
||||
const service = makeService(rules, {
|
||||
anthropic: { status: 'down' }, // primary is unhealthy
|
||||
openai: { status: 'up' },
|
||||
});
|
||||
|
||||
const decision = await service.resolve('implement a function');
|
||||
expect(decision.ruleName).toBe('secondary rule');
|
||||
expect(decision.provider).toBe('openai');
|
||||
});
|
||||
|
||||
it('falls back to Sonnet when all rules have unhealthy providers', async () => {
|
||||
// Override the rule's provider to something unhealthy but keep anthropic up for fallback
|
||||
const unhealthyRules = [
|
||||
makeRule({
|
||||
name: 'only rule',
|
||||
priority: 1,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'coding' }],
|
||||
action: { provider: 'openai', model: 'gpt-4o' }, // openai is unhealthy
|
||||
}),
|
||||
];
|
||||
|
||||
const service2 = makeService(unhealthyRules, {
|
||||
anthropic: { status: 'up' },
|
||||
openai: { status: 'down' },
|
||||
});
|
||||
|
||||
const decision = await service2.resolve('implement a function');
|
||||
// Should fall through to Sonnet fallback on anthropic
|
||||
expect(decision.provider).toBe('anthropic');
|
||||
expect(decision.model).toBe('claude-sonnet-4-6');
|
||||
expect(decision.ruleName).toBe('fallback');
|
||||
});
|
||||
|
||||
it('falls back to Haiku when Sonnet provider is also down', async () => {
|
||||
const rules: RoutingRule[] = []; // no rules
|
||||
|
||||
const service = makeService(rules, {
|
||||
anthropic: { status: 'down' }, // Sonnet is on anthropic — down
|
||||
ollama: { status: 'up' }, // Haiku is also on anthropic — use Ollama as next
|
||||
});
|
||||
|
||||
const decision = await service.resolve('hello there');
|
||||
// Sonnet (anthropic) is down, Haiku (anthropic) is down, Ollama is up
|
||||
expect(decision.provider).toBe('ollama');
|
||||
expect(decision.model).toBe('llama3.2');
|
||||
expect(decision.ruleName).toBe('fallback');
|
||||
});
|
||||
|
||||
it('uses last resort (Sonnet) when all fallback providers are unhealthy', async () => {
|
||||
const rules: RoutingRule[] = [];
|
||||
|
||||
const service = makeService(rules, {
|
||||
anthropic: { status: 'down' },
|
||||
ollama: { status: 'down' },
|
||||
});
|
||||
|
||||
const decision = await service.resolve('hello');
|
||||
// All unhealthy — still returns first fallback entry as last resort
|
||||
expect(decision.provider).toBe('anthropic');
|
||||
expect(decision.model).toBe('claude-sonnet-4-6');
|
||||
expect(decision.ruleName).toBe('fallback');
|
||||
});
|
||||
});
|
||||
|
||||
// ─── resolve — empty conditions (catch-all rule) ──────────────────────────────
|
||||
|
||||
describe('RoutingEngineService.resolve — empty conditions (fallback rule)', () => {
|
||||
it('matches catch-all rule for any message', async () => {
|
||||
const rules = [
|
||||
makeRule({
|
||||
name: 'catch-all',
|
||||
priority: 99,
|
||||
conditions: [],
|
||||
action: { provider: 'anthropic', model: 'claude-sonnet-4-6' },
|
||||
}),
|
||||
];
|
||||
|
||||
const service = makeService(rules, { anthropic: { status: 'up' } });
|
||||
|
||||
const decision = await service.resolve('completely unrelated message xyz');
|
||||
expect(decision.ruleName).toBe('catch-all');
|
||||
expect(decision.provider).toBe('anthropic');
|
||||
expect(decision.model).toBe('claude-sonnet-4-6');
|
||||
});
|
||||
|
||||
it('catch-all is overridden by a higher-priority specific rule', async () => {
|
||||
const rules = [
|
||||
makeRule({
|
||||
name: 'specific coding rule',
|
||||
priority: 1,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'coding' }],
|
||||
action: { provider: 'anthropic', model: 'claude-opus-4-6' },
|
||||
}),
|
||||
makeRule({
|
||||
name: 'catch-all',
|
||||
priority: 99,
|
||||
conditions: [],
|
||||
action: { provider: 'anthropic', model: 'claude-haiku-4-5' },
|
||||
}),
|
||||
];
|
||||
|
||||
const service = makeService(rules, { anthropic: { status: 'up' } });
|
||||
|
||||
const codingDecision = await service.resolve('implement a function');
|
||||
expect(codingDecision.ruleName).toBe('specific coding rule');
|
||||
expect(codingDecision.model).toBe('claude-opus-4-6');
|
||||
|
||||
const conversationDecision = await service.resolve('hello how are you');
|
||||
expect(conversationDecision.ruleName).toBe('catch-all');
|
||||
expect(conversationDecision.model).toBe('claude-haiku-4-5');
|
||||
});
|
||||
});
|
||||
|
||||
// ─── resolve — disabled rules ─────────────────────────────────────────────────
|
||||
|
||||
describe('RoutingEngineService.resolve — disabled rules', () => {
|
||||
it('skips disabled rules', async () => {
|
||||
const rules = [
|
||||
makeRule({
|
||||
name: 'disabled rule',
|
||||
priority: 1,
|
||||
enabled: false,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'coding' }],
|
||||
action: { provider: 'anthropic', model: 'claude-opus-4-6' },
|
||||
}),
|
||||
makeRule({
|
||||
name: 'enabled fallback',
|
||||
priority: 99,
|
||||
conditions: [],
|
||||
action: { provider: 'anthropic', model: 'claude-sonnet-4-6' },
|
||||
}),
|
||||
];
|
||||
|
||||
const service = makeService(rules, { anthropic: { status: 'up' } });
|
||||
|
||||
const decision = await service.resolve('implement a function');
|
||||
expect(decision.ruleName).toBe('enabled fallback');
|
||||
expect(decision.model).toBe('claude-sonnet-4-6');
|
||||
});
|
||||
});
|
||||
|
||||
// ─── resolve — pre-fetched health map ────────────────────────────────────────
|
||||
|
||||
describe('RoutingEngineService.resolve — availableProviders override', () => {
|
||||
it('uses the provided health map instead of calling healthCheckAll', async () => {
|
||||
const rules = [
|
||||
makeRule({
|
||||
name: 'coding rule',
|
||||
priority: 1,
|
||||
conditions: [{ field: 'taskType', operator: 'eq', value: 'coding' }],
|
||||
action: { provider: 'anthropic', model: 'claude-opus-4-6' },
|
||||
}),
|
||||
];
|
||||
|
||||
const mockHealthCheckAll = vi.fn().mockResolvedValue({});
|
||||
const mockDb = {
|
||||
select: vi.fn().mockReturnValue({
|
||||
from: vi.fn().mockReturnValue({
|
||||
where: vi.fn().mockReturnValue({
|
||||
orderBy: vi.fn().mockResolvedValue(
|
||||
rules.map((r) => ({
|
||||
id: r.id,
|
||||
name: r.name,
|
||||
priority: r.priority,
|
||||
scope: r.scope,
|
||||
userId: r.userId ?? null,
|
||||
conditions: r.conditions,
|
||||
action: r.action,
|
||||
enabled: r.enabled,
|
||||
createdAt: new Date(),
|
||||
updatedAt: new Date(),
|
||||
})),
|
||||
),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
const mockProviderService = { healthCheckAll: mockHealthCheckAll };
|
||||
|
||||
const service = new (RoutingEngineService as unknown as new (
|
||||
db: unknown,
|
||||
ps: unknown,
|
||||
) => RoutingEngineService)(mockDb, mockProviderService);
|
||||
|
||||
const preSupplied = { anthropic: { status: 'up' } };
|
||||
await service.resolve('implement a function', undefined, preSupplied);
|
||||
|
||||
expect(mockHealthCheckAll).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
@@ -1,234 +0,0 @@
|
||||
import {
|
||||
Body,
|
||||
Controller,
|
||||
Delete,
|
||||
ForbiddenException,
|
||||
Get,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
Inject,
|
||||
NotFoundException,
|
||||
Param,
|
||||
Patch,
|
||||
Post,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import { routingRules, type Db, and, asc, eq, or, inArray } from '@mosaic/db';
|
||||
import { DB } from '../../database/database.module.js';
|
||||
import { AuthGuard } from '../../auth/auth.guard.js';
|
||||
import { CurrentUser } from '../../auth/current-user.decorator.js';
|
||||
import {
|
||||
CreateRoutingRuleDto,
|
||||
UpdateRoutingRuleDto,
|
||||
ReorderRoutingRulesDto,
|
||||
} from './routing.dto.js';
|
||||
|
||||
@Controller('api/routing/rules')
|
||||
@UseGuards(AuthGuard)
|
||||
export class RoutingController {
|
||||
constructor(@Inject(DB) private readonly db: Db) {}
|
||||
|
||||
/**
|
||||
* GET /api/routing/rules
|
||||
* List all rules visible to the authenticated user:
|
||||
* - All system rules
|
||||
* - User's own rules
|
||||
* Ordered by priority ascending (lower number = higher priority).
|
||||
*/
|
||||
@Get()
|
||||
async list(@CurrentUser() user: { id: string }) {
|
||||
const rows = await this.db
|
||||
.select()
|
||||
.from(routingRules)
|
||||
.where(
|
||||
or(
|
||||
eq(routingRules.scope, 'system'),
|
||||
and(eq(routingRules.scope, 'user'), eq(routingRules.userId, user.id)),
|
||||
),
|
||||
)
|
||||
.orderBy(asc(routingRules.priority));
|
||||
|
||||
return rows;
|
||||
}
|
||||
|
||||
/**
|
||||
* GET /api/routing/rules/effective
|
||||
* Return the merged rule set in priority order.
|
||||
* User-scoped rules are checked before system rules at the same priority
|
||||
* (achieved by ordering: priority ASC, then scope='user' first).
|
||||
*/
|
||||
@Get('effective')
|
||||
async effective(@CurrentUser() user: { id: string }) {
|
||||
const rows = await this.db
|
||||
.select()
|
||||
.from(routingRules)
|
||||
.where(
|
||||
and(
|
||||
eq(routingRules.enabled, true),
|
||||
or(
|
||||
eq(routingRules.scope, 'system'),
|
||||
and(eq(routingRules.scope, 'user'), eq(routingRules.userId, user.id)),
|
||||
),
|
||||
),
|
||||
)
|
||||
.orderBy(asc(routingRules.priority));
|
||||
|
||||
// For rules with the same priority: user rules beat system rules.
|
||||
// Group by priority then stable-sort each group: user before system.
|
||||
const grouped = new Map<number, typeof rows>();
|
||||
for (const row of rows) {
|
||||
const bucket = grouped.get(row.priority) ?? [];
|
||||
bucket.push(row);
|
||||
grouped.set(row.priority, bucket);
|
||||
}
|
||||
|
||||
const effective: typeof rows = [];
|
||||
for (const [, bucket] of [...grouped.entries()].sort(([a], [b]) => a - b)) {
|
||||
// user-scoped rules first within the same priority bucket
|
||||
const userRules = bucket.filter((r) => r.scope === 'user');
|
||||
const systemRules = bucket.filter((r) => r.scope === 'system');
|
||||
effective.push(...userRules, ...systemRules);
|
||||
}
|
||||
|
||||
return effective;
|
||||
}
|
||||
|
||||
/**
|
||||
* POST /api/routing/rules
|
||||
* Create a new routing rule. Scope is forced to 'user' (users cannot create
|
||||
* system rules). The authenticated user's ID is attached automatically.
|
||||
*/
|
||||
@Post()
|
||||
async create(@Body() dto: CreateRoutingRuleDto, @CurrentUser() user: { id: string }) {
|
||||
const [created] = await this.db
|
||||
.insert(routingRules)
|
||||
.values({
|
||||
name: dto.name,
|
||||
priority: dto.priority,
|
||||
scope: 'user',
|
||||
userId: user.id,
|
||||
conditions: dto.conditions as unknown as Record<string, unknown>[],
|
||||
action: dto.action as unknown as Record<string, unknown>,
|
||||
enabled: dto.enabled ?? true,
|
||||
})
|
||||
.returning();
|
||||
|
||||
return created;
|
||||
}
|
||||
|
||||
/**
|
||||
* PATCH /api/routing/rules/reorder
|
||||
* Reassign priorities so that the order of `ruleIds` reflects ascending
|
||||
* priority (index 0 = priority 0, index 1 = priority 1, …).
|
||||
* Only the authenticated user's own rules can be reordered.
|
||||
*/
|
||||
@Patch('reorder')
|
||||
async reorder(@Body() dto: ReorderRoutingRulesDto, @CurrentUser() user: { id: string }) {
|
||||
// Verify all supplied IDs belong to this user
|
||||
const owned = await this.db
|
||||
.select({ id: routingRules.id })
|
||||
.from(routingRules)
|
||||
.where(
|
||||
and(
|
||||
inArray(routingRules.id, dto.ruleIds),
|
||||
eq(routingRules.scope, 'user'),
|
||||
eq(routingRules.userId, user.id),
|
||||
),
|
||||
);
|
||||
|
||||
const ownedIds = new Set(owned.map((r) => r.id));
|
||||
const unowned = dto.ruleIds.filter((id) => !ownedIds.has(id));
|
||||
if (unowned.length > 0) {
|
||||
throw new ForbiddenException(
|
||||
`Cannot reorder rules that do not belong to you: ${unowned.join(', ')}`,
|
||||
);
|
||||
}
|
||||
|
||||
// Apply new priorities in transaction
|
||||
const updates = await this.db.transaction(async (tx) => {
|
||||
const results = [];
|
||||
for (let i = 0; i < dto.ruleIds.length; i++) {
|
||||
const [updated] = await tx
|
||||
.update(routingRules)
|
||||
.set({ priority: i, updatedAt: new Date() })
|
||||
.where(and(eq(routingRules.id, dto.ruleIds[i]!), eq(routingRules.userId, user.id)))
|
||||
.returning();
|
||||
if (updated) results.push(updated);
|
||||
}
|
||||
return results;
|
||||
});
|
||||
|
||||
return updates;
|
||||
}
|
||||
|
||||
/**
|
||||
* PATCH /api/routing/rules/:id
|
||||
* Update a user-owned rule. System rules cannot be modified by regular users.
|
||||
*/
|
||||
@Patch(':id')
|
||||
async update(
|
||||
@Param('id') id: string,
|
||||
@Body() dto: UpdateRoutingRuleDto,
|
||||
@CurrentUser() user: { id: string },
|
||||
) {
|
||||
const [existing] = await this.db.select().from(routingRules).where(eq(routingRules.id, id));
|
||||
|
||||
if (!existing) throw new NotFoundException('Routing rule not found');
|
||||
|
||||
if (existing.scope === 'system') {
|
||||
throw new ForbiddenException('System routing rules cannot be modified');
|
||||
}
|
||||
|
||||
if (existing.userId !== user.id) {
|
||||
throw new ForbiddenException('Routing rule does not belong to the current user');
|
||||
}
|
||||
|
||||
const updatePayload: Partial<typeof routingRules.$inferInsert> = {
|
||||
updatedAt: new Date(),
|
||||
};
|
||||
|
||||
if (dto.name !== undefined) updatePayload.name = dto.name;
|
||||
if (dto.priority !== undefined) updatePayload.priority = dto.priority;
|
||||
if (dto.conditions !== undefined)
|
||||
updatePayload.conditions = dto.conditions as unknown as Record<string, unknown>[];
|
||||
if (dto.action !== undefined)
|
||||
updatePayload.action = dto.action as unknown as Record<string, unknown>;
|
||||
if (dto.enabled !== undefined) updatePayload.enabled = dto.enabled;
|
||||
|
||||
const [updated] = await this.db
|
||||
.update(routingRules)
|
||||
.set(updatePayload)
|
||||
.where(and(eq(routingRules.id, id), eq(routingRules.userId, user.id)))
|
||||
.returning();
|
||||
|
||||
if (!updated) throw new NotFoundException('Routing rule not found');
|
||||
return updated;
|
||||
}
|
||||
|
||||
/**
|
||||
* DELETE /api/routing/rules/:id
|
||||
* Delete a user-owned routing rule. System rules cannot be deleted.
|
||||
*/
|
||||
@Delete(':id')
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
async remove(@Param('id') id: string, @CurrentUser() user: { id: string }) {
|
||||
const [existing] = await this.db.select().from(routingRules).where(eq(routingRules.id, id));
|
||||
|
||||
if (!existing) throw new NotFoundException('Routing rule not found');
|
||||
|
||||
if (existing.scope === 'system') {
|
||||
throw new ForbiddenException('System routing rules cannot be deleted');
|
||||
}
|
||||
|
||||
if (existing.userId !== user.id) {
|
||||
throw new ForbiddenException('Routing rule does not belong to the current user');
|
||||
}
|
||||
|
||||
const [deleted] = await this.db
|
||||
.delete(routingRules)
|
||||
.where(and(eq(routingRules.id, id), eq(routingRules.userId, user.id)))
|
||||
.returning();
|
||||
|
||||
if (!deleted) throw new NotFoundException('Routing rule not found');
|
||||
}
|
||||
}
|
||||
@@ -1,135 +0,0 @@
|
||||
import {
|
||||
IsArray,
|
||||
IsBoolean,
|
||||
IsInt,
|
||||
IsIn,
|
||||
IsObject,
|
||||
IsOptional,
|
||||
IsString,
|
||||
IsUUID,
|
||||
MaxLength,
|
||||
Min,
|
||||
ValidateNested,
|
||||
ArrayNotEmpty,
|
||||
} from 'class-validator';
|
||||
import { Type } from 'class-transformer';
|
||||
|
||||
// ─── Condition DTO ────────────────────────────────────────────────────────────
|
||||
|
||||
const conditionFields = [
|
||||
'taskType',
|
||||
'complexity',
|
||||
'domain',
|
||||
'costTier',
|
||||
'requiredCapabilities',
|
||||
] as const;
|
||||
const conditionOperators = ['eq', 'in', 'includes'] as const;
|
||||
|
||||
export class RoutingConditionDto {
|
||||
@IsString()
|
||||
@IsIn(conditionFields)
|
||||
field!: (typeof conditionFields)[number];
|
||||
|
||||
@IsString()
|
||||
@IsIn(conditionOperators)
|
||||
operator!: (typeof conditionOperators)[number];
|
||||
|
||||
// value can be string or string[] — keep as unknown and validate at runtime
|
||||
value!: string | string[];
|
||||
}
|
||||
|
||||
// ─── Action DTO ───────────────────────────────────────────────────────────────
|
||||
|
||||
export class RoutingActionDto {
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
provider!: string;
|
||||
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
model!: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsUUID()
|
||||
agentConfigId?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(50_000)
|
||||
systemPromptOverride?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
toolAllowlist?: string[];
|
||||
}
|
||||
|
||||
// ─── Create DTO ───────────────────────────────────────────────────────────────
|
||||
|
||||
const scopeValues = ['system', 'user'] as const;
|
||||
|
||||
export class CreateRoutingRuleDto {
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
name!: string;
|
||||
|
||||
@IsInt()
|
||||
@Min(0)
|
||||
priority!: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsIn(scopeValues)
|
||||
scope?: 'system' | 'user';
|
||||
|
||||
@IsArray()
|
||||
@ValidateNested({ each: true })
|
||||
@Type(() => RoutingConditionDto)
|
||||
conditions!: RoutingConditionDto[];
|
||||
|
||||
@IsObject()
|
||||
@ValidateNested()
|
||||
@Type(() => RoutingActionDto)
|
||||
action!: RoutingActionDto;
|
||||
|
||||
@IsOptional()
|
||||
@IsBoolean()
|
||||
enabled?: boolean;
|
||||
}
|
||||
|
||||
// ─── Update DTO ───────────────────────────────────────────────────────────────
|
||||
|
||||
export class UpdateRoutingRuleDto {
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
name?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(0)
|
||||
priority?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@ValidateNested({ each: true })
|
||||
@Type(() => RoutingConditionDto)
|
||||
conditions?: RoutingConditionDto[];
|
||||
|
||||
@IsOptional()
|
||||
@IsObject()
|
||||
@ValidateNested()
|
||||
@Type(() => RoutingActionDto)
|
||||
action?: RoutingActionDto;
|
||||
|
||||
@IsOptional()
|
||||
@IsBoolean()
|
||||
enabled?: boolean;
|
||||
}
|
||||
|
||||
// ─── Reorder DTO ──────────────────────────────────────────────────────────────
|
||||
|
||||
export class ReorderRoutingRulesDto {
|
||||
@IsArray()
|
||||
@ArrayNotEmpty()
|
||||
@IsUUID(undefined, { each: true })
|
||||
ruleIds!: string[];
|
||||
}
|
||||
@@ -1,118 +0,0 @@
|
||||
/**
|
||||
* Routing engine types — M4-002 (condition types) and M4-003 (action types).
|
||||
*
|
||||
* These types are re-exported from `@mosaic/types` for shared use across packages.
|
||||
*/
|
||||
|
||||
// ─── Classification primitives ───────────────────────────────────────────────
|
||||
|
||||
/** Category of work the agent is being asked to perform */
|
||||
export type TaskType =
|
||||
| 'coding'
|
||||
| 'research'
|
||||
| 'summarization'
|
||||
| 'conversation'
|
||||
| 'analysis'
|
||||
| 'creative';
|
||||
|
||||
/** Estimated complexity of the task, used to bias toward cheaper or more capable models */
|
||||
export type Complexity = 'simple' | 'moderate' | 'complex';
|
||||
|
||||
/** Primary knowledge domain of the task */
|
||||
export type Domain = 'frontend' | 'backend' | 'devops' | 'docs' | 'general';
|
||||
|
||||
/**
|
||||
* Cost tier for model selection.
|
||||
* Extends the existing `CostTier` in `@mosaic/types` with `local` for self-hosted models.
|
||||
*/
|
||||
export type CostTier = 'cheap' | 'standard' | 'premium' | 'local';
|
||||
|
||||
/** Special model capability required by the task */
|
||||
export type Capability = 'tools' | 'vision' | 'long-context' | 'reasoning' | 'embedding';
|
||||
|
||||
// ─── Condition types ─────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* A single predicate that must be satisfied for a routing rule to match.
|
||||
*
|
||||
* - `eq` — scalar equality: `field === value`
|
||||
* - `in` — set membership: `value` contains `field`
|
||||
* - `includes` — array containment: `field` (array) includes `value`
|
||||
*/
|
||||
export interface RoutingCondition {
|
||||
/** The task-classification field to test */
|
||||
field: 'taskType' | 'complexity' | 'domain' | 'costTier' | 'requiredCapabilities';
|
||||
/** Comparison operator */
|
||||
operator: 'eq' | 'in' | 'includes';
|
||||
/** Expected value or set of values */
|
||||
value: string | string[];
|
||||
}
|
||||
|
||||
// ─── Action types ────────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* The routing action to execute when all conditions in a rule are satisfied.
|
||||
*/
|
||||
export interface RoutingAction {
|
||||
/** LLM provider identifier, e.g. `'anthropic'`, `'openai'`, `'ollama'` */
|
||||
provider: string;
|
||||
/** Model identifier, e.g. `'claude-opus-4-6'`, `'gpt-4o'` */
|
||||
model: string;
|
||||
/** Optional: use a specific pre-configured agent config from the agent registry */
|
||||
agentConfigId?: string;
|
||||
/** Optional: override the agent's default system prompt for this route */
|
||||
systemPromptOverride?: string;
|
||||
/** Optional: restrict the tool set available to the agent for this route */
|
||||
toolAllowlist?: string[];
|
||||
}
|
||||
|
||||
// ─── Rule and decision types ─────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Full routing rule as stored in the database and used at runtime.
|
||||
*/
|
||||
export interface RoutingRule {
|
||||
/** UUID primary key */
|
||||
id: string;
|
||||
/** Human-readable rule name */
|
||||
name: string;
|
||||
/** Lower number = evaluated first; unique per scope */
|
||||
priority: number;
|
||||
/** `'system'` rules apply globally; `'user'` rules override for a specific user */
|
||||
scope: 'system' | 'user';
|
||||
/** Present only for `'user'`-scoped rules */
|
||||
userId?: string;
|
||||
/** All conditions must match for the rule to fire */
|
||||
conditions: RoutingCondition[];
|
||||
/** Action to take when all conditions are met */
|
||||
action: RoutingAction;
|
||||
/** Whether this rule is active */
|
||||
enabled: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* Structured representation of what an agent has been asked to do,
|
||||
* produced by the task classifier and consumed by the routing engine.
|
||||
*/
|
||||
export interface TaskClassification {
|
||||
taskType: TaskType;
|
||||
complexity: Complexity;
|
||||
domain: Domain;
|
||||
requiredCapabilities: Capability[];
|
||||
}
|
||||
|
||||
/**
|
||||
* Output of the routing engine — which model to use and why.
|
||||
*/
|
||||
export interface RoutingDecision {
|
||||
/** LLM provider identifier */
|
||||
provider: string;
|
||||
/** Model identifier */
|
||||
model: string;
|
||||
/** Optional agent config to apply */
|
||||
agentConfigId?: string;
|
||||
/** Name of the rule that matched, for observability */
|
||||
ruleName: string;
|
||||
/** Human-readable explanation of why this rule was selected */
|
||||
reason: string;
|
||||
}
|
||||
@@ -1,366 +0,0 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { classifyTask } from './task-classifier.js';
|
||||
|
||||
// ─── Task Type Detection ──────────────────────────────────────────────────────
|
||||
|
||||
describe('classifyTask — taskType', () => {
|
||||
it('detects coding from "code" keyword', () => {
|
||||
expect(classifyTask('Can you write some code for me?').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "implement" keyword', () => {
|
||||
expect(classifyTask('Implement a binary search algorithm').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "function" keyword', () => {
|
||||
expect(classifyTask('Write a function that reverses a string').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "debug" keyword', () => {
|
||||
expect(classifyTask('Help me debug this error').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "fix" keyword', () => {
|
||||
expect(classifyTask('fix the broken test').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "refactor" keyword', () => {
|
||||
expect(classifyTask('Please refactor this module').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "typescript" keyword', () => {
|
||||
expect(classifyTask('How do I use generics in TypeScript?').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "javascript" keyword', () => {
|
||||
expect(classifyTask('JavaScript promises explained').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "python" keyword', () => {
|
||||
expect(classifyTask('Write a Python script to parse CSV').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "SQL" keyword', () => {
|
||||
expect(classifyTask('Write a SQL query to join these tables').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "API" keyword', () => {
|
||||
expect(classifyTask('Design an API for user management').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "endpoint" keyword', () => {
|
||||
expect(classifyTask('Add a new endpoint for user profiles').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "class" keyword', () => {
|
||||
expect(classifyTask('Create a class for handling payments').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from "method" keyword', () => {
|
||||
expect(classifyTask('Add a method to validate emails').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects coding from inline backtick code', () => {
|
||||
expect(classifyTask('What does `Array.prototype.reduce` do?').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
it('detects summarization from "summarize"', () => {
|
||||
expect(classifyTask('Please summarize this document').taskType).toBe('summarization');
|
||||
});
|
||||
|
||||
it('detects summarization from "summary"', () => {
|
||||
expect(classifyTask('Give me a summary of the meeting').taskType).toBe('summarization');
|
||||
});
|
||||
|
||||
it('detects summarization from "tldr"', () => {
|
||||
expect(classifyTask('TLDR this article for me').taskType).toBe('summarization');
|
||||
});
|
||||
|
||||
it('detects summarization from "condense"', () => {
|
||||
expect(classifyTask('Condense this into 3 bullet points').taskType).toBe('summarization');
|
||||
});
|
||||
|
||||
it('detects summarization from "brief"', () => {
|
||||
expect(classifyTask('Give me a brief overview of this topic').taskType).toBe('summarization');
|
||||
});
|
||||
|
||||
it('detects creative from "write"', () => {
|
||||
expect(classifyTask('Write a short story about a dragon').taskType).toBe('creative');
|
||||
});
|
||||
|
||||
it('detects creative from "story"', () => {
|
||||
expect(classifyTask('Tell me a story about space exploration').taskType).toBe('creative');
|
||||
});
|
||||
|
||||
it('detects creative from "poem"', () => {
|
||||
expect(classifyTask('Write a poem about autumn').taskType).toBe('creative');
|
||||
});
|
||||
|
||||
it('detects creative from "generate"', () => {
|
||||
expect(classifyTask('Generate some creative marketing copy').taskType).toBe('creative');
|
||||
});
|
||||
|
||||
it('detects creative from "create content"', () => {
|
||||
expect(classifyTask('Help me create content for my website').taskType).toBe('creative');
|
||||
});
|
||||
|
||||
it('detects creative from "blog post"', () => {
|
||||
expect(classifyTask('Write a blog post about productivity habits').taskType).toBe('creative');
|
||||
});
|
||||
|
||||
it('detects analysis from "analyze"', () => {
|
||||
expect(classifyTask('Analyze the performance of this system').taskType).toBe('analysis');
|
||||
});
|
||||
|
||||
it('detects analysis from "review"', () => {
|
||||
expect(classifyTask('Please review my pull request changes').taskType).toBe('analysis');
|
||||
});
|
||||
|
||||
it('detects analysis from "evaluate"', () => {
|
||||
expect(classifyTask('Evaluate the pros and cons of this approach').taskType).toBe('analysis');
|
||||
});
|
||||
|
||||
it('detects analysis from "assess"', () => {
|
||||
expect(classifyTask('Assess the security risks here').taskType).toBe('analysis');
|
||||
});
|
||||
|
||||
it('detects analysis from "audit"', () => {
|
||||
expect(classifyTask('Audit this codebase for vulnerabilities').taskType).toBe('analysis');
|
||||
});
|
||||
|
||||
it('detects research from "research"', () => {
|
||||
expect(classifyTask('Research the best state management libraries').taskType).toBe('research');
|
||||
});
|
||||
|
||||
it('detects research from "find"', () => {
|
||||
expect(classifyTask('Find all open issues in our backlog').taskType).toBe('research');
|
||||
});
|
||||
|
||||
it('detects research from "search"', () => {
|
||||
expect(classifyTask('Search for papers on transformer architectures').taskType).toBe(
|
||||
'research',
|
||||
);
|
||||
});
|
||||
|
||||
it('detects research from "what is"', () => {
|
||||
expect(classifyTask('What is the difference between REST and GraphQL?').taskType).toBe(
|
||||
'research',
|
||||
);
|
||||
});
|
||||
|
||||
it('detects research from "explain"', () => {
|
||||
expect(classifyTask('Explain how OAuth2 works').taskType).toBe('research');
|
||||
});
|
||||
|
||||
it('detects research from "how does"', () => {
|
||||
expect(classifyTask('How does garbage collection work in V8?').taskType).toBe('research');
|
||||
});
|
||||
|
||||
it('detects research from "compare"', () => {
|
||||
expect(classifyTask('Compare Postgres and MySQL for this use case').taskType).toBe('research');
|
||||
});
|
||||
|
||||
it('falls back to conversation with no strong signal', () => {
|
||||
expect(classifyTask('Hello, how are you?').taskType).toBe('conversation');
|
||||
});
|
||||
|
||||
it('falls back to conversation for generic greetings', () => {
|
||||
expect(classifyTask('Good morning!').taskType).toBe('conversation');
|
||||
});
|
||||
|
||||
// Priority: coding wins over research when both keywords present
|
||||
it('coding takes priority over research', () => {
|
||||
expect(classifyTask('find a code example for sorting').taskType).toBe('coding');
|
||||
});
|
||||
|
||||
// Priority: summarization wins over creative
|
||||
it('summarization takes priority over creative', () => {
|
||||
expect(classifyTask('write a summary of this article').taskType).toBe('summarization');
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Complexity Estimation ────────────────────────────────────────────────────
|
||||
|
||||
describe('classifyTask — complexity', () => {
|
||||
it('classifies short message as simple', () => {
|
||||
expect(classifyTask('Fix typo').complexity).toBe('simple');
|
||||
});
|
||||
|
||||
it('classifies single question as simple', () => {
|
||||
expect(classifyTask('What is a closure?').complexity).toBe('simple');
|
||||
});
|
||||
|
||||
it('classifies message > 500 chars as complex', () => {
|
||||
const long = 'a'.repeat(501);
|
||||
expect(classifyTask(long).complexity).toBe('complex');
|
||||
});
|
||||
|
||||
it('classifies message with "architecture" keyword as complex', () => {
|
||||
expect(
|
||||
classifyTask('Can you help me think through the architecture of this system?').complexity,
|
||||
).toBe('complex');
|
||||
});
|
||||
|
||||
it('classifies message with "design" keyword as complex', () => {
|
||||
expect(classifyTask('Design a data model for this feature').complexity).toBe('complex');
|
||||
});
|
||||
|
||||
it('classifies message with "complex" keyword as complex', () => {
|
||||
expect(classifyTask('This is a complex problem involving multiple services').complexity).toBe(
|
||||
'complex',
|
||||
);
|
||||
});
|
||||
|
||||
it('classifies message with "system" keyword as complex', () => {
|
||||
expect(classifyTask('Explain the whole system behavior').complexity).toBe('complex');
|
||||
});
|
||||
|
||||
it('classifies message with multiple code blocks as complex', () => {
|
||||
const msg = '```\nconst a = 1;\n```\n\nAlso look at\n\n```\nconst b = 2;\n```';
|
||||
expect(classifyTask(msg).complexity).toBe('complex');
|
||||
});
|
||||
|
||||
it('classifies moderate-length message as moderate', () => {
|
||||
const msg =
|
||||
'Please help me implement a small utility function that parses query strings. It should handle arrays and nested objects properly.';
|
||||
expect(classifyTask(msg).complexity).toBe('moderate');
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Domain Detection ─────────────────────────────────────────────────────────
|
||||
|
||||
describe('classifyTask — domain', () => {
|
||||
it('detects frontend from "react"', () => {
|
||||
expect(classifyTask('How do I use React hooks?').domain).toBe('frontend');
|
||||
});
|
||||
|
||||
it('detects frontend from "css"', () => {
|
||||
expect(classifyTask('Fix the CSS layout issue').domain).toBe('frontend');
|
||||
});
|
||||
|
||||
it('detects frontend from "html"', () => {
|
||||
expect(classifyTask('Add an HTML form element').domain).toBe('frontend');
|
||||
});
|
||||
|
||||
it('detects frontend from "component"', () => {
|
||||
expect(classifyTask('Create a reusable component').domain).toBe('frontend');
|
||||
});
|
||||
|
||||
it('detects frontend from "UI"', () => {
|
||||
expect(classifyTask('Update the UI spacing').domain).toBe('frontend');
|
||||
});
|
||||
|
||||
it('detects frontend from "tailwind"', () => {
|
||||
expect(classifyTask('Style this button with Tailwind').domain).toBe('frontend');
|
||||
});
|
||||
|
||||
it('detects frontend from "next.js"', () => {
|
||||
expect(classifyTask('Configure Next.js routing').domain).toBe('frontend');
|
||||
});
|
||||
|
||||
it('detects backend from "server"', () => {
|
||||
expect(classifyTask('Set up the server to handle requests').domain).toBe('backend');
|
||||
});
|
||||
|
||||
it('detects backend from "database"', () => {
|
||||
expect(classifyTask('Optimize this database query').domain).toBe('backend');
|
||||
});
|
||||
|
||||
it('detects backend from "endpoint"', () => {
|
||||
expect(classifyTask('Add an endpoint for authentication').domain).toBe('backend');
|
||||
});
|
||||
|
||||
it('detects backend from "nest"', () => {
|
||||
expect(classifyTask('Add a NestJS guard for this route').domain).toBe('backend');
|
||||
});
|
||||
|
||||
it('detects backend from "express"', () => {
|
||||
expect(classifyTask('Middleware in Express explained').domain).toBe('backend');
|
||||
});
|
||||
|
||||
it('detects devops from "docker"', () => {
|
||||
expect(classifyTask('Write a Dockerfile for this app').domain).toBe('devops');
|
||||
});
|
||||
|
||||
it('detects devops from "deploy"', () => {
|
||||
expect(classifyTask('Deploy this service to production').domain).toBe('devops');
|
||||
});
|
||||
|
||||
it('detects devops from "pipeline"', () => {
|
||||
expect(classifyTask('Set up a CI pipeline').domain).toBe('devops');
|
||||
});
|
||||
|
||||
it('detects devops from "kubernetes"', () => {
|
||||
expect(classifyTask('Configure a Kubernetes deployment').domain).toBe('devops');
|
||||
});
|
||||
|
||||
it('detects docs from "documentation"', () => {
|
||||
expect(classifyTask('Write documentation for this module').domain).toBe('docs');
|
||||
});
|
||||
|
||||
it('detects docs from "readme"', () => {
|
||||
expect(classifyTask('Update the README').domain).toBe('docs');
|
||||
});
|
||||
|
||||
it('detects docs from "guide"', () => {
|
||||
expect(classifyTask('Create a user guide for this feature').domain).toBe('docs');
|
||||
});
|
||||
|
||||
it('falls back to general domain', () => {
|
||||
expect(classifyTask('What time is it?').domain).toBe('general');
|
||||
});
|
||||
|
||||
// devops takes priority over backend when both match
|
||||
it('devops takes priority over backend (both keywords)', () => {
|
||||
expect(classifyTask('Deploy the API server using Docker').domain).toBe('devops');
|
||||
});
|
||||
|
||||
// docs takes priority over frontend when both match
|
||||
it('docs takes priority over frontend (both keywords)', () => {
|
||||
expect(classifyTask('Write documentation for React components').domain).toBe('docs');
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Combined Classification ──────────────────────────────────────────────────
|
||||
|
||||
describe('classifyTask — combined', () => {
|
||||
it('returns full classification object', () => {
|
||||
const result = classifyTask('Fix the bug?');
|
||||
expect(result).toHaveProperty('taskType');
|
||||
expect(result).toHaveProperty('complexity');
|
||||
expect(result).toHaveProperty('domain');
|
||||
});
|
||||
|
||||
it('classifies complex TypeScript architecture request', () => {
|
||||
const msg =
|
||||
'Design the architecture for a multi-tenant TypeScript system using NestJS with proper database isolation and role-based access control. The system needs to support multiple organizations each with their own data namespace.';
|
||||
const result = classifyTask(msg);
|
||||
expect(result.taskType).toBe('coding');
|
||||
expect(result.complexity).toBe('complex');
|
||||
expect(result.domain).toBe('backend');
|
||||
});
|
||||
|
||||
it('classifies simple frontend question', () => {
|
||||
const result = classifyTask('How do I center a div in CSS?');
|
||||
expect(result.taskType).toBe('research');
|
||||
expect(result.domain).toBe('frontend');
|
||||
});
|
||||
|
||||
it('classifies a DevOps pipeline task as complex', () => {
|
||||
const msg =
|
||||
'Design a complete CI/CD pipeline architecture using Docker and Kubernetes with blue-green deployments and automatic rollback capabilities for a complex microservices system.';
|
||||
const result = classifyTask(msg);
|
||||
expect(result.domain).toBe('devops');
|
||||
expect(result.complexity).toBe('complex');
|
||||
});
|
||||
|
||||
it('classifies summarization task correctly', () => {
|
||||
const result = classifyTask('Summarize the key points from this document');
|
||||
expect(result.taskType).toBe('summarization');
|
||||
});
|
||||
|
||||
it('classifies creative writing task correctly', () => {
|
||||
const result = classifyTask('Write a poem about the ocean');
|
||||
expect(result.taskType).toBe('creative');
|
||||
});
|
||||
});
|
||||
@@ -1,159 +0,0 @@
|
||||
import type { TaskType, Complexity, Domain, TaskClassification } from './routing.types.js';
|
||||
|
||||
// ─── Pattern Banks ──────────────────────────────────────────────────────────
|
||||
|
||||
const CODING_PATTERNS: RegExp[] = [
|
||||
/\bcode\b/i,
|
||||
/\bfunction\b/i,
|
||||
/\bimplement\b/i,
|
||||
/\bdebug\b/i,
|
||||
/\bfix\b/i,
|
||||
/\brefactor\b/i,
|
||||
/\btypescript\b/i,
|
||||
/\bjavascript\b/i,
|
||||
/\bpython\b/i,
|
||||
/\bSQL\b/i,
|
||||
/\bAPI\b/i,
|
||||
/\bendpoint\b/i,
|
||||
/\bclass\b/i,
|
||||
/\bmethod\b/i,
|
||||
/`[^`]*`/,
|
||||
];
|
||||
|
||||
const RESEARCH_PATTERNS: RegExp[] = [
|
||||
/\bresearch\b/i,
|
||||
/\bfind\b/i,
|
||||
/\bsearch\b/i,
|
||||
/\bwhat is\b/i,
|
||||
/\bexplain\b/i,
|
||||
/\bhow do(es)?\b/i,
|
||||
/\bcompare\b/i,
|
||||
/\banalyze\b/i,
|
||||
];
|
||||
|
||||
const SUMMARIZATION_PATTERNS: RegExp[] = [
|
||||
/\bsummariz(e|ation)\b/i,
|
||||
/\bsummary\b/i,
|
||||
/\btldr\b/i,
|
||||
/\bcondense\b/i,
|
||||
/\bbrief\b/i,
|
||||
];
|
||||
|
||||
const CREATIVE_PATTERNS: RegExp[] = [
|
||||
/\bwrite\b/i,
|
||||
/\bstory\b/i,
|
||||
/\bpoem\b/i,
|
||||
/\bgenerate\b/i,
|
||||
/\bcreate content\b/i,
|
||||
/\bblog post\b/i,
|
||||
];
|
||||
|
||||
const ANALYSIS_PATTERNS: RegExp[] = [
|
||||
/\banalyze\b/i,
|
||||
/\breview\b/i,
|
||||
/\bevaluate\b/i,
|
||||
/\bassess\b/i,
|
||||
/\baudit\b/i,
|
||||
];
|
||||
|
||||
// ─── Complexity Indicators ───────────────────────────────────────────────────
|
||||
|
||||
const COMPLEX_KEYWORDS: RegExp[] = [
|
||||
/\barchitecture\b/i,
|
||||
/\bdesign\b/i,
|
||||
/\bcomplex\b/i,
|
||||
/\bsystem\b/i,
|
||||
];
|
||||
|
||||
const SIMPLE_QUESTION_PATTERN = /^[^.!?]+[?]$/;
|
||||
|
||||
/** Counts occurrences of triple-backtick code fences in the message */
|
||||
function countCodeBlocks(message: string): number {
|
||||
return (message.match(/```/g) ?? []).length / 2;
|
||||
}
|
||||
|
||||
// ─── Domain Indicators ───────────────────────────────────────────────────────
|
||||
|
||||
const FRONTEND_PATTERNS: RegExp[] = [
|
||||
/\breact\b/i,
|
||||
/\bcss\b/i,
|
||||
/\bhtml\b/i,
|
||||
/\bcomponent\b/i,
|
||||
/\bUI\b/,
|
||||
/\btailwind\b/i,
|
||||
/\bnext\.js\b/i,
|
||||
];
|
||||
|
||||
const BACKEND_PATTERNS: RegExp[] = [
|
||||
/\bAPI\b/i,
|
||||
/\bserver\b/i,
|
||||
/\bdatabase\b/i,
|
||||
/\bendpoint\b/i,
|
||||
/\bnest(js)?\b/i,
|
||||
/\bexpress\b/i,
|
||||
];
|
||||
|
||||
const DEVOPS_PATTERNS: RegExp[] = [
|
||||
/\bdocker(file|compose|hub)?\b/i,
|
||||
/\bCI\b/,
|
||||
/\bdeploy\b/i,
|
||||
/\bpipeline\b/i,
|
||||
/\bkubernetes\b/i,
|
||||
];
|
||||
|
||||
const DOCS_PATTERNS: RegExp[] = [/\bdocumentation\b/i, /\breadme\b/i, /\bguide\b/i];
|
||||
|
||||
// ─── Helpers ─────────────────────────────────────────────────────────────────
|
||||
|
||||
function matchesAny(message: string, patterns: RegExp[]): boolean {
|
||||
return patterns.some((p) => p.test(message));
|
||||
}
|
||||
|
||||
// ─── Classifier ──────────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Classify a task based on the user's message using deterministic regex/keyword matching.
|
||||
* No LLM calls are made — this is a pure, fast, synchronous classification.
|
||||
*/
|
||||
export function classifyTask(message: string): TaskClassification {
|
||||
return {
|
||||
taskType: detectTaskType(message),
|
||||
complexity: estimateComplexity(message),
|
||||
domain: detectDomain(message),
|
||||
requiredCapabilities: [],
|
||||
};
|
||||
}
|
||||
|
||||
function detectTaskType(message: string): TaskType {
|
||||
if (matchesAny(message, CODING_PATTERNS)) return 'coding';
|
||||
if (matchesAny(message, SUMMARIZATION_PATTERNS)) return 'summarization';
|
||||
if (matchesAny(message, CREATIVE_PATTERNS)) return 'creative';
|
||||
if (matchesAny(message, ANALYSIS_PATTERNS)) return 'analysis';
|
||||
if (matchesAny(message, RESEARCH_PATTERNS)) return 'research';
|
||||
return 'conversation';
|
||||
}
|
||||
|
||||
function estimateComplexity(message: string): Complexity {
|
||||
const trimmed = message.trim();
|
||||
const codeBlocks = countCodeBlocks(trimmed);
|
||||
|
||||
// Complex: long messages, multiple code blocks, or complexity keywords
|
||||
if (trimmed.length > 500 || codeBlocks > 1 || matchesAny(trimmed, COMPLEX_KEYWORDS)) {
|
||||
return 'complex';
|
||||
}
|
||||
|
||||
// Simple: short messages or a single direct question
|
||||
if (trimmed.length < 100 || SIMPLE_QUESTION_PATTERN.test(trimmed)) {
|
||||
return 'simple';
|
||||
}
|
||||
|
||||
return 'moderate';
|
||||
}
|
||||
|
||||
function detectDomain(message: string): Domain {
|
||||
if (matchesAny(message, DEVOPS_PATTERNS)) return 'devops';
|
||||
if (matchesAny(message, DOCS_PATTERNS)) return 'docs';
|
||||
if (matchesAny(message, FRONTEND_PATTERNS)) return 'frontend';
|
||||
if (matchesAny(message, BACKEND_PATTERNS)) return 'backend';
|
||||
return 'general';
|
||||
}
|
||||
@@ -1,65 +1,14 @@
|
||||
/** Token usage metrics for a session (M5-007). */
|
||||
export interface SessionTokenMetrics {
|
||||
input: number;
|
||||
output: number;
|
||||
cacheRead: number;
|
||||
cacheWrite: number;
|
||||
total: number;
|
||||
}
|
||||
|
||||
/** Per-session metrics tracked throughout the session lifetime (M5-007). */
|
||||
export interface SessionMetrics {
|
||||
tokens: SessionTokenMetrics;
|
||||
modelSwitches: number;
|
||||
messageCount: number;
|
||||
lastActivityAt: string;
|
||||
}
|
||||
|
||||
export interface SessionInfoDto {
|
||||
id: string;
|
||||
provider: string;
|
||||
modelId: string;
|
||||
/** M5-005: human-readable agent name when an agent config is applied. */
|
||||
agentName?: string;
|
||||
createdAt: string;
|
||||
promptCount: number;
|
||||
channels: string[];
|
||||
durationMs: number;
|
||||
/** M5-007: per-session metrics (token usage, model switches, etc.) */
|
||||
metrics: SessionMetrics;
|
||||
}
|
||||
|
||||
export interface SessionListDto {
|
||||
sessions: SessionInfoDto[];
|
||||
total: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Options accepted when creating an agent session.
|
||||
* All fields are optional; omitting them falls back to env-var or process defaults.
|
||||
*/
|
||||
export interface CreateSessionOptionsDto {
|
||||
/** Provider name (e.g. "anthropic", "openai"). */
|
||||
provider?: string;
|
||||
/** Model ID to use for this session. */
|
||||
modelId?: string;
|
||||
/**
|
||||
* Sandbox working directory for the session.
|
||||
* File, git, and shell tools will be restricted to this directory.
|
||||
* Defaults to AGENT_FILE_SANDBOX_DIR env var or process.cwd().
|
||||
*/
|
||||
sandboxDir?: string;
|
||||
/**
|
||||
* Platform-level system prompt for this session.
|
||||
* Merged with skill prompt additions (platform prompt first, then skills).
|
||||
* Falls back to AGENT_SYSTEM_PROMPT env var when omitted.
|
||||
*/
|
||||
systemPrompt?: string;
|
||||
/**
|
||||
* Explicit allowlist of tool names available in this session.
|
||||
* When provided, only listed tools are registered with the agent.
|
||||
* Admins receive all tools; regular users fall back to AGENT_USER_TOOLS
|
||||
* env var (comma-separated) when this field is not supplied.
|
||||
*/
|
||||
allowedTools?: string[];
|
||||
}
|
||||
|
||||
@@ -1,59 +0,0 @@
|
||||
import { Inject, Injectable, Logger } from '@nestjs/common';
|
||||
import type { ToolDefinition } from '@mariozechner/pi-coding-agent';
|
||||
import { SkillsService } from '../skills/skills.service.js';
|
||||
import { createSkillTools } from './tools/skill-tools.js';
|
||||
|
||||
export interface LoadedSkills {
|
||||
/** Meta-tools: skill_list + skill_invoke */
|
||||
metaTools: ToolDefinition[];
|
||||
/**
|
||||
* System prompt additions from enabled prompt-type skills.
|
||||
* Callers may prepend these to the session system prompt.
|
||||
*/
|
||||
promptAdditions: string[];
|
||||
}
|
||||
|
||||
/**
|
||||
* SkillLoaderService is responsible for:
|
||||
* 1. Providing the skill meta-tools (skill_list, skill_invoke) to agent sessions.
|
||||
* 2. Collecting system-prompt additions from enabled prompt-type skills.
|
||||
*/
|
||||
@Injectable()
|
||||
export class SkillLoaderService {
|
||||
private readonly logger = new Logger(SkillLoaderService.name);
|
||||
|
||||
constructor(@Inject(SkillsService) private readonly skillsService: SkillsService) {}
|
||||
|
||||
/**
|
||||
* Load enabled skills and return tools + prompt additions for a new session.
|
||||
*/
|
||||
async loadForSession(): Promise<LoadedSkills> {
|
||||
const metaTools = createSkillTools(this.skillsService);
|
||||
|
||||
let promptAdditions: string[] = [];
|
||||
try {
|
||||
const enabledSkills = await this.skillsService.findEnabled();
|
||||
promptAdditions = enabledSkills.flatMap((skill) => {
|
||||
const config = (skill.config ?? {}) as Record<string, unknown>;
|
||||
const skillType = (config['type'] as string | undefined) ?? 'prompt';
|
||||
if (skillType === 'prompt') {
|
||||
const addition = (config['prompt'] as string | undefined) ?? skill.description;
|
||||
return addition ? [addition] : [];
|
||||
}
|
||||
return [];
|
||||
});
|
||||
|
||||
this.logger.log(
|
||||
`Loaded ${enabledSkills.length} enabled skill(s), ` +
|
||||
`${promptAdditions.length} prompt addition(s)`,
|
||||
);
|
||||
} catch (err) {
|
||||
// Non-fatal: log and continue without prompt additions
|
||||
this.logger.warn(
|
||||
`Failed to load skill prompt additions: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
}
|
||||
|
||||
return { metaTools, promptAdditions };
|
||||
}
|
||||
}
|
||||
@@ -1,358 +0,0 @@
|
||||
import { Type } from '@sinclair/typebox';
|
||||
import type { ToolDefinition } from '@mariozechner/pi-coding-agent';
|
||||
import { readFile, writeFile, readdir, stat } from 'node:fs/promises';
|
||||
import { guardPath, guardPathUnsafe, SandboxEscapeError } from './path-guard.js';
|
||||
|
||||
const MAX_READ_BYTES = 512 * 1024; // 512 KB read limit
|
||||
const MAX_WRITE_BYTES = 1024 * 1024; // 1 MB write limit
|
||||
|
||||
export function createFileTools(baseDir: string): ToolDefinition[] {
|
||||
const readFileTool: ToolDefinition = {
|
||||
name: 'fs_read_file',
|
||||
label: 'Read File',
|
||||
description:
|
||||
'Read the contents of a file. Path is resolved relative to the sandbox base directory.',
|
||||
parameters: Type.Object({
|
||||
path: Type.String({
|
||||
description: 'File path (relative to sandbox base or absolute within it)',
|
||||
}),
|
||||
encoding: Type.Optional(
|
||||
Type.String({ description: 'Encoding: utf8 (default), base64, hex' }),
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
const { path, encoding } = params as { path: string; encoding?: string };
|
||||
let safePath: string;
|
||||
try {
|
||||
safePath = guardPath(path, baseDir);
|
||||
} catch (err) {
|
||||
if (err instanceof SandboxEscapeError) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${err.message}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
try {
|
||||
const info = await stat(safePath);
|
||||
if (!info.isFile()) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: path is not a file: ${path}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
if (info.size > MAX_READ_BYTES) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `Error: file too large (${info.size} bytes, limit ${MAX_READ_BYTES} bytes)`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
const enc = (encoding ?? 'utf8') as BufferEncoding;
|
||||
const content = await readFile(safePath, { encoding: enc });
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: String(content) }],
|
||||
details: undefined,
|
||||
};
|
||||
} catch (err) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error reading file: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
const writeFileTool: ToolDefinition = {
|
||||
name: 'fs_write_file',
|
||||
label: 'Write File',
|
||||
description:
|
||||
'Write content to a file. Path is resolved relative to the sandbox base directory. Overwrites existing file.',
|
||||
parameters: Type.Object({
|
||||
path: Type.String({
|
||||
description: 'File path (relative to sandbox base or absolute within it)',
|
||||
}),
|
||||
content: Type.String({ description: 'Content to write' }),
|
||||
encoding: Type.Optional(Type.String({ description: 'Encoding: utf8 (default), base64' })),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
const { path, content, encoding } = params as {
|
||||
path: string;
|
||||
content: string;
|
||||
encoding?: string;
|
||||
};
|
||||
let safePath: string;
|
||||
try {
|
||||
safePath = guardPathUnsafe(path, baseDir);
|
||||
} catch (err) {
|
||||
if (err instanceof SandboxEscapeError) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${err.message}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
if (Buffer.byteLength(content, 'utf8') > MAX_WRITE_BYTES) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `Error: content too large (limit ${MAX_WRITE_BYTES} bytes)`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
try {
|
||||
const enc = (encoding ?? 'utf8') as BufferEncoding;
|
||||
await writeFile(safePath, content, { encoding: enc });
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `File written successfully: ${path}` }],
|
||||
details: undefined,
|
||||
};
|
||||
} catch (err) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error writing file: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
const listDirectoryTool: ToolDefinition = {
|
||||
name: 'fs_list_directory',
|
||||
label: 'List Directory',
|
||||
description: 'List files and directories at a given path within the sandbox base directory.',
|
||||
parameters: Type.Object({
|
||||
path: Type.Optional(
|
||||
Type.String({
|
||||
description: 'Directory path (relative to sandbox base). Defaults to base directory.',
|
||||
}),
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
const { path } = params as { path?: string };
|
||||
const target = path ?? '.';
|
||||
let safePath: string;
|
||||
try {
|
||||
safePath = guardPath(target, baseDir);
|
||||
} catch (err) {
|
||||
if (err instanceof SandboxEscapeError) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${err.message}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
try {
|
||||
const info = await stat(safePath);
|
||||
if (!info.isDirectory()) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: path is not a directory: ${target}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
const entries = await readdir(safePath, { withFileTypes: true });
|
||||
const items = entries.map((e) => ({
|
||||
name: e.name,
|
||||
type: e.isDirectory() ? 'directory' : e.isSymbolicLink() ? 'symlink' : 'file',
|
||||
}));
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: JSON.stringify(items, null, 2) }],
|
||||
details: undefined,
|
||||
};
|
||||
} catch (err) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error listing directory: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
const editFileTool: ToolDefinition = {
|
||||
name: 'fs_edit_file',
|
||||
label: 'Edit File',
|
||||
description:
|
||||
'Make targeted text replacements in a file. Each edit replaces an exact match of oldText with newText. ' +
|
||||
'All edits are matched against the original file content (not incrementally). ' +
|
||||
'Each oldText must be unique in the file and edits must not overlap.',
|
||||
parameters: Type.Object({
|
||||
path: Type.String({
|
||||
description: 'File path (relative to sandbox base or absolute within it)',
|
||||
}),
|
||||
edits: Type.Array(
|
||||
Type.Object({
|
||||
oldText: Type.String({
|
||||
description: 'Exact text to find and replace (must be unique in the file)',
|
||||
}),
|
||||
newText: Type.String({ description: 'Replacement text' }),
|
||||
}),
|
||||
{ description: 'One or more targeted replacements', minItems: 1 },
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
const { path, edits } = params as {
|
||||
path: string;
|
||||
edits: Array<{ oldText: string; newText: string }>;
|
||||
};
|
||||
|
||||
let safePath: string;
|
||||
try {
|
||||
safePath = guardPath(path, baseDir);
|
||||
} catch (err) {
|
||||
if (err instanceof SandboxEscapeError) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${err.message}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
try {
|
||||
const info = await stat(safePath);
|
||||
if (!info.isFile()) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: path is not a file: ${path}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
if (info.size > MAX_READ_BYTES) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `Error: file too large for editing (${info.size} bytes, limit ${MAX_READ_BYTES} bytes)`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
} catch (err) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error reading file: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
let content: string;
|
||||
try {
|
||||
content = await readFile(safePath, { encoding: 'utf8' });
|
||||
} catch (err) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error reading file: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
// Validate all edits before applying any
|
||||
const errors: string[] = [];
|
||||
for (let i = 0; i < edits.length; i++) {
|
||||
const edit = edits[i]!;
|
||||
const occurrences = content.split(edit.oldText).length - 1;
|
||||
if (occurrences === 0) {
|
||||
errors.push(`Edit ${i + 1}: oldText not found in file`);
|
||||
} else if (occurrences > 1) {
|
||||
errors.push(`Edit ${i + 1}: oldText matches ${occurrences} locations (must be unique)`);
|
||||
}
|
||||
}
|
||||
|
||||
// Check for overlapping edits
|
||||
if (errors.length === 0) {
|
||||
const positions = edits.map((edit, i) => ({
|
||||
index: i,
|
||||
start: content.indexOf(edit.oldText),
|
||||
end: content.indexOf(edit.oldText) + edit.oldText.length,
|
||||
}));
|
||||
positions.sort((a, b) => a.start - b.start);
|
||||
for (let i = 1; i < positions.length; i++) {
|
||||
if (positions[i]!.start < positions[i - 1]!.end) {
|
||||
errors.push(
|
||||
`Edits ${positions[i - 1]!.index + 1} and ${positions[i]!.index + 1} overlap`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (errors.length > 0) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `Edit validation failed:\n${errors.join('\n')}`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
// Apply edits: process from end to start to preserve positions
|
||||
const positions = edits.map((edit) => ({
|
||||
edit,
|
||||
start: content.indexOf(edit.oldText),
|
||||
}));
|
||||
positions.sort((a, b) => b.start - a.start); // reverse order
|
||||
|
||||
let result = content;
|
||||
for (const { edit } of positions) {
|
||||
result = result.replace(edit.oldText, edit.newText);
|
||||
}
|
||||
|
||||
if (Buffer.byteLength(result, 'utf8') > MAX_WRITE_BYTES) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `Error: resulting file too large (limit ${MAX_WRITE_BYTES} bytes)`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
try {
|
||||
await writeFile(safePath, result, { encoding: 'utf8' });
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `File edited successfully: ${path} (${edits.length} edit(s) applied)`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
} catch (err) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error writing file: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
return [readFileTool, writeFileTool, listDirectoryTool, editFileTool];
|
||||
}
|
||||
@@ -1,212 +0,0 @@
|
||||
import { Type } from '@sinclair/typebox';
|
||||
import type { ToolDefinition } from '@mariozechner/pi-coding-agent';
|
||||
import { exec } from 'node:child_process';
|
||||
import { promisify } from 'node:util';
|
||||
import { guardPath, guardPathUnsafe, SandboxEscapeError } from './path-guard.js';
|
||||
|
||||
const execAsync = promisify(exec);
|
||||
|
||||
const GIT_TIMEOUT_MS = 15_000;
|
||||
const MAX_OUTPUT_BYTES = 100 * 1024; // 100 KB
|
||||
|
||||
async function runGit(
|
||||
args: string[],
|
||||
cwd?: string,
|
||||
): Promise<{ stdout: string; stderr: string; error?: string }> {
|
||||
// Only allow specific safe read-only git subcommands
|
||||
const allowedSubcommands = ['status', 'log', 'diff', 'show', 'branch', 'tag', 'ls-files'];
|
||||
const subcommand = args[0];
|
||||
if (!subcommand || !allowedSubcommands.includes(subcommand)) {
|
||||
return {
|
||||
stdout: '',
|
||||
stderr: '',
|
||||
error: `Blocked: git subcommand "${subcommand}" is not allowed. Permitted: ${allowedSubcommands.join(', ')}`,
|
||||
};
|
||||
}
|
||||
|
||||
const cmd = `git ${args.map((a) => JSON.stringify(a)).join(' ')}`;
|
||||
try {
|
||||
const { stdout, stderr } = await execAsync(cmd, {
|
||||
cwd,
|
||||
timeout: GIT_TIMEOUT_MS,
|
||||
maxBuffer: MAX_OUTPUT_BYTES,
|
||||
});
|
||||
return { stdout, stderr };
|
||||
} catch (err: unknown) {
|
||||
const e = err as { stdout?: string; stderr?: string; message?: string };
|
||||
return {
|
||||
stdout: e.stdout ?? '',
|
||||
stderr: e.stderr ?? '',
|
||||
error: e.message ?? String(err),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
export function createGitTools(sandboxDir?: string): ToolDefinition[] {
|
||||
const defaultCwd = sandboxDir ?? process.cwd();
|
||||
|
||||
const gitStatus: ToolDefinition = {
|
||||
name: 'git_status',
|
||||
label: 'Git Status',
|
||||
description: 'Show the working tree status (staged, unstaged, untracked files).',
|
||||
parameters: Type.Object({
|
||||
cwd: Type.Optional(
|
||||
Type.String({
|
||||
description: 'Repository working directory (relative to sandbox or absolute within it).',
|
||||
}),
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
const { cwd } = params as { cwd?: string };
|
||||
let safeCwd: string;
|
||||
try {
|
||||
safeCwd = guardPath(cwd ?? '.', defaultCwd);
|
||||
} catch (err) {
|
||||
if (err instanceof SandboxEscapeError) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${err.message}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
const result = await runGit(['status', '--short', '--branch'], safeCwd);
|
||||
const text = result.error
|
||||
? `Error: ${result.error}\n${result.stderr}`
|
||||
: result.stdout || '(no output)';
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: text }],
|
||||
details: undefined,
|
||||
};
|
||||
},
|
||||
};
|
||||
|
||||
const gitLog: ToolDefinition = {
|
||||
name: 'git_log',
|
||||
label: 'Git Log',
|
||||
description: 'Show recent commit history.',
|
||||
parameters: Type.Object({
|
||||
limit: Type.Optional(Type.Number({ description: 'Number of commits to show (default 20)' })),
|
||||
oneline: Type.Optional(
|
||||
Type.Boolean({ description: 'Compact one-line format (default true)' }),
|
||||
),
|
||||
cwd: Type.Optional(
|
||||
Type.String({
|
||||
description: 'Repository working directory (relative to sandbox or absolute within it).',
|
||||
}),
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
const { limit, oneline, cwd } = params as {
|
||||
limit?: number;
|
||||
oneline?: boolean;
|
||||
cwd?: string;
|
||||
};
|
||||
let safeCwd: string;
|
||||
try {
|
||||
safeCwd = guardPath(cwd ?? '.', defaultCwd);
|
||||
} catch (err) {
|
||||
if (err instanceof SandboxEscapeError) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${err.message}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
const args = ['log', `--max-count=${limit ?? 20}`];
|
||||
if (oneline !== false) args.push('--oneline');
|
||||
const result = await runGit(args, safeCwd);
|
||||
const text = result.error
|
||||
? `Error: ${result.error}\n${result.stderr}`
|
||||
: result.stdout || '(no commits)';
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: text }],
|
||||
details: undefined,
|
||||
};
|
||||
},
|
||||
};
|
||||
|
||||
const gitDiff: ToolDefinition = {
|
||||
name: 'git_diff',
|
||||
label: 'Git Diff',
|
||||
description: 'Show changes between commits, working tree, or staged changes.',
|
||||
parameters: Type.Object({
|
||||
staged: Type.Optional(
|
||||
Type.Boolean({ description: 'Show staged (cached) changes instead of unstaged' }),
|
||||
),
|
||||
ref: Type.Optional(
|
||||
Type.String({ description: 'Compare against this ref (commit SHA, branch, or tag)' }),
|
||||
),
|
||||
path: Type.Optional(
|
||||
Type.String({ description: 'Limit diff to a specific file or directory' }),
|
||||
),
|
||||
cwd: Type.Optional(
|
||||
Type.String({
|
||||
description: 'Repository working directory (relative to sandbox or absolute within it).',
|
||||
}),
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
const { staged, ref, path, cwd } = params as {
|
||||
staged?: boolean;
|
||||
ref?: string;
|
||||
path?: string;
|
||||
cwd?: string;
|
||||
};
|
||||
let safeCwd: string;
|
||||
try {
|
||||
safeCwd = guardPath(cwd ?? '.', defaultCwd);
|
||||
} catch (err) {
|
||||
if (err instanceof SandboxEscapeError) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${err.message}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
let safePath: string | undefined;
|
||||
if (path !== undefined) {
|
||||
try {
|
||||
safePath = guardPathUnsafe(path, defaultCwd);
|
||||
} catch (err) {
|
||||
if (err instanceof SandboxEscapeError) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${err.message}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
}
|
||||
const args = ['diff'];
|
||||
if (staged) args.push('--cached');
|
||||
if (ref) args.push(ref);
|
||||
args.push('--');
|
||||
if (safePath !== undefined) args.push(safePath);
|
||||
const result = await runGit(args, safeCwd);
|
||||
const text = result.error
|
||||
? `Error: ${result.error}\n${result.stderr}`
|
||||
: result.stdout || '(no diff)';
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: text }],
|
||||
details: undefined,
|
||||
};
|
||||
},
|
||||
};
|
||||
|
||||
return [gitStatus, gitLog, gitDiff];
|
||||
}
|
||||
@@ -1,8 +1,2 @@
|
||||
export { createBrainTools } from './brain-tools.js';
|
||||
export { createCoordTools } from './coord-tools.js';
|
||||
export { createFileTools } from './file-tools.js';
|
||||
export { createGitTools } from './git-tools.js';
|
||||
export { createSearchTools } from './search-tools.js';
|
||||
export { createShellTools } from './shell-tools.js';
|
||||
export { createWebTools } from './web-tools.js';
|
||||
export { createSkillTools } from './skill-tools.js';
|
||||
|
||||
@@ -3,45 +3,23 @@ import type { ToolDefinition } from '@mariozechner/pi-coding-agent';
|
||||
import type { Memory } from '@mosaic/memory';
|
||||
import type { EmbeddingProvider } from '@mosaic/memory';
|
||||
|
||||
/**
|
||||
* Create memory tools bound to the session's authenticated userId.
|
||||
*
|
||||
* SECURITY: userId is resolved from the authenticated session at tool-creation
|
||||
* time and is never accepted as a user-supplied or LLM-supplied parameter.
|
||||
* This prevents cross-user data access via parameter injection.
|
||||
*/
|
||||
export function createMemoryTools(
|
||||
memory: Memory,
|
||||
embeddingProvider: EmbeddingProvider | null,
|
||||
/** Authenticated user ID from the session. All memory operations are scoped to this user. */
|
||||
sessionUserId: string | undefined,
|
||||
): ToolDefinition[] {
|
||||
/** Return an error result when no session user is bound. */
|
||||
function noUserError() {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: 'Memory tools unavailable — no authenticated user bound to this session',
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
const searchMemory: ToolDefinition = {
|
||||
name: 'memory_search',
|
||||
label: 'Search Memory',
|
||||
description:
|
||||
'Search across stored insights and knowledge using natural language. Returns semantically similar results.',
|
||||
parameters: Type.Object({
|
||||
userId: Type.String({ description: 'User ID to search memory for' }),
|
||||
query: Type.String({ description: 'Natural language search query' }),
|
||||
limit: Type.Optional(Type.Number({ description: 'Max results (default 5)' })),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
if (!sessionUserId) return noUserError();
|
||||
|
||||
const { query, limit } = params as {
|
||||
const { userId, query, limit } = params as {
|
||||
userId: string;
|
||||
query: string;
|
||||
limit?: number;
|
||||
};
|
||||
@@ -59,7 +37,7 @@ export function createMemoryTools(
|
||||
}
|
||||
|
||||
const embedding = await embeddingProvider.embed(query);
|
||||
const results = await memory.insights.searchByEmbedding(sessionUserId, embedding, limit ?? 5);
|
||||
const results = await memory.insights.searchByEmbedding(userId, embedding, limit ?? 5);
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: JSON.stringify(results, null, 2) }],
|
||||
details: undefined,
|
||||
@@ -70,8 +48,9 @@ export function createMemoryTools(
|
||||
const getPreferences: ToolDefinition = {
|
||||
name: 'memory_get_preferences',
|
||||
label: 'Get User Preferences',
|
||||
description: 'Retrieve stored preferences for the current session user.',
|
||||
description: 'Retrieve stored preferences for a user.',
|
||||
parameters: Type.Object({
|
||||
userId: Type.String({ description: 'User ID' }),
|
||||
category: Type.Optional(
|
||||
Type.String({
|
||||
description: 'Filter by category: communication, coding, workflow, appearance, general',
|
||||
@@ -79,13 +58,11 @@ export function createMemoryTools(
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
if (!sessionUserId) return noUserError();
|
||||
|
||||
const { category } = params as { category?: string };
|
||||
const { userId, category } = params as { userId: string; category?: string };
|
||||
type Cat = 'communication' | 'coding' | 'workflow' | 'appearance' | 'general';
|
||||
const prefs = category
|
||||
? await memory.preferences.findByUserAndCategory(sessionUserId, category as Cat)
|
||||
: await memory.preferences.findByUser(sessionUserId);
|
||||
? await memory.preferences.findByUserAndCategory(userId, category as Cat)
|
||||
: await memory.preferences.findByUser(userId);
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: JSON.stringify(prefs, null, 2) }],
|
||||
details: undefined,
|
||||
@@ -99,6 +76,7 @@ export function createMemoryTools(
|
||||
description:
|
||||
'Store a learned user preference (e.g., "prefers tables over paragraphs", "timezone: America/Chicago").',
|
||||
parameters: Type.Object({
|
||||
userId: Type.String({ description: 'User ID' }),
|
||||
key: Type.String({ description: 'Preference key' }),
|
||||
value: Type.String({ description: 'Preference value (JSON string)' }),
|
||||
category: Type.Optional(
|
||||
@@ -108,9 +86,8 @@ export function createMemoryTools(
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
if (!sessionUserId) return noUserError();
|
||||
|
||||
const { key, value, category } = params as {
|
||||
const { userId, key, value, category } = params as {
|
||||
userId: string;
|
||||
key: string;
|
||||
value: string;
|
||||
category?: string;
|
||||
@@ -123,7 +100,7 @@ export function createMemoryTools(
|
||||
parsedValue = value;
|
||||
}
|
||||
const pref = await memory.preferences.upsert({
|
||||
userId: sessionUserId,
|
||||
userId,
|
||||
key,
|
||||
value: parsedValue,
|
||||
category: (category as Cat) ?? 'general',
|
||||
@@ -142,6 +119,7 @@ export function createMemoryTools(
|
||||
description:
|
||||
'Store a learned insight, decision, or knowledge extracted from the current interaction.',
|
||||
parameters: Type.Object({
|
||||
userId: Type.String({ description: 'User ID' }),
|
||||
content: Type.String({ description: 'The insight or knowledge to store' }),
|
||||
category: Type.Optional(
|
||||
Type.String({
|
||||
@@ -150,9 +128,8 @@ export function createMemoryTools(
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
if (!sessionUserId) return noUserError();
|
||||
|
||||
const { content, category } = params as {
|
||||
const { userId, content, category } = params as {
|
||||
userId: string;
|
||||
content: string;
|
||||
category?: string;
|
||||
};
|
||||
@@ -164,7 +141,7 @@ export function createMemoryTools(
|
||||
}
|
||||
|
||||
const insight = await memory.insights.create({
|
||||
userId: sessionUserId,
|
||||
userId,
|
||||
content,
|
||||
embedding,
|
||||
source: 'agent',
|
||||
|
||||
@@ -1,104 +0,0 @@
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { guardPath, guardPathUnsafe, SandboxEscapeError } from './path-guard.js';
|
||||
import path from 'node:path';
|
||||
import os from 'node:os';
|
||||
import fs from 'node:fs';
|
||||
|
||||
describe('guardPathUnsafe', () => {
|
||||
const sandbox = '/tmp/test-sandbox';
|
||||
|
||||
it('allows paths inside sandbox', () => {
|
||||
const result = guardPathUnsafe('foo/bar.txt', sandbox);
|
||||
expect(result).toBe(path.resolve(sandbox, 'foo/bar.txt'));
|
||||
});
|
||||
|
||||
it('allows sandbox root itself', () => {
|
||||
const result = guardPathUnsafe('.', sandbox);
|
||||
expect(result).toBe(path.resolve(sandbox));
|
||||
});
|
||||
|
||||
it('rejects path traversal with ../', () => {
|
||||
expect(() => guardPathUnsafe('../escape.txt', sandbox)).toThrow(SandboxEscapeError);
|
||||
});
|
||||
|
||||
it('rejects absolute path outside sandbox', () => {
|
||||
expect(() => guardPathUnsafe('/etc/passwd', sandbox)).toThrow(SandboxEscapeError);
|
||||
});
|
||||
|
||||
it('rejects deeply nested traversal', () => {
|
||||
expect(() => guardPathUnsafe('a/b/../../../../../../etc/passwd', sandbox)).toThrow(
|
||||
SandboxEscapeError,
|
||||
);
|
||||
});
|
||||
|
||||
it('rejects path that starts with sandbox name but is sibling', () => {
|
||||
expect(() => guardPathUnsafe('/tmp/test-sandbox-evil/file.txt', sandbox)).toThrow(
|
||||
SandboxEscapeError,
|
||||
);
|
||||
});
|
||||
|
||||
it('returns the resolved absolute path for nested paths', () => {
|
||||
const result = guardPathUnsafe('deep/nested/file.ts', sandbox);
|
||||
expect(result).toBe('/tmp/test-sandbox/deep/nested/file.ts');
|
||||
});
|
||||
|
||||
it('SandboxEscapeError includes the user path and sandbox in message', () => {
|
||||
let caught: unknown;
|
||||
try {
|
||||
guardPathUnsafe('../escape.txt', sandbox);
|
||||
} catch (err) {
|
||||
caught = err;
|
||||
}
|
||||
expect(caught).toBeInstanceOf(SandboxEscapeError);
|
||||
const e = caught as SandboxEscapeError;
|
||||
expect(e.userPath).toBe('../escape.txt');
|
||||
expect(e.sandboxDir).toBe(sandbox);
|
||||
expect(e.message).toContain('Path escape attempt blocked');
|
||||
});
|
||||
});
|
||||
|
||||
describe('guardPath', () => {
|
||||
let tmpDir: string;
|
||||
|
||||
it('allows an existing path inside a real temp sandbox', () => {
|
||||
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'path-guard-test-'));
|
||||
try {
|
||||
const subdir = path.join(tmpDir, 'subdir');
|
||||
fs.mkdirSync(subdir);
|
||||
const result = guardPath('subdir', tmpDir);
|
||||
expect(result).toBe(subdir);
|
||||
} finally {
|
||||
fs.rmSync(tmpDir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
it('allows sandbox root itself', () => {
|
||||
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'path-guard-test-'));
|
||||
try {
|
||||
const result = guardPath('.', tmpDir);
|
||||
// realpathSync resolves the tmpdir symlinks (macOS /var -> /private/var)
|
||||
const realTmp = fs.realpathSync.native(tmpDir);
|
||||
expect(result).toBe(realTmp);
|
||||
} finally {
|
||||
fs.rmSync(tmpDir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
it('rejects path traversal with ../ on existing sandbox', () => {
|
||||
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'path-guard-test-'));
|
||||
try {
|
||||
expect(() => guardPath('../escape', tmpDir)).toThrow(SandboxEscapeError);
|
||||
} finally {
|
||||
fs.rmSync(tmpDir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
it('rejects absolute path outside sandbox', () => {
|
||||
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'path-guard-test-'));
|
||||
try {
|
||||
expect(() => guardPath('/etc/passwd', tmpDir)).toThrow(SandboxEscapeError);
|
||||
} finally {
|
||||
fs.rmSync(tmpDir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -1,58 +0,0 @@
|
||||
import path from 'node:path';
|
||||
import fs from 'node:fs';
|
||||
|
||||
/**
|
||||
* Resolves a user-provided path and verifies it is inside the allowed sandbox directory.
|
||||
* Throws SandboxEscapeError if the resolved path is outside the sandbox.
|
||||
*
|
||||
* Uses realpathSync to resolve symlinks in the sandbox root. The user-supplied path
|
||||
* is checked for containment AFTER lexical resolution but BEFORE resolving any symlinks
|
||||
* within the user path — so symlink escape attempts are caught too.
|
||||
*
|
||||
* @param userPath - The path provided by the agent (may be relative or absolute)
|
||||
* @param sandboxDir - The allowed root directory (already validated on session creation)
|
||||
* @returns The resolved absolute path, guaranteed to be within sandboxDir
|
||||
*/
|
||||
export function guardPath(userPath: string, sandboxDir: string): string {
|
||||
const resolved = path.resolve(sandboxDir, userPath);
|
||||
const sandboxResolved = fs.realpathSync.native(sandboxDir);
|
||||
|
||||
// Normalize both paths to resolve any symlinks in the sandbox root itself.
|
||||
// For the user path, we check containment BEFORE resolving symlinks in the path
|
||||
// (so we catch symlink escape attempts too — the resolved path must still be under sandbox)
|
||||
if (!resolved.startsWith(sandboxResolved + path.sep) && resolved !== sandboxResolved) {
|
||||
throw new SandboxEscapeError(userPath, sandboxDir, resolved);
|
||||
}
|
||||
|
||||
return resolved;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validates a path without resolving symlinks in the user-provided portion.
|
||||
* Use for paths that may not exist yet (creates, writes).
|
||||
*
|
||||
* Performs a lexical containment check only using path.resolve.
|
||||
*/
|
||||
export function guardPathUnsafe(userPath: string, sandboxDir: string): string {
|
||||
const resolved = path.resolve(sandboxDir, userPath);
|
||||
const sandboxAbs = path.resolve(sandboxDir);
|
||||
|
||||
if (!resolved.startsWith(sandboxAbs + path.sep) && resolved !== sandboxAbs) {
|
||||
throw new SandboxEscapeError(userPath, sandboxDir, resolved);
|
||||
}
|
||||
|
||||
return resolved;
|
||||
}
|
||||
|
||||
export class SandboxEscapeError extends Error {
|
||||
constructor(
|
||||
public readonly userPath: string,
|
||||
public readonly sandboxDir: string,
|
||||
public readonly resolvedPath: string,
|
||||
) {
|
||||
super(
|
||||
`Path escape attempt blocked: "${userPath}" resolves to "${resolvedPath}" which is outside sandbox "${sandboxDir}"`,
|
||||
);
|
||||
this.name = 'SandboxEscapeError';
|
||||
}
|
||||
}
|
||||
@@ -1,496 +0,0 @@
|
||||
import { Type } from '@sinclair/typebox';
|
||||
import type { ToolDefinition } from '@mariozechner/pi-coding-agent';
|
||||
|
||||
const DEFAULT_TIMEOUT_MS = 15_000;
|
||||
const MAX_RESULTS = 10;
|
||||
const MAX_RESPONSE_BYTES = 256 * 1024; // 256 KB
|
||||
|
||||
// ─── Provider helpers ────────────────────────────────────────────────────────
|
||||
|
||||
interface SearchResult {
|
||||
title: string;
|
||||
url: string;
|
||||
snippet: string;
|
||||
}
|
||||
|
||||
interface SearchResponse {
|
||||
provider: string;
|
||||
query: string;
|
||||
results: SearchResult[];
|
||||
error?: string;
|
||||
}
|
||||
|
||||
async function fetchWithTimeout(
|
||||
url: string,
|
||||
init: RequestInit,
|
||||
timeoutMs: number,
|
||||
): Promise<Response> {
|
||||
const controller = new AbortController();
|
||||
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
||||
try {
|
||||
return await fetch(url, { ...init, signal: controller.signal });
|
||||
} finally {
|
||||
clearTimeout(timer);
|
||||
}
|
||||
}
|
||||
|
||||
async function readLimited(response: Response): Promise<string> {
|
||||
const reader = response.body?.getReader();
|
||||
if (!reader) return '';
|
||||
const chunks: Uint8Array[] = [];
|
||||
let total = 0;
|
||||
while (true) {
|
||||
const { done, value } = await reader.read();
|
||||
if (done) break;
|
||||
total += value.length;
|
||||
if (total > MAX_RESPONSE_BYTES) {
|
||||
chunks.push(value.subarray(0, MAX_RESPONSE_BYTES - (total - value.length)));
|
||||
reader.cancel();
|
||||
break;
|
||||
}
|
||||
chunks.push(value);
|
||||
}
|
||||
const combined = new Uint8Array(chunks.reduce((a, c) => a + c.length, 0));
|
||||
let offset = 0;
|
||||
for (const chunk of chunks) {
|
||||
combined.set(chunk, offset);
|
||||
offset += chunk.length;
|
||||
}
|
||||
return new TextDecoder().decode(combined);
|
||||
}
|
||||
|
||||
// ─── Brave Search ────────────────────────────────────────────────────────────
|
||||
|
||||
async function searchBrave(query: string, limit: number): Promise<SearchResponse> {
|
||||
const apiKey = process.env['BRAVE_API_KEY'];
|
||||
if (!apiKey) return { provider: 'brave', query, results: [], error: 'BRAVE_API_KEY not set' };
|
||||
|
||||
try {
|
||||
const params = new URLSearchParams({
|
||||
q: query,
|
||||
count: String(Math.min(limit, 20)),
|
||||
});
|
||||
const res = await fetchWithTimeout(
|
||||
`https://api.search.brave.com/res/v1/web/search?${params}`,
|
||||
{ headers: { 'X-Subscription-Token': apiKey, Accept: 'application/json' } },
|
||||
DEFAULT_TIMEOUT_MS,
|
||||
);
|
||||
if (!res.ok) {
|
||||
const body = await res.text().catch(() => '');
|
||||
return { provider: 'brave', query, results: [], error: `HTTP ${res.status}: ${body}` };
|
||||
}
|
||||
const data = (await res.json()) as {
|
||||
web?: { results?: Array<{ title: string; url: string; description: string }> };
|
||||
};
|
||||
const results: SearchResult[] = (data.web?.results ?? []).slice(0, limit).map((r) => ({
|
||||
title: r.title,
|
||||
url: r.url,
|
||||
snippet: r.description,
|
||||
}));
|
||||
return { provider: 'brave', query, results };
|
||||
} catch (err) {
|
||||
return {
|
||||
provider: 'brave',
|
||||
query,
|
||||
results: [],
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Tavily Search ───────────────────────────────────────────────────────────
|
||||
|
||||
async function searchTavily(query: string, limit: number): Promise<SearchResponse> {
|
||||
const apiKey = process.env['TAVILY_API_KEY'];
|
||||
if (!apiKey) return { provider: 'tavily', query, results: [], error: 'TAVILY_API_KEY not set' };
|
||||
|
||||
try {
|
||||
const res = await fetchWithTimeout(
|
||||
'https://api.tavily.com/search',
|
||||
{
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
api_key: apiKey,
|
||||
query,
|
||||
max_results: Math.min(limit, 10),
|
||||
include_answer: false,
|
||||
}),
|
||||
},
|
||||
DEFAULT_TIMEOUT_MS,
|
||||
);
|
||||
if (!res.ok) {
|
||||
const body = await res.text().catch(() => '');
|
||||
return { provider: 'tavily', query, results: [], error: `HTTP ${res.status}: ${body}` };
|
||||
}
|
||||
const data = (await res.json()) as {
|
||||
results?: Array<{ title: string; url: string; content: string }>;
|
||||
};
|
||||
const results: SearchResult[] = (data.results ?? []).slice(0, limit).map((r) => ({
|
||||
title: r.title,
|
||||
url: r.url,
|
||||
snippet: r.content,
|
||||
}));
|
||||
return { provider: 'tavily', query, results };
|
||||
} catch (err) {
|
||||
return {
|
||||
provider: 'tavily',
|
||||
query,
|
||||
results: [],
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// ─── SearXNG (self-hosted) ───────────────────────────────────────────────────
|
||||
|
||||
async function searchSearxng(query: string, limit: number): Promise<SearchResponse> {
|
||||
const baseUrl = process.env['SEARXNG_URL'];
|
||||
if (!baseUrl) return { provider: 'searxng', query, results: [], error: 'SEARXNG_URL not set' };
|
||||
|
||||
try {
|
||||
const params = new URLSearchParams({
|
||||
q: query,
|
||||
format: 'json',
|
||||
pageno: '1',
|
||||
});
|
||||
const res = await fetchWithTimeout(
|
||||
`${baseUrl.replace(/\/$/, '')}/search?${params}`,
|
||||
{ headers: { Accept: 'application/json' } },
|
||||
DEFAULT_TIMEOUT_MS,
|
||||
);
|
||||
if (!res.ok) {
|
||||
const body = await res.text().catch(() => '');
|
||||
return { provider: 'searxng', query, results: [], error: `HTTP ${res.status}: ${body}` };
|
||||
}
|
||||
const data = (await res.json()) as {
|
||||
results?: Array<{ title: string; url: string; content: string }>;
|
||||
};
|
||||
const results: SearchResult[] = (data.results ?? []).slice(0, limit).map((r) => ({
|
||||
title: r.title,
|
||||
url: r.url,
|
||||
snippet: r.content,
|
||||
}));
|
||||
return { provider: 'searxng', query, results };
|
||||
} catch (err) {
|
||||
return {
|
||||
provider: 'searxng',
|
||||
query,
|
||||
results: [],
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// ─── DuckDuckGo (lite HTML endpoint) ─────────────────────────────────────────
|
||||
|
||||
async function searchDuckDuckGo(query: string, limit: number): Promise<SearchResponse> {
|
||||
try {
|
||||
// Use the DuckDuckGo Instant Answer API (JSON, free, no key)
|
||||
const params = new URLSearchParams({
|
||||
q: query,
|
||||
format: 'json',
|
||||
no_html: '1',
|
||||
skip_disambig: '1',
|
||||
});
|
||||
const res = await fetchWithTimeout(
|
||||
`https://api.duckduckgo.com/?${params}`,
|
||||
{ headers: { Accept: 'application/json' } },
|
||||
DEFAULT_TIMEOUT_MS,
|
||||
);
|
||||
if (!res.ok) {
|
||||
return {
|
||||
provider: 'duckduckgo',
|
||||
query,
|
||||
results: [],
|
||||
error: `HTTP ${res.status}`,
|
||||
};
|
||||
}
|
||||
const text = await readLimited(res);
|
||||
const data = JSON.parse(text) as {
|
||||
AbstractText?: string;
|
||||
AbstractURL?: string;
|
||||
AbstractSource?: string;
|
||||
RelatedTopics?: Array<{
|
||||
Text?: string;
|
||||
FirstURL?: string;
|
||||
Result?: string;
|
||||
Topics?: Array<{ Text?: string; FirstURL?: string }>;
|
||||
}>;
|
||||
};
|
||||
|
||||
const results: SearchResult[] = [];
|
||||
|
||||
// Main abstract result
|
||||
if (data.AbstractText && data.AbstractURL) {
|
||||
results.push({
|
||||
title: data.AbstractSource ?? 'DuckDuckGo Abstract',
|
||||
url: data.AbstractURL,
|
||||
snippet: data.AbstractText,
|
||||
});
|
||||
}
|
||||
|
||||
// Related topics
|
||||
for (const topic of data.RelatedTopics ?? []) {
|
||||
if (results.length >= limit) break;
|
||||
if (topic.Text && topic.FirstURL) {
|
||||
results.push({
|
||||
title: topic.Text.slice(0, 120),
|
||||
url: topic.FirstURL,
|
||||
snippet: topic.Text,
|
||||
});
|
||||
}
|
||||
// Sub-topics
|
||||
for (const sub of topic.Topics ?? []) {
|
||||
if (results.length >= limit) break;
|
||||
if (sub.Text && sub.FirstURL) {
|
||||
results.push({
|
||||
title: sub.Text.slice(0, 120),
|
||||
url: sub.FirstURL,
|
||||
snippet: sub.Text,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return { provider: 'duckduckgo', query, results: results.slice(0, limit) };
|
||||
} catch (err) {
|
||||
return {
|
||||
provider: 'duckduckgo',
|
||||
query,
|
||||
results: [],
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Provider resolution ─────────────────────────────────────────────────────
|
||||
|
||||
type SearchProvider = 'brave' | 'tavily' | 'searxng' | 'duckduckgo' | 'auto';
|
||||
|
||||
function getAvailableProviders(): SearchProvider[] {
|
||||
const available: SearchProvider[] = [];
|
||||
if (process.env['BRAVE_API_KEY']) available.push('brave');
|
||||
if (process.env['TAVILY_API_KEY']) available.push('tavily');
|
||||
if (process.env['SEARXNG_URL']) available.push('searxng');
|
||||
// DuckDuckGo is always available (no API key needed)
|
||||
available.push('duckduckgo');
|
||||
return available;
|
||||
}
|
||||
|
||||
async function executeSearch(
|
||||
provider: SearchProvider,
|
||||
query: string,
|
||||
limit: number,
|
||||
): Promise<SearchResponse> {
|
||||
switch (provider) {
|
||||
case 'brave':
|
||||
return searchBrave(query, limit);
|
||||
case 'tavily':
|
||||
return searchTavily(query, limit);
|
||||
case 'searxng':
|
||||
return searchSearxng(query, limit);
|
||||
case 'duckduckgo':
|
||||
return searchDuckDuckGo(query, limit);
|
||||
case 'auto': {
|
||||
// Try providers in priority order: Brave > Tavily > SearXNG > DuckDuckGo
|
||||
const available = getAvailableProviders();
|
||||
for (const p of available) {
|
||||
const result = await executeSearch(p, query, limit);
|
||||
if (!result.error && result.results.length > 0) return result;
|
||||
}
|
||||
// Fall back to DuckDuckGo if everything failed
|
||||
return searchDuckDuckGo(query, limit);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function formatSearchResults(response: SearchResponse): string {
|
||||
const lines: string[] = [];
|
||||
lines.push(`Search provider: ${response.provider}`);
|
||||
lines.push(`Query: "${response.query}"`);
|
||||
|
||||
if (response.error) {
|
||||
lines.push(`Error: ${response.error}`);
|
||||
}
|
||||
|
||||
if (response.results.length === 0) {
|
||||
lines.push('No results found.');
|
||||
} else {
|
||||
lines.push(`Results (${response.results.length}):\n`);
|
||||
for (let i = 0; i < response.results.length; i++) {
|
||||
const r = response.results[i]!;
|
||||
lines.push(`${i + 1}. ${r.title}`);
|
||||
lines.push(` URL: ${r.url}`);
|
||||
lines.push(` ${r.snippet}`);
|
||||
lines.push('');
|
||||
}
|
||||
}
|
||||
return lines.join('\n');
|
||||
}
|
||||
|
||||
// ─── Tool exports ────────────────────────────────────────────────────────────
|
||||
|
||||
export function createSearchTools(): ToolDefinition[] {
|
||||
const webSearch: ToolDefinition = {
|
||||
name: 'web_search',
|
||||
label: 'Web Search',
|
||||
description:
|
||||
'Search the web using configured search providers. ' +
|
||||
'Supports Brave, Tavily, SearXNG, and DuckDuckGo. ' +
|
||||
'Use "auto" provider to pick the best available. ' +
|
||||
'DuckDuckGo is always available as a fallback (no API key needed).',
|
||||
parameters: Type.Object({
|
||||
query: Type.String({ description: 'Search query' }),
|
||||
provider: Type.Optional(
|
||||
Type.String({
|
||||
description:
|
||||
'Search provider: "auto" (default), "brave", "tavily", "searxng", or "duckduckgo"',
|
||||
}),
|
||||
),
|
||||
limit: Type.Optional(
|
||||
Type.Number({ description: `Max results to return (default 5, max ${MAX_RESULTS})` }),
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
const { query, provider, limit } = params as {
|
||||
query: string;
|
||||
provider?: string;
|
||||
limit?: number;
|
||||
};
|
||||
|
||||
const effectiveProvider = (provider ?? 'auto') as SearchProvider;
|
||||
const validProviders = ['auto', 'brave', 'tavily', 'searxng', 'duckduckgo'];
|
||||
if (!validProviders.includes(effectiveProvider)) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `Invalid provider "${provider}". Valid: ${validProviders.join(', ')}`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
const effectiveLimit = Math.min(Math.max(limit ?? 5, 1), MAX_RESULTS);
|
||||
|
||||
try {
|
||||
const response = await executeSearch(effectiveProvider, query, effectiveLimit);
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: formatSearchResults(response) }],
|
||||
details: undefined,
|
||||
};
|
||||
} catch (err) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `Search failed: ${err instanceof Error ? err.message : String(err)}`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
const webSearchNews: ToolDefinition = {
|
||||
name: 'web_search_news',
|
||||
label: 'Web Search (News)',
|
||||
description:
|
||||
'Search for recent news articles. Uses Brave News API if available, falls back to standard search with news keywords.',
|
||||
parameters: Type.Object({
|
||||
query: Type.String({ description: 'News search query' }),
|
||||
limit: Type.Optional(
|
||||
Type.Number({ description: `Max results (default 5, max ${MAX_RESULTS})` }),
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
const { query, limit } = params as { query: string; limit?: number };
|
||||
const effectiveLimit = Math.min(Math.max(limit ?? 5, 1), MAX_RESULTS);
|
||||
|
||||
// Try Brave News API first (dedicated news endpoint)
|
||||
const braveKey = process.env['BRAVE_API_KEY'];
|
||||
if (braveKey) {
|
||||
try {
|
||||
const newsParams = new URLSearchParams({
|
||||
q: query,
|
||||
count: String(effectiveLimit),
|
||||
});
|
||||
const res = await fetchWithTimeout(
|
||||
`https://api.search.brave.com/res/v1/news/search?${newsParams}`,
|
||||
{
|
||||
headers: {
|
||||
'X-Subscription-Token': braveKey,
|
||||
Accept: 'application/json',
|
||||
},
|
||||
},
|
||||
DEFAULT_TIMEOUT_MS,
|
||||
);
|
||||
if (res.ok) {
|
||||
const data = (await res.json()) as {
|
||||
results?: Array<{
|
||||
title: string;
|
||||
url: string;
|
||||
description: string;
|
||||
age?: string;
|
||||
}>;
|
||||
};
|
||||
const results: SearchResult[] = (data.results ?? [])
|
||||
.slice(0, effectiveLimit)
|
||||
.map((r) => ({
|
||||
title: r.title + (r.age ? ` (${r.age})` : ''),
|
||||
url: r.url,
|
||||
snippet: r.description,
|
||||
}));
|
||||
const response: SearchResponse = { provider: 'brave-news', query, results };
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: formatSearchResults(response) }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
} catch {
|
||||
// Fall through to generic search
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback: standard search with "news" appended
|
||||
const newsQuery = `${query} news latest`;
|
||||
const response = await executeSearch('auto', newsQuery, effectiveLimit);
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: formatSearchResults(response) }],
|
||||
details: undefined,
|
||||
};
|
||||
},
|
||||
};
|
||||
|
||||
const searchProviders: ToolDefinition = {
|
||||
name: 'web_search_providers',
|
||||
label: 'List Search Providers',
|
||||
description: 'List the currently available and configured web search providers.',
|
||||
parameters: Type.Object({}),
|
||||
async execute() {
|
||||
const available = getAvailableProviders();
|
||||
const allProviders = [
|
||||
{ name: 'brave', configured: !!process.env['BRAVE_API_KEY'], envVar: 'BRAVE_API_KEY' },
|
||||
{ name: 'tavily', configured: !!process.env['TAVILY_API_KEY'], envVar: 'TAVILY_API_KEY' },
|
||||
{ name: 'searxng', configured: !!process.env['SEARXNG_URL'], envVar: 'SEARXNG_URL' },
|
||||
{ name: 'duckduckgo', configured: true, envVar: '(none — always available)' },
|
||||
];
|
||||
|
||||
const lines = ['Search providers:\n'];
|
||||
for (const p of allProviders) {
|
||||
const status = p.configured ? '✓ configured' : '✗ not configured';
|
||||
lines.push(` ${p.name}: ${status} (${p.envVar})`);
|
||||
}
|
||||
lines.push(`\nActive providers for "auto" mode: ${available.join(', ')}`);
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: lines.join('\n') }],
|
||||
details: undefined,
|
||||
};
|
||||
},
|
||||
};
|
||||
|
||||
return [webSearch, webSearchNews, searchProviders];
|
||||
}
|
||||
@@ -1,218 +0,0 @@
|
||||
import { Type } from '@sinclair/typebox';
|
||||
import type { ToolDefinition } from '@mariozechner/pi-coding-agent';
|
||||
import { spawn } from 'node:child_process';
|
||||
import { guardPath, SandboxEscapeError } from './path-guard.js';
|
||||
|
||||
const DEFAULT_TIMEOUT_MS = 30_000;
|
||||
const MAX_OUTPUT_BYTES = 100 * 1024; // 100 KB
|
||||
|
||||
/**
|
||||
* Commands that are outright blocked for safety.
|
||||
* This is a denylist; the agent should be instructed to use
|
||||
* the least-privilege command necessary.
|
||||
*/
|
||||
const BLOCKED_COMMANDS = new Set([
|
||||
'rm',
|
||||
'rmdir',
|
||||
'mkfs',
|
||||
'dd',
|
||||
'format',
|
||||
'fdisk',
|
||||
'parted',
|
||||
'shred',
|
||||
'wipefs',
|
||||
'sudo',
|
||||
'su',
|
||||
'chown',
|
||||
'chmod',
|
||||
'passwd',
|
||||
'useradd',
|
||||
'userdel',
|
||||
'groupadd',
|
||||
'shutdown',
|
||||
'reboot',
|
||||
'halt',
|
||||
'poweroff',
|
||||
'kill',
|
||||
'killall',
|
||||
'pkill',
|
||||
'curl',
|
||||
'wget',
|
||||
'nc',
|
||||
'netcat',
|
||||
'ncat',
|
||||
'ssh',
|
||||
'scp',
|
||||
'sftp',
|
||||
'rsync',
|
||||
'iptables',
|
||||
'ip6tables',
|
||||
'nft',
|
||||
'ufw',
|
||||
'firewall-cmd',
|
||||
'docker',
|
||||
'podman',
|
||||
'kubectl',
|
||||
'helm',
|
||||
'terraform',
|
||||
'ansible',
|
||||
'crontab',
|
||||
'at',
|
||||
'batch',
|
||||
]);
|
||||
|
||||
function extractBaseCommand(command: string): string {
|
||||
// Extract the first word (the binary name), stripping path
|
||||
const trimmed = command.trim();
|
||||
const firstToken = trimmed.split(/\s+/)[0] ?? '';
|
||||
return firstToken.split('/').pop() ?? firstToken;
|
||||
}
|
||||
|
||||
function runCommand(
|
||||
command: string,
|
||||
options: { timeoutMs: number; cwd?: string },
|
||||
): Promise<{ stdout: string; stderr: string; exitCode: number | null; timedOut: boolean }> {
|
||||
return new Promise((resolve) => {
|
||||
const child = spawn('sh', ['-c', command], {
|
||||
cwd: options.cwd,
|
||||
stdio: ['ignore', 'pipe', 'pipe'],
|
||||
detached: false,
|
||||
});
|
||||
|
||||
let stdout = '';
|
||||
let stderr = '';
|
||||
let timedOut = false;
|
||||
let totalBytes = 0;
|
||||
let truncated = false;
|
||||
|
||||
child.stdout?.on('data', (chunk: Buffer) => {
|
||||
if (truncated) return;
|
||||
totalBytes += chunk.length;
|
||||
if (totalBytes > MAX_OUTPUT_BYTES) {
|
||||
stdout += chunk.subarray(0, MAX_OUTPUT_BYTES - (totalBytes - chunk.length)).toString();
|
||||
stdout += '\n[output truncated at 100 KB limit]';
|
||||
truncated = true;
|
||||
child.kill('SIGTERM');
|
||||
} else {
|
||||
stdout += chunk.toString();
|
||||
}
|
||||
});
|
||||
|
||||
child.stderr?.on('data', (chunk: Buffer) => {
|
||||
if (stderr.length < MAX_OUTPUT_BYTES) {
|
||||
stderr += chunk.toString();
|
||||
}
|
||||
});
|
||||
|
||||
const timer = setTimeout(() => {
|
||||
timedOut = true;
|
||||
child.kill('SIGTERM');
|
||||
setTimeout(() => {
|
||||
try {
|
||||
child.kill('SIGKILL');
|
||||
} catch {
|
||||
// already exited
|
||||
}
|
||||
}, 2000);
|
||||
}, options.timeoutMs);
|
||||
|
||||
child.on('close', (exitCode) => {
|
||||
clearTimeout(timer);
|
||||
resolve({ stdout, stderr, exitCode, timedOut });
|
||||
});
|
||||
|
||||
child.on('error', (err) => {
|
||||
clearTimeout(timer);
|
||||
resolve({ stdout, stderr: stderr + String(err), exitCode: null, timedOut: false });
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
export function createShellTools(sandboxDir?: string): ToolDefinition[] {
|
||||
const defaultCwd = sandboxDir ?? process.cwd();
|
||||
|
||||
const shellExec: ToolDefinition = {
|
||||
name: 'shell_exec',
|
||||
label: 'Shell Execute',
|
||||
description:
|
||||
'Execute a shell command with timeout and output limits. Dangerous commands (rm, sudo, docker, etc.) are blocked. Working directory is restricted to the session sandbox.',
|
||||
parameters: Type.Object({
|
||||
command: Type.String({ description: 'Shell command to execute' }),
|
||||
cwd: Type.Optional(
|
||||
Type.String({
|
||||
description:
|
||||
'Working directory for the command (relative to sandbox or absolute within it).',
|
||||
}),
|
||||
),
|
||||
timeout: Type.Optional(
|
||||
Type.Number({ description: 'Timeout in milliseconds (default 30000, max 60000)' }),
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
const { command, cwd, timeout } = params as {
|
||||
command: string;
|
||||
cwd?: string;
|
||||
timeout?: number;
|
||||
};
|
||||
|
||||
const base = extractBaseCommand(command);
|
||||
if (BLOCKED_COMMANDS.has(base)) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `Error: command "${base}" is blocked for safety reasons.`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
const timeoutMs = Math.min(timeout ?? DEFAULT_TIMEOUT_MS, 60_000);
|
||||
let safeCwd: string;
|
||||
try {
|
||||
safeCwd = guardPath(cwd ?? '.', defaultCwd);
|
||||
} catch (err) {
|
||||
if (err instanceof SandboxEscapeError) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${err.message}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${String(err)}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
const result = await runCommand(command, {
|
||||
timeoutMs,
|
||||
cwd: safeCwd,
|
||||
});
|
||||
|
||||
if (result.timedOut) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `Command timed out after ${timeoutMs}ms.\nPartial stdout:\n${result.stdout}\nPartial stderr:\n${result.stderr}`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
const parts: string[] = [];
|
||||
if (result.stdout) parts.push(`stdout:\n${result.stdout}`);
|
||||
if (result.stderr) parts.push(`stderr:\n${result.stderr}`);
|
||||
parts.push(`exit code: ${result.exitCode ?? 'null'}`);
|
||||
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: parts.join('\n') }],
|
||||
details: undefined,
|
||||
};
|
||||
},
|
||||
};
|
||||
|
||||
return [shellExec];
|
||||
}
|
||||
@@ -1,180 +0,0 @@
|
||||
import { Type } from '@sinclair/typebox';
|
||||
import type { ToolDefinition } from '@mariozechner/pi-coding-agent';
|
||||
import type { SkillsService } from '../../skills/skills.service.js';
|
||||
|
||||
/**
|
||||
* Creates meta-tools that allow agents to list and invoke skills from the catalog.
|
||||
*
|
||||
* skill_list — list all enabled skills
|
||||
* skill_invoke — execute a skill by name with parameters
|
||||
*/
|
||||
export function createSkillTools(skillsService: SkillsService): ToolDefinition[] {
|
||||
const skillList: ToolDefinition = {
|
||||
name: 'skill_list',
|
||||
label: 'List Skills',
|
||||
description:
|
||||
'List all enabled skills available in the catalog. Returns name, description, type, and config for each skill.',
|
||||
parameters: Type.Object({}),
|
||||
async execute() {
|
||||
const skills = await skillsService.findEnabled();
|
||||
const summary = skills.map((s) => ({
|
||||
name: s.name,
|
||||
description: s.description,
|
||||
version: s.version,
|
||||
source: s.source,
|
||||
config: s.config,
|
||||
}));
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text:
|
||||
summary.length > 0
|
||||
? JSON.stringify(summary, null, 2)
|
||||
: 'No enabled skills found in catalog.',
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
},
|
||||
};
|
||||
|
||||
const skillInvoke: ToolDefinition = {
|
||||
name: 'skill_invoke',
|
||||
label: 'Invoke Skill',
|
||||
description:
|
||||
'Invoke a skill from the catalog by name. For prompt skills, returns the prompt addition. ' +
|
||||
'For tool skills, executes the embedded logic. For workflow skills, returns the workflow steps.',
|
||||
parameters: Type.Object({
|
||||
name: Type.String({ description: 'Skill name to invoke' }),
|
||||
params: Type.Optional(
|
||||
Type.Record(Type.String(), Type.Unknown(), {
|
||||
description: 'Parameters to pass to the skill (if applicable)',
|
||||
}),
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, rawParams) {
|
||||
const { name, params } = rawParams as {
|
||||
name: string;
|
||||
params?: Record<string, unknown>;
|
||||
};
|
||||
|
||||
const skill = await skillsService.findByName(name);
|
||||
if (!skill) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Skill not found: ${name}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
if (!skill.enabled) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Skill is disabled: ${name}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
const config = (skill.config ?? {}) as Record<string, unknown>;
|
||||
const skillType = (config['type'] as string | undefined) ?? 'prompt';
|
||||
|
||||
switch (skillType) {
|
||||
case 'prompt': {
|
||||
const promptAddition =
|
||||
(config['prompt'] as string | undefined) ?? skill.description ?? '';
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: promptAddition
|
||||
? `[Skill: ${name}] ${promptAddition}`
|
||||
: `[Skill: ${name}] No prompt content defined.`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
case 'tool': {
|
||||
const toolLogic = config['logic'] as string | undefined;
|
||||
if (!toolLogic) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `[Skill: ${name}] Tool skill has no logic defined.`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
// Inline tool skill execution: the logic field holds a JS expression or template
|
||||
// For safety, treat it as a template that can reference params
|
||||
const result = renderTemplate(toolLogic, { params: params ?? {}, skill });
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `[Skill: ${name}]\n${result}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
case 'workflow': {
|
||||
const steps = config['steps'] as unknown[] | undefined;
|
||||
if (!steps || steps.length === 0) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `[Skill: ${name}] Workflow has no steps defined.`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `[Skill: ${name}] Workflow steps:\n${JSON.stringify(steps, null, 2)}`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
default: {
|
||||
// Unknown type — return full config so the agent can decide what to do
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `[Skill: ${name}] (type: ${skillType})\n${JSON.stringify(config, null, 2)}`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
return [skillList, skillInvoke];
|
||||
}
|
||||
|
||||
/**
|
||||
* Minimal template renderer — replaces {{key}} with values from the context.
|
||||
* Used for tool skill logic templates.
|
||||
*/
|
||||
function renderTemplate(template: string, context: Record<string, unknown>): string {
|
||||
return template.replace(/\{\{(\w+(?:\.\w+)*)\}\}/g, (_match, path: string) => {
|
||||
const parts = path.split('.');
|
||||
let value: unknown = context;
|
||||
for (const part of parts) {
|
||||
if (value != null && typeof value === 'object') {
|
||||
value = (value as Record<string, unknown>)[part];
|
||||
} else {
|
||||
value = undefined;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return value !== undefined && value !== null ? String(value) : '';
|
||||
});
|
||||
}
|
||||
@@ -1,225 +0,0 @@
|
||||
import { Type } from '@sinclair/typebox';
|
||||
import type { ToolDefinition } from '@mariozechner/pi-coding-agent';
|
||||
|
||||
const DEFAULT_TIMEOUT_MS = 15_000;
|
||||
const MAX_RESPONSE_BYTES = 512 * 1024; // 512 KB
|
||||
|
||||
/**
|
||||
* Blocked URL patterns (private IP ranges, localhost, link-local).
|
||||
*/
|
||||
const BLOCKED_HOSTNAMES = [
|
||||
/^localhost$/i,
|
||||
/^127\./,
|
||||
/^10\./,
|
||||
/^172\.(1[6-9]|2\d|3[01])\./,
|
||||
/^192\.168\./,
|
||||
/^::1$/,
|
||||
/^fc[0-9a-f][0-9a-f]:/i,
|
||||
/^fe80:/i,
|
||||
/^0\.0\.0\.0$/,
|
||||
/^169\.254\./,
|
||||
];
|
||||
|
||||
function isBlockedUrl(urlString: string): string | null {
|
||||
let parsed: URL;
|
||||
try {
|
||||
parsed = new URL(urlString);
|
||||
} catch {
|
||||
return `Invalid URL: ${urlString}`;
|
||||
}
|
||||
if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
|
||||
return `Unsupported protocol: ${parsed.protocol}. Only http and https are allowed.`;
|
||||
}
|
||||
const hostname = parsed.hostname;
|
||||
for (const pattern of BLOCKED_HOSTNAMES) {
|
||||
if (pattern.test(hostname)) {
|
||||
return `Blocked: requests to "${hostname}" are not allowed (private/local addresses).`;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
async function fetchWithLimit(
|
||||
url: string,
|
||||
options: RequestInit,
|
||||
timeoutMs: number,
|
||||
): Promise<{ text: string; status: number; contentType: string }> {
|
||||
const controller = new AbortController();
|
||||
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
||||
|
||||
try {
|
||||
const response = await fetch(url, { ...options, signal: controller.signal });
|
||||
const contentType = response.headers.get('content-type') ?? '';
|
||||
|
||||
// Stream response and enforce size limit
|
||||
const reader = response.body?.getReader();
|
||||
if (!reader) {
|
||||
return { text: '', status: response.status, contentType };
|
||||
}
|
||||
|
||||
const chunks: Uint8Array[] = [];
|
||||
let totalBytes = 0;
|
||||
let truncated = false;
|
||||
|
||||
while (true) {
|
||||
const { done, value } = await reader.read();
|
||||
if (done) break;
|
||||
totalBytes += value.length;
|
||||
if (totalBytes > MAX_RESPONSE_BYTES) {
|
||||
const remaining = MAX_RESPONSE_BYTES - (totalBytes - value.length);
|
||||
chunks.push(value.subarray(0, remaining));
|
||||
truncated = true;
|
||||
reader.cancel();
|
||||
break;
|
||||
}
|
||||
chunks.push(value);
|
||||
}
|
||||
|
||||
const combined = new Uint8Array(chunks.reduce((acc, c) => acc + c.length, 0));
|
||||
let offset = 0;
|
||||
for (const chunk of chunks) {
|
||||
combined.set(chunk, offset);
|
||||
offset += chunk.length;
|
||||
}
|
||||
|
||||
let text = new TextDecoder().decode(combined);
|
||||
if (truncated) {
|
||||
text += '\n[response truncated at 512 KB limit]';
|
||||
}
|
||||
|
||||
return { text, status: response.status, contentType };
|
||||
} finally {
|
||||
clearTimeout(timer);
|
||||
}
|
||||
}
|
||||
|
||||
export function createWebTools(): ToolDefinition[] {
|
||||
const webGet: ToolDefinition = {
|
||||
name: 'web_get',
|
||||
label: 'HTTP GET',
|
||||
description:
|
||||
'Perform an HTTP GET request and return the response body. Private/local addresses are blocked.',
|
||||
parameters: Type.Object({
|
||||
url: Type.String({ description: 'URL to fetch (http/https only)' }),
|
||||
headers: Type.Optional(
|
||||
Type.Record(Type.String(), Type.String(), {
|
||||
description: 'Optional request headers as key-value pairs',
|
||||
}),
|
||||
),
|
||||
timeout: Type.Optional(
|
||||
Type.Number({ description: 'Timeout in milliseconds (default 15000, max 30000)' }),
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
const { url, headers, timeout } = params as {
|
||||
url: string;
|
||||
headers?: Record<string, string>;
|
||||
timeout?: number;
|
||||
};
|
||||
|
||||
const blocked = isBlockedUrl(url);
|
||||
if (blocked) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${blocked}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
const timeoutMs = Math.min(timeout ?? DEFAULT_TIMEOUT_MS, 30_000);
|
||||
|
||||
try {
|
||||
const result = await fetchWithLimit(
|
||||
url,
|
||||
{ method: 'GET', headers: headers ?? {} },
|
||||
timeoutMs,
|
||||
);
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `HTTP ${result.status} (${result.contentType})\n\n${result.text}`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
} catch (err) {
|
||||
const msg = err instanceof Error ? err.message : String(err);
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error fetching URL: ${msg}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
const webPost: ToolDefinition = {
|
||||
name: 'web_post',
|
||||
label: 'HTTP POST',
|
||||
description:
|
||||
'Perform an HTTP POST request with a JSON or text body. Private/local addresses are blocked.',
|
||||
parameters: Type.Object({
|
||||
url: Type.String({ description: 'URL to POST to (http/https only)' }),
|
||||
body: Type.String({ description: 'Request body (JSON string or plain text)' }),
|
||||
contentType: Type.Optional(
|
||||
Type.String({ description: 'Content-Type header (default: application/json)' }),
|
||||
),
|
||||
headers: Type.Optional(
|
||||
Type.Record(Type.String(), Type.String(), {
|
||||
description: 'Optional additional request headers',
|
||||
}),
|
||||
),
|
||||
timeout: Type.Optional(
|
||||
Type.Number({ description: 'Timeout in milliseconds (default 15000, max 30000)' }),
|
||||
),
|
||||
}),
|
||||
async execute(_toolCallId, params) {
|
||||
const { url, body, contentType, headers, timeout } = params as {
|
||||
url: string;
|
||||
body: string;
|
||||
contentType?: string;
|
||||
headers?: Record<string, string>;
|
||||
timeout?: number;
|
||||
};
|
||||
|
||||
const blocked = isBlockedUrl(url);
|
||||
if (blocked) {
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error: ${blocked}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
const timeoutMs = Math.min(timeout ?? DEFAULT_TIMEOUT_MS, 30_000);
|
||||
const ct = contentType ?? 'application/json';
|
||||
|
||||
try {
|
||||
const result = await fetchWithLimit(
|
||||
url,
|
||||
{
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': ct, ...(headers ?? {}) },
|
||||
body,
|
||||
},
|
||||
timeoutMs,
|
||||
);
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `HTTP ${result.status} (${result.contentType})\n\n${result.text}`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
} catch (err) {
|
||||
const msg = err instanceof Error ? err.message : String(err);
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: `Error posting to URL: ${msg}` }],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
return [webGet, webPost];
|
||||
}
|
||||
@@ -14,15 +14,6 @@ import { CoordModule } from './coord/coord.module.js';
|
||||
import { MemoryModule } from './memory/memory.module.js';
|
||||
import { LogModule } from './log/log.module.js';
|
||||
import { SkillsModule } from './skills/skills.module.js';
|
||||
import { PluginModule } from './plugin/plugin.module.js';
|
||||
import { McpModule } from './mcp/mcp.module.js';
|
||||
import { AdminModule } from './admin/admin.module.js';
|
||||
import { CommandsModule } from './commands/commands.module.js';
|
||||
import { PreferencesModule } from './preferences/preferences.module.js';
|
||||
import { GCModule } from './gc/gc.module.js';
|
||||
import { ReloadModule } from './reload/reload.module.js';
|
||||
import { WorkspaceModule } from './workspace/workspace.module.js';
|
||||
import { QueueModule } from './queue/queue.module.js';
|
||||
import { ThrottlerGuard, ThrottlerModule } from '@nestjs/throttler';
|
||||
|
||||
@Module({
|
||||
@@ -41,15 +32,6 @@ import { ThrottlerGuard, ThrottlerModule } from '@nestjs/throttler';
|
||||
MemoryModule,
|
||||
LogModule,
|
||||
SkillsModule,
|
||||
PluginModule,
|
||||
McpModule,
|
||||
AdminModule,
|
||||
PreferencesModule,
|
||||
CommandsModule,
|
||||
GCModule,
|
||||
QueueModule,
|
||||
ReloadModule,
|
||||
WorkspaceModule,
|
||||
],
|
||||
controllers: [HealthController],
|
||||
providers: [
|
||||
|
||||
@@ -7,17 +7,16 @@ import { AUTH } from './auth.tokens.js';
|
||||
export function mountAuthHandler(app: NestFastifyApplication): void {
|
||||
const auth = app.get<Auth>(AUTH);
|
||||
const nodeHandler = toNodeHandler(auth);
|
||||
const corsOrigin = process.env['GATEWAY_CORS_ORIGIN'] ?? 'http://localhost:3000';
|
||||
|
||||
const fastify = app.getHttpAdapter().getInstance();
|
||||
|
||||
// BetterAuth is mounted at the raw HTTP level via Fastify's onRequest hook,
|
||||
// bypassing NestJS middleware (including CORS). We must set CORS headers
|
||||
// manually on the raw response before handing off to BetterAuth.
|
||||
// Use Fastify's addHook to intercept auth requests at the raw HTTP level,
|
||||
// before Fastify's body parser runs. This avoids conflicts with NestJS's
|
||||
// custom content-type parser.
|
||||
fastify.addHook(
|
||||
'onRequest',
|
||||
(
|
||||
req: { raw: IncomingMessage; url: string; method: string },
|
||||
req: { raw: IncomingMessage; url: string },
|
||||
reply: { raw: ServerResponse; hijack: () => void },
|
||||
done: () => void,
|
||||
) => {
|
||||
@@ -26,27 +25,6 @@ export function mountAuthHandler(app: NestFastifyApplication): void {
|
||||
return;
|
||||
}
|
||||
|
||||
const origin = req.raw.headers.origin;
|
||||
const allowed = corsOrigin.split(',').map((o) => o.trim());
|
||||
|
||||
if (origin && allowed.includes(origin)) {
|
||||
reply.raw.setHeader('Access-Control-Allow-Origin', origin);
|
||||
reply.raw.setHeader('Access-Control-Allow-Credentials', 'true');
|
||||
reply.raw.setHeader(
|
||||
'Access-Control-Allow-Methods',
|
||||
'GET, POST, PUT, PATCH, DELETE, OPTIONS',
|
||||
);
|
||||
reply.raw.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Cookie');
|
||||
}
|
||||
|
||||
// Handle preflight
|
||||
if (req.method === 'OPTIONS') {
|
||||
reply.hijack();
|
||||
reply.raw.writeHead(204);
|
||||
reply.raw.end();
|
||||
return;
|
||||
}
|
||||
|
||||
reply.hijack();
|
||||
nodeHandler(req.raw as IncomingMessage, reply.raw as ServerResponse)
|
||||
.then(() => {
|
||||
|
||||
@@ -3,11 +3,9 @@ import { createAuth, type Auth } from '@mosaic/auth';
|
||||
import type { Db } from '@mosaic/db';
|
||||
import { DB } from '../database/database.module.js';
|
||||
import { AUTH } from './auth.tokens.js';
|
||||
import { SsoController } from './sso.controller.js';
|
||||
|
||||
@Global()
|
||||
@Module({
|
||||
controllers: [SsoController],
|
||||
providers: [
|
||||
{
|
||||
provide: AUTH,
|
||||
|
||||
@@ -1,40 +0,0 @@
|
||||
import { afterEach, describe, expect, it, vi } from 'vitest';
|
||||
import { SsoController } from './sso.controller.js';
|
||||
|
||||
describe('SsoController', () => {
|
||||
afterEach(() => {
|
||||
vi.unstubAllEnvs();
|
||||
});
|
||||
|
||||
it('lists configured OIDC providers', () => {
|
||||
vi.stubEnv('WORKOS_CLIENT_ID', 'workos-client');
|
||||
vi.stubEnv('WORKOS_CLIENT_SECRET', 'workos-secret');
|
||||
vi.stubEnv('WORKOS_ISSUER', 'https://auth.workos.com/sso/client_123');
|
||||
|
||||
const controller = new SsoController();
|
||||
const providers = controller.list();
|
||||
|
||||
expect(providers.find((provider) => provider.id === 'workos')).toMatchObject({
|
||||
configured: true,
|
||||
loginMode: 'oidc',
|
||||
callbackPath: '/api/auth/oauth2/callback/workos',
|
||||
teamSync: { enabled: true, claim: 'organization_id' },
|
||||
});
|
||||
});
|
||||
|
||||
it('prefers SAML fallback for Keycloak when only the SAML login URL is configured', () => {
|
||||
vi.stubEnv('KEYCLOAK_SAML_LOGIN_URL', 'https://sso.example.com/realms/mosaic/protocol/saml');
|
||||
|
||||
const controller = new SsoController();
|
||||
const providers = controller.list();
|
||||
|
||||
expect(providers.find((provider) => provider.id === 'keycloak')).toMatchObject({
|
||||
configured: true,
|
||||
loginMode: 'saml',
|
||||
samlFallback: {
|
||||
configured: true,
|
||||
loginUrl: 'https://sso.example.com/realms/mosaic/protocol/saml',
|
||||
},
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,10 +0,0 @@
|
||||
import { Controller, Get } from '@nestjs/common';
|
||||
import { buildSsoDiscovery, type SsoProviderDiscovery } from '@mosaic/auth';
|
||||
|
||||
@Controller('api/sso/providers')
|
||||
export class SsoController {
|
||||
@Get()
|
||||
list(): SsoProviderDiscovery[] {
|
||||
return buildSsoDiscovery();
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,3 @@
|
||||
import 'reflect-metadata';
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { resolve } from 'node:path';
|
||||
import { validateSync } from 'class-validator';
|
||||
|
||||
@@ -28,8 +28,4 @@ export class ChatSocketMessageDto {
|
||||
@IsString()
|
||||
@MaxLength(255)
|
||||
modelId?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsUUID()
|
||||
agentId?: string;
|
||||
}
|
||||
|
||||
@@ -12,44 +12,12 @@ import {
|
||||
import { Server, Socket } from 'socket.io';
|
||||
import type { AgentSessionEvent } from '@mariozechner/pi-coding-agent';
|
||||
import type { Auth } from '@mosaic/auth';
|
||||
import type { Brain } from '@mosaic/brain';
|
||||
import type {
|
||||
SetThinkingPayload,
|
||||
SlashCommandPayload,
|
||||
SystemReloadPayload,
|
||||
RoutingDecisionInfo,
|
||||
AbortPayload,
|
||||
} from '@mosaic/types';
|
||||
import { AgentService, type ConversationHistoryMessage } from '../agent/agent.service.js';
|
||||
import { AgentService } from '../agent/agent.service.js';
|
||||
import { AUTH } from '../auth/auth.tokens.js';
|
||||
import { BRAIN } from '../brain/brain.tokens.js';
|
||||
import { CommandRegistryService } from '../commands/command-registry.service.js';
|
||||
import { CommandExecutorService } from '../commands/command-executor.service.js';
|
||||
import { RoutingEngineService } from '../agent/routing/routing-engine.service.js';
|
||||
import { v4 as uuid } from 'uuid';
|
||||
import { ChatSocketMessageDto } from './chat.dto.js';
|
||||
import { validateSocketSession } from './chat.gateway-auth.js';
|
||||
|
||||
/** Per-client state tracking streaming accumulation for persistence. */
|
||||
interface ClientSession {
|
||||
conversationId: string;
|
||||
cleanup: () => void;
|
||||
/** Accumulated assistant response text for the current turn. */
|
||||
assistantText: string;
|
||||
/** Tool calls observed during the current turn. */
|
||||
toolCalls: Array<{ toolCallId: string; toolName: string; args: unknown; isError: boolean }>;
|
||||
/** Tool calls in-flight (started but not ended yet). */
|
||||
pendingToolCalls: Map<string, { toolName: string; args: unknown }>;
|
||||
/** Last routing decision made for this session (M4-008) */
|
||||
lastRoutingDecision?: RoutingDecisionInfo;
|
||||
}
|
||||
|
||||
/**
|
||||
* Per-conversation model overrides set via /model command (M4-007).
|
||||
* Keyed by conversationId, value is the model name to use.
|
||||
*/
|
||||
const modelOverrides = new Map<string, string>();
|
||||
|
||||
@WebSocketGateway({
|
||||
cors: {
|
||||
origin: process.env['GATEWAY_CORS_ORIGIN'] ?? 'http://localhost:3000',
|
||||
@@ -61,15 +29,14 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
|
||||
server!: Server;
|
||||
|
||||
private readonly logger = new Logger(ChatGateway.name);
|
||||
private readonly clientSessions = new Map<string, ClientSession>();
|
||||
private readonly clientSessions = new Map<
|
||||
string,
|
||||
{ conversationId: string; cleanup: () => void }
|
||||
>();
|
||||
|
||||
constructor(
|
||||
@Inject(AgentService) private readonly agentService: AgentService,
|
||||
@Inject(AUTH) private readonly auth: Auth,
|
||||
@Inject(BRAIN) private readonly brain: Brain,
|
||||
@Inject(CommandRegistryService) private readonly commandRegistry: CommandRegistryService,
|
||||
@Inject(CommandExecutorService) private readonly commandExecutor: CommandExecutorService,
|
||||
@Inject(RoutingEngineService) private readonly routingEngine: RoutingEngineService,
|
||||
) {}
|
||||
|
||||
afterInit(): void {
|
||||
@@ -87,9 +54,6 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
|
||||
client.data.user = session.user;
|
||||
client.data.session = session.session;
|
||||
this.logger.log(`Client connected: ${client.id}`);
|
||||
|
||||
// Broadcast command manifest to the newly connected client
|
||||
client.emit('commands:manifest', { manifest: this.commandRegistry.getManifest() });
|
||||
}
|
||||
|
||||
handleDisconnect(client: Socket): void {
|
||||
@@ -108,78 +72,17 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
|
||||
@MessageBody() data: ChatSocketMessageDto,
|
||||
): Promise<void> {
|
||||
const conversationId = data.conversationId ?? uuid();
|
||||
const userId = (client.data.user as { id: string } | undefined)?.id;
|
||||
|
||||
this.logger.log(`Message from ${client.id} in conversation ${conversationId}`);
|
||||
|
||||
// Ensure agent session exists for this conversation
|
||||
let sessionRoutingDecision: RoutingDecisionInfo | undefined;
|
||||
try {
|
||||
let agentSession = this.agentService.getSession(conversationId);
|
||||
if (!agentSession) {
|
||||
// When resuming an existing conversation, load prior messages to inject as context (M1-004)
|
||||
const conversationHistory = await this.loadConversationHistory(conversationId, userId);
|
||||
|
||||
// M5-004: Check if there's an existing sessionId bound to this conversation
|
||||
let existingSessionId: string | undefined;
|
||||
if (userId) {
|
||||
existingSessionId = await this.getConversationSessionId(conversationId, userId);
|
||||
if (existingSessionId) {
|
||||
this.logger.log(
|
||||
`Resuming existing sessionId=${existingSessionId} for conversation=${conversationId}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Determine provider/model via routing engine or per-session /model override (M4-012 / M4-007)
|
||||
let resolvedProvider = data.provider;
|
||||
let resolvedModelId = data.modelId;
|
||||
|
||||
const modelOverride = modelOverrides.get(conversationId);
|
||||
if (modelOverride) {
|
||||
// /model override bypasses routing engine (M4-007)
|
||||
resolvedModelId = modelOverride;
|
||||
this.logger.log(
|
||||
`Using /model override "${modelOverride}" for conversation=${conversationId}`,
|
||||
);
|
||||
} else if (!resolvedProvider && !resolvedModelId) {
|
||||
// No explicit provider/model from client — use routing engine (M4-012)
|
||||
try {
|
||||
const routingDecision = await this.routingEngine.resolve(data.content, userId);
|
||||
resolvedProvider = routingDecision.provider;
|
||||
resolvedModelId = routingDecision.model;
|
||||
sessionRoutingDecision = {
|
||||
model: routingDecision.model,
|
||||
provider: routingDecision.provider,
|
||||
ruleName: routingDecision.ruleName,
|
||||
reason: routingDecision.reason,
|
||||
};
|
||||
this.logger.log(
|
||||
`Routing decision for conversation=${conversationId}: ${routingDecision.provider}/${routingDecision.model} (rule="${routingDecision.ruleName}")`,
|
||||
);
|
||||
} catch (routingErr) {
|
||||
this.logger.warn(
|
||||
`Routing engine failed for conversation=${conversationId}, using defaults`,
|
||||
routingErr instanceof Error ? routingErr.message : String(routingErr),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// M5-004: Use existingSessionId as sessionId when available (session reuse)
|
||||
const sessionIdToCreate = existingSessionId ?? conversationId;
|
||||
agentSession = await this.agentService.createSession(sessionIdToCreate, {
|
||||
provider: resolvedProvider,
|
||||
modelId: resolvedModelId,
|
||||
agentConfigId: data.agentId,
|
||||
userId,
|
||||
conversationHistory: conversationHistory.length > 0 ? conversationHistory : undefined,
|
||||
agentSession = await this.agentService.createSession(conversationId, {
|
||||
provider: data.provider,
|
||||
modelId: data.modelId,
|
||||
});
|
||||
|
||||
if (conversationHistory.length > 0) {
|
||||
this.logger.log(
|
||||
`Loaded ${conversationHistory.length} prior messages for conversation=${conversationId}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
this.logger.error(
|
||||
@@ -193,38 +96,6 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
|
||||
return;
|
||||
}
|
||||
|
||||
// Ensure conversation record exists in the DB before persisting messages
|
||||
// M5-004: Also bind the sessionId to the conversation record
|
||||
if (userId) {
|
||||
await this.ensureConversation(conversationId, userId);
|
||||
await this.bindSessionToConversation(conversationId, userId, conversationId);
|
||||
}
|
||||
|
||||
// M5-007: Count the user message
|
||||
this.agentService.recordMessage(conversationId);
|
||||
|
||||
// Persist the user message
|
||||
if (userId) {
|
||||
try {
|
||||
await this.brain.conversations.addMessage(
|
||||
{
|
||||
conversationId,
|
||||
role: 'user',
|
||||
content: data.content,
|
||||
metadata: {
|
||||
timestamp: new Date().toISOString(),
|
||||
},
|
||||
},
|
||||
userId,
|
||||
);
|
||||
} catch (err) {
|
||||
this.logger.error(
|
||||
`Failed to persist user message for conversation=${conversationId}`,
|
||||
err instanceof Error ? err.stack : String(err),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Always clean up previous listener to prevent leak
|
||||
const existing = this.clientSessions.get(client.id);
|
||||
if (existing) {
|
||||
@@ -236,40 +107,11 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
|
||||
this.relayEvent(client, conversationId, event);
|
||||
});
|
||||
|
||||
// Preserve routing decision from the existing client session if we didn't get a new one
|
||||
const prevClientSession = this.clientSessions.get(client.id);
|
||||
const routingDecisionToStore = sessionRoutingDecision ?? prevClientSession?.lastRoutingDecision;
|
||||
|
||||
this.clientSessions.set(client.id, {
|
||||
conversationId,
|
||||
cleanup,
|
||||
assistantText: '',
|
||||
toolCalls: [],
|
||||
pendingToolCalls: new Map(),
|
||||
lastRoutingDecision: routingDecisionToStore,
|
||||
});
|
||||
this.clientSessions.set(client.id, { conversationId, cleanup });
|
||||
|
||||
// Track channel connection
|
||||
this.agentService.addChannel(conversationId, `websocket:${client.id}`);
|
||||
|
||||
// Send session info so the client knows the model/provider (M4-008: include routing decision)
|
||||
// Include agentName when a named agent config is active (M5-001)
|
||||
{
|
||||
const agentSession = this.agentService.getSession(conversationId);
|
||||
if (agentSession) {
|
||||
const piSession = agentSession.piSession;
|
||||
client.emit('session:info', {
|
||||
conversationId,
|
||||
provider: agentSession.provider,
|
||||
modelId: agentSession.modelId,
|
||||
thinkingLevel: piSession.thinkingLevel,
|
||||
availableThinkingLevels: piSession.getAvailableThinkingLevels(),
|
||||
...(agentSession.agentName ? { agentName: agentSession.agentName } : {}),
|
||||
...(routingDecisionToStore ? { routingDecision: routingDecisionToStore } : {}),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Send acknowledgment
|
||||
client.emit('message:ack', { conversationId, messageId: uuid() });
|
||||
|
||||
@@ -288,245 +130,6 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('set:thinking')
|
||||
handleSetThinking(
|
||||
@ConnectedSocket() client: Socket,
|
||||
@MessageBody() data: SetThinkingPayload,
|
||||
): void {
|
||||
const session = this.agentService.getSession(data.conversationId);
|
||||
if (!session) {
|
||||
client.emit('error', {
|
||||
conversationId: data.conversationId,
|
||||
error: 'No active session for this conversation.',
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
const validLevels = session.piSession.getAvailableThinkingLevels();
|
||||
if (!validLevels.includes(data.level as never)) {
|
||||
client.emit('error', {
|
||||
conversationId: data.conversationId,
|
||||
error: `Invalid thinking level "${data.level}". Available: ${validLevels.join(', ')}`,
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
session.piSession.setThinkingLevel(data.level as never);
|
||||
this.logger.log(
|
||||
`Thinking level set to "${data.level}" for conversation ${data.conversationId}`,
|
||||
);
|
||||
|
||||
client.emit('session:info', {
|
||||
conversationId: data.conversationId,
|
||||
provider: session.provider,
|
||||
modelId: session.modelId,
|
||||
thinkingLevel: session.piSession.thinkingLevel,
|
||||
availableThinkingLevels: session.piSession.getAvailableThinkingLevels(),
|
||||
...(session.agentName ? { agentName: session.agentName } : {}),
|
||||
});
|
||||
}
|
||||
|
||||
@SubscribeMessage('abort')
|
||||
async handleAbort(
|
||||
@ConnectedSocket() client: Socket,
|
||||
@MessageBody() data: AbortPayload,
|
||||
): Promise<void> {
|
||||
const conversationId = data.conversationId;
|
||||
this.logger.log(`Abort requested by ${client.id} for conversation ${conversationId}`);
|
||||
|
||||
const session = this.agentService.getSession(conversationId);
|
||||
if (!session) {
|
||||
client.emit('error', {
|
||||
conversationId,
|
||||
error: 'No active session to abort.',
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
await session.piSession.abort();
|
||||
this.logger.log(`Agent session ${conversationId} aborted successfully`);
|
||||
} catch (err) {
|
||||
this.logger.error(
|
||||
`Failed to abort session ${conversationId}`,
|
||||
err instanceof Error ? err.stack : String(err),
|
||||
);
|
||||
client.emit('error', {
|
||||
conversationId,
|
||||
error: 'Failed to abort the agent operation.',
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('command:execute')
|
||||
async handleCommandExecute(
|
||||
@ConnectedSocket() client: Socket,
|
||||
@MessageBody() payload: SlashCommandPayload,
|
||||
): Promise<void> {
|
||||
const userId = (client.data.user as { id: string } | undefined)?.id ?? 'unknown';
|
||||
const result = await this.commandExecutor.execute(payload, userId);
|
||||
client.emit('command:result', result);
|
||||
}
|
||||
|
||||
broadcastReload(payload: SystemReloadPayload): void {
|
||||
this.server.emit('system:reload', payload);
|
||||
this.logger.log('Broadcasted system:reload to all connected clients');
|
||||
}
|
||||
|
||||
/**
|
||||
* Set a per-conversation model override (M4-007 / M5-002).
|
||||
* When set, the routing engine is bypassed and the specified model is used.
|
||||
* Pass null to clear the override and resume automatic routing.
|
||||
* M5-005: Emits session:info to clients subscribed to this conversation when a model is set.
|
||||
* M5-007: Records a model switch in session metrics.
|
||||
*/
|
||||
setModelOverride(conversationId: string, modelName: string | null): void {
|
||||
if (modelName) {
|
||||
modelOverrides.set(conversationId, modelName);
|
||||
this.logger.log(`Model override set: conversation=${conversationId} model="${modelName}"`);
|
||||
|
||||
// M5-002: Update the live session's modelId so session:info reflects the new model immediately
|
||||
this.agentService.updateSessionModel(conversationId, modelName);
|
||||
|
||||
// M5-005: Broadcast session:info to all clients subscribed to this conversation
|
||||
this.broadcastSessionInfo(conversationId);
|
||||
} else {
|
||||
modelOverrides.delete(conversationId);
|
||||
this.logger.log(`Model override cleared: conversation=${conversationId}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the active model override for a conversation, or undefined if none.
|
||||
*/
|
||||
getModelOverride(conversationId: string): string | undefined {
|
||||
return modelOverrides.get(conversationId);
|
||||
}
|
||||
|
||||
/**
|
||||
* M5-005: Broadcast session:info to all clients currently subscribed to a conversation.
|
||||
* Called on model or agent switch to ensure the TUI TopBar updates immediately.
|
||||
*/
|
||||
broadcastSessionInfo(
|
||||
conversationId: string,
|
||||
extra?: { agentName?: string; routingDecision?: RoutingDecisionInfo },
|
||||
): void {
|
||||
const agentSession = this.agentService.getSession(conversationId);
|
||||
if (!agentSession) return;
|
||||
|
||||
const piSession = agentSession.piSession;
|
||||
const resolvedAgentName = extra?.agentName ?? agentSession.agentName;
|
||||
const payload = {
|
||||
conversationId,
|
||||
provider: agentSession.provider,
|
||||
modelId: agentSession.modelId,
|
||||
thinkingLevel: piSession.thinkingLevel,
|
||||
availableThinkingLevels: piSession.getAvailableThinkingLevels(),
|
||||
...(resolvedAgentName ? { agentName: resolvedAgentName } : {}),
|
||||
...(extra?.routingDecision ? { routingDecision: extra.routingDecision } : {}),
|
||||
};
|
||||
|
||||
// Emit to all clients currently subscribed to this conversation
|
||||
for (const [clientId, session] of this.clientSessions) {
|
||||
if (session.conversationId === conversationId) {
|
||||
const socket = this.server.sockets.sockets.get(clientId);
|
||||
if (socket?.connected) {
|
||||
socket.emit('session:info', payload);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensure a conversation record exists in the DB.
|
||||
* Creates it if absent — safe to call concurrently since a duplicate insert
|
||||
* would fail on the PK constraint and be caught here.
|
||||
*/
|
||||
private async ensureConversation(conversationId: string, userId: string): Promise<void> {
|
||||
try {
|
||||
const existing = await this.brain.conversations.findById(conversationId, userId);
|
||||
if (!existing) {
|
||||
await this.brain.conversations.create({
|
||||
id: conversationId,
|
||||
userId,
|
||||
});
|
||||
}
|
||||
} catch (err) {
|
||||
this.logger.error(
|
||||
`Failed to ensure conversation record for conversation=${conversationId}`,
|
||||
err instanceof Error ? err.stack : String(err),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* M5-004: Bind the agent sessionId to the conversation record in the DB.
|
||||
* Updates the sessionId column so future resumes can reuse the session.
|
||||
*/
|
||||
private async bindSessionToConversation(
|
||||
conversationId: string,
|
||||
userId: string,
|
||||
sessionId: string,
|
||||
): Promise<void> {
|
||||
try {
|
||||
await this.brain.conversations.update(conversationId, userId, { sessionId });
|
||||
} catch (err) {
|
||||
this.logger.error(
|
||||
`Failed to bind sessionId=${sessionId} to conversation=${conversationId}`,
|
||||
err instanceof Error ? err.stack : String(err),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* M5-004: Retrieve the sessionId bound to a conversation, if any.
|
||||
* Returns undefined when the conversation does not exist or has no bound session.
|
||||
*/
|
||||
private async getConversationSessionId(
|
||||
conversationId: string,
|
||||
userId: string,
|
||||
): Promise<string | undefined> {
|
||||
try {
|
||||
const conv = await this.brain.conversations.findById(conversationId, userId);
|
||||
return conv?.sessionId ?? undefined;
|
||||
} catch (err) {
|
||||
this.logger.error(
|
||||
`Failed to get sessionId for conversation=${conversationId}`,
|
||||
err instanceof Error ? err.stack : String(err),
|
||||
);
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Load prior conversation messages from DB for context injection on session resume (M1-004).
|
||||
* Returns an empty array when no history exists, the conversation is not owned by the user,
|
||||
* or userId is not provided.
|
||||
*/
|
||||
private async loadConversationHistory(
|
||||
conversationId: string,
|
||||
userId: string | undefined,
|
||||
): Promise<ConversationHistoryMessage[]> {
|
||||
if (!userId) return [];
|
||||
|
||||
try {
|
||||
const messages = await this.brain.conversations.findMessages(conversationId, userId);
|
||||
if (messages.length === 0) return [];
|
||||
|
||||
return messages.map((msg) => ({
|
||||
role: msg.role as 'user' | 'assistant' | 'system',
|
||||
content: msg.content,
|
||||
createdAt: msg.createdAt,
|
||||
}));
|
||||
} catch (err) {
|
||||
this.logger.error(
|
||||
`Failed to load conversation history for conversation=${conversationId}`,
|
||||
err instanceof Error ? err.stack : String(err),
|
||||
);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
private relayEvent(client: Socket, conversationId: string, event: AgentSessionEvent): void {
|
||||
if (!client.connected) {
|
||||
this.logger.warn(
|
||||
@@ -536,109 +139,17 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
|
||||
}
|
||||
|
||||
switch (event.type) {
|
||||
case 'agent_start': {
|
||||
// Reset accumulation buffers for the new turn
|
||||
const cs = this.clientSessions.get(client.id);
|
||||
if (cs) {
|
||||
cs.assistantText = '';
|
||||
cs.toolCalls = [];
|
||||
cs.pendingToolCalls.clear();
|
||||
}
|
||||
case 'agent_start':
|
||||
client.emit('agent:start', { conversationId });
|
||||
break;
|
||||
}
|
||||
|
||||
case 'agent_end': {
|
||||
// Gather usage stats from the Pi session
|
||||
const agentSession = this.agentService.getSession(conversationId);
|
||||
const piSession = agentSession?.piSession;
|
||||
const stats = piSession?.getSessionStats();
|
||||
const contextUsage = piSession?.getContextUsage();
|
||||
|
||||
const usagePayload = stats
|
||||
? {
|
||||
provider: agentSession?.provider ?? 'unknown',
|
||||
modelId: agentSession?.modelId ?? 'unknown',
|
||||
thinkingLevel: piSession?.thinkingLevel ?? 'off',
|
||||
tokens: stats.tokens,
|
||||
cost: stats.cost,
|
||||
context: {
|
||||
percent: contextUsage?.percent ?? null,
|
||||
window: contextUsage?.contextWindow ?? 0,
|
||||
},
|
||||
}
|
||||
: undefined;
|
||||
|
||||
client.emit('agent:end', {
|
||||
conversationId,
|
||||
usage: usagePayload,
|
||||
});
|
||||
|
||||
// M5-007: Accumulate token usage in session metrics
|
||||
if (stats?.tokens) {
|
||||
this.agentService.recordTokenUsage(conversationId, {
|
||||
input: stats.tokens.input ?? 0,
|
||||
output: stats.tokens.output ?? 0,
|
||||
cacheRead: stats.tokens.cacheRead ?? 0,
|
||||
cacheWrite: stats.tokens.cacheWrite ?? 0,
|
||||
total: stats.tokens.total ?? 0,
|
||||
});
|
||||
}
|
||||
|
||||
// Persist the assistant message with metadata
|
||||
const cs = this.clientSessions.get(client.id);
|
||||
const userId = (client.data.user as { id: string } | undefined)?.id;
|
||||
if (cs && userId && cs.assistantText.trim().length > 0) {
|
||||
const metadata: Record<string, unknown> = {
|
||||
timestamp: new Date().toISOString(),
|
||||
model: agentSession?.modelId ?? 'unknown',
|
||||
provider: agentSession?.provider ?? 'unknown',
|
||||
toolCalls: cs.toolCalls,
|
||||
};
|
||||
|
||||
if (stats?.tokens) {
|
||||
metadata['tokenUsage'] = {
|
||||
input: stats.tokens.input,
|
||||
output: stats.tokens.output,
|
||||
cacheRead: stats.tokens.cacheRead,
|
||||
cacheWrite: stats.tokens.cacheWrite,
|
||||
total: stats.tokens.total,
|
||||
};
|
||||
}
|
||||
|
||||
this.brain.conversations
|
||||
.addMessage(
|
||||
{
|
||||
conversationId,
|
||||
role: 'assistant',
|
||||
content: cs.assistantText,
|
||||
metadata,
|
||||
},
|
||||
userId,
|
||||
)
|
||||
.catch((err: unknown) => {
|
||||
this.logger.error(
|
||||
`Failed to persist assistant message for conversation=${conversationId}`,
|
||||
err instanceof Error ? err.stack : String(err),
|
||||
);
|
||||
});
|
||||
|
||||
// Reset accumulation
|
||||
cs.assistantText = '';
|
||||
cs.toolCalls = [];
|
||||
cs.pendingToolCalls.clear();
|
||||
}
|
||||
case 'agent_end':
|
||||
client.emit('agent:end', { conversationId });
|
||||
break;
|
||||
}
|
||||
|
||||
case 'message_update': {
|
||||
const assistantEvent = event.assistantMessageEvent;
|
||||
if (assistantEvent.type === 'text_delta') {
|
||||
// Accumulate assistant text for persistence
|
||||
const cs = this.clientSessions.get(client.id);
|
||||
if (cs) {
|
||||
cs.assistantText += assistantEvent.delta;
|
||||
}
|
||||
client.emit('agent:text', {
|
||||
conversationId,
|
||||
text: assistantEvent.delta,
|
||||
@@ -652,36 +163,15 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
|
||||
break;
|
||||
}
|
||||
|
||||
case 'tool_execution_start': {
|
||||
// Track pending tool call for later recording
|
||||
const cs = this.clientSessions.get(client.id);
|
||||
if (cs) {
|
||||
cs.pendingToolCalls.set(event.toolCallId, {
|
||||
toolName: event.toolName,
|
||||
args: event.args,
|
||||
});
|
||||
}
|
||||
case 'tool_execution_start':
|
||||
client.emit('agent:tool:start', {
|
||||
conversationId,
|
||||
toolCallId: event.toolCallId,
|
||||
toolName: event.toolName,
|
||||
});
|
||||
break;
|
||||
}
|
||||
|
||||
case 'tool_execution_end': {
|
||||
// Finalise tool call record
|
||||
const cs = this.clientSessions.get(client.id);
|
||||
if (cs) {
|
||||
const pending = cs.pendingToolCalls.get(event.toolCallId);
|
||||
cs.toolCalls.push({
|
||||
toolCallId: event.toolCallId,
|
||||
toolName: event.toolName,
|
||||
args: pending?.args ?? null,
|
||||
isError: event.isError,
|
||||
});
|
||||
cs.pendingToolCalls.delete(event.toolCallId);
|
||||
}
|
||||
case 'tool_execution_end':
|
||||
client.emit('agent:tool:end', {
|
||||
conversationId,
|
||||
toolCallId: event.toolCallId,
|
||||
@@ -689,7 +179,6 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
|
||||
isError: event.isError,
|
||||
});
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,12 +1,9 @@
|
||||
import { forwardRef, Module } from '@nestjs/common';
|
||||
import { CommandsModule } from '../commands/commands.module.js';
|
||||
import { Module } from '@nestjs/common';
|
||||
import { ChatGateway } from './chat.gateway.js';
|
||||
import { ChatController } from './chat.controller.js';
|
||||
|
||||
@Module({
|
||||
imports: [forwardRef(() => CommandsModule)],
|
||||
controllers: [ChatController],
|
||||
providers: [ChatGateway],
|
||||
exports: [ChatGateway],
|
||||
})
|
||||
export class ChatModule {}
|
||||
|
||||
@@ -1,249 +0,0 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
||||
import { CommandExecutorService } from './command-executor.service.js';
|
||||
import type { SlashCommandPayload } from '@mosaic/types';
|
||||
|
||||
// Minimal mock implementations
|
||||
const mockRegistry = {
|
||||
getManifest: vi.fn(() => ({
|
||||
version: 1,
|
||||
commands: [
|
||||
{ name: 'provider', aliases: [], scope: 'agent', execution: 'hybrid', available: true },
|
||||
{ name: 'mission', aliases: [], scope: 'agent', execution: 'socket', available: true },
|
||||
{ name: 'agent', aliases: ['a'], scope: 'agent', execution: 'socket', available: true },
|
||||
{ name: 'prdy', aliases: [], scope: 'agent', execution: 'socket', available: true },
|
||||
{ name: 'tools', aliases: [], scope: 'agent', execution: 'socket', available: true },
|
||||
],
|
||||
skills: [],
|
||||
})),
|
||||
};
|
||||
|
||||
const mockAgentService = {
|
||||
getSession: vi.fn(() => undefined),
|
||||
applyAgentConfig: vi.fn(),
|
||||
updateSessionModel: vi.fn(),
|
||||
};
|
||||
|
||||
const mockSystemOverride = {
|
||||
set: vi.fn(),
|
||||
get: vi.fn(),
|
||||
clear: vi.fn(),
|
||||
renew: vi.fn(),
|
||||
};
|
||||
|
||||
const mockSessionGC = {
|
||||
sweepOrphans: vi.fn(() => ({ orphanedSessions: 0, totalCleaned: [], duration: 0 })),
|
||||
};
|
||||
|
||||
const mockRedis = {
|
||||
set: vi.fn().mockResolvedValue('OK'),
|
||||
get: vi.fn(),
|
||||
del: vi.fn(),
|
||||
};
|
||||
|
||||
// Mock agent config returned by brain.agents.findByName for "my-agent-id"
|
||||
const mockAgentConfig = {
|
||||
id: 'my-agent-id',
|
||||
name: 'my-agent-id',
|
||||
model: 'claude-sonnet-4-6',
|
||||
provider: 'anthropic',
|
||||
systemPrompt: null,
|
||||
allowedTools: null,
|
||||
isSystem: false,
|
||||
ownerId: 'user-123',
|
||||
status: 'idle',
|
||||
createdAt: new Date(),
|
||||
updatedAt: new Date(),
|
||||
};
|
||||
|
||||
const mockBrain = {
|
||||
agents: {
|
||||
// findByName resolves with the agent when name matches, undefined otherwise
|
||||
findByName: vi.fn((name: string) =>
|
||||
Promise.resolve(name === 'my-agent-id' ? mockAgentConfig : undefined),
|
||||
),
|
||||
findById: vi.fn((id: string) =>
|
||||
Promise.resolve(id === 'my-agent-id' ? mockAgentConfig : undefined),
|
||||
),
|
||||
create: vi.fn(),
|
||||
},
|
||||
};
|
||||
|
||||
const mockChatGateway = {
|
||||
broadcastSessionInfo: vi.fn(),
|
||||
};
|
||||
|
||||
function buildService(): CommandExecutorService {
|
||||
return new CommandExecutorService(
|
||||
mockRegistry as never,
|
||||
mockAgentService as never,
|
||||
mockSystemOverride as never,
|
||||
mockSessionGC as never,
|
||||
mockRedis as never,
|
||||
mockBrain as never,
|
||||
null,
|
||||
mockChatGateway as never,
|
||||
null,
|
||||
);
|
||||
}
|
||||
|
||||
describe('CommandExecutorService — P8-012 commands', () => {
|
||||
let service: CommandExecutorService;
|
||||
const userId = 'user-123';
|
||||
const conversationId = 'conv-456';
|
||||
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
service = buildService();
|
||||
});
|
||||
|
||||
// /provider login — missing provider name
|
||||
it('/provider login with no provider name returns usage error', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'provider', args: 'login', conversationId };
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.message).toContain('Usage: /provider login');
|
||||
expect(result.command).toBe('provider');
|
||||
});
|
||||
|
||||
// /provider login anthropic — success with URL containing poll token
|
||||
it('/provider login <name> returns success with URL and poll token', async () => {
|
||||
const payload: SlashCommandPayload = {
|
||||
command: 'provider',
|
||||
args: 'login anthropic',
|
||||
conversationId,
|
||||
};
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.command).toBe('provider');
|
||||
expect(result.message).toContain('anthropic');
|
||||
expect(result.message).toContain('http');
|
||||
// data should contain loginUrl and pollToken
|
||||
expect(result.data).toBeDefined();
|
||||
const data = result.data as Record<string, unknown>;
|
||||
expect(typeof data['loginUrl']).toBe('string');
|
||||
expect(typeof data['pollToken']).toBe('string');
|
||||
expect(data['loginUrl'] as string).toContain('anthropic');
|
||||
expect(data['loginUrl'] as string).toContain(data['pollToken'] as string);
|
||||
// Verify Valkey was called
|
||||
expect(mockRedis.set).toHaveBeenCalledOnce();
|
||||
const [key, value, , ttl] = mockRedis.set.mock.calls[0] as [string, string, string, number];
|
||||
expect(key).toContain('mosaic:auth:poll:');
|
||||
const stored = JSON.parse(value) as { status: string; provider: string; userId: string };
|
||||
expect(stored.status).toBe('pending');
|
||||
expect(stored.provider).toBe('anthropic');
|
||||
expect(stored.userId).toBe(userId);
|
||||
expect(ttl).toBe(300);
|
||||
});
|
||||
|
||||
// /provider with no args — returns usage
|
||||
it('/provider with no args returns usage message', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'provider', conversationId };
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.message).toContain('Usage: /provider');
|
||||
});
|
||||
|
||||
// /provider list
|
||||
it('/provider list returns success', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'provider', args: 'list', conversationId };
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.command).toBe('provider');
|
||||
});
|
||||
|
||||
// /provider logout with no name — usage error
|
||||
it('/provider logout with no name returns error', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'provider', args: 'logout', conversationId };
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.message).toContain('Usage: /provider logout');
|
||||
});
|
||||
|
||||
// /provider unknown subcommand
|
||||
it('/provider unknown subcommand returns error', async () => {
|
||||
const payload: SlashCommandPayload = {
|
||||
command: 'provider',
|
||||
args: 'unknown',
|
||||
conversationId,
|
||||
};
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.message).toContain('Unknown subcommand');
|
||||
});
|
||||
|
||||
// /mission status
|
||||
it('/mission status returns stub message', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'mission', args: 'status', conversationId };
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.command).toBe('mission');
|
||||
expect(result.message).toContain('Mission status');
|
||||
});
|
||||
|
||||
// /mission with no args
|
||||
it('/mission with no args returns status stub', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'mission', conversationId };
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.message).toContain('Mission status');
|
||||
});
|
||||
|
||||
// /mission set <id>
|
||||
it('/mission set <id> returns confirmation', async () => {
|
||||
const payload: SlashCommandPayload = {
|
||||
command: 'mission',
|
||||
args: 'set my-mission-123',
|
||||
conversationId,
|
||||
};
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.message).toContain('my-mission-123');
|
||||
});
|
||||
|
||||
// /agent list
|
||||
it('/agent list returns stub message', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'agent', args: 'list', conversationId };
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.command).toBe('agent');
|
||||
expect(result.message).toContain('agent');
|
||||
});
|
||||
|
||||
// /agent with no args
|
||||
it('/agent with no args returns usage', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'agent', conversationId };
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.message).toContain('Usage: /agent');
|
||||
});
|
||||
|
||||
// /agent <id> — switch
|
||||
it('/agent <id> returns switch confirmation', async () => {
|
||||
const payload: SlashCommandPayload = {
|
||||
command: 'agent',
|
||||
args: 'my-agent-id',
|
||||
conversationId,
|
||||
};
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.message).toContain('my-agent-id');
|
||||
});
|
||||
|
||||
// /prdy
|
||||
it('/prdy returns PRD wizard message', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'prdy', conversationId };
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.command).toBe('prdy');
|
||||
expect(result.message).toContain('mosaic prdy');
|
||||
});
|
||||
|
||||
// /tools
|
||||
it('/tools returns tools stub message', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'tools', conversationId };
|
||||
const result = await service.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.command).toBe('tools');
|
||||
expect(result.message).toContain('tools');
|
||||
});
|
||||
});
|
||||
@@ -1,586 +0,0 @@
|
||||
import { forwardRef, Inject, Injectable, Logger, Optional } from '@nestjs/common';
|
||||
import type { QueueHandle } from '@mosaic/queue';
|
||||
import type { Brain } from '@mosaic/brain';
|
||||
import type { SlashCommandPayload, SlashCommandResultPayload } from '@mosaic/types';
|
||||
import { AgentService } from '../agent/agent.service.js';
|
||||
import { ChatGateway } from '../chat/chat.gateway.js';
|
||||
import { SessionGCService } from '../gc/session-gc.service.js';
|
||||
import { SystemOverrideService } from '../preferences/system-override.service.js';
|
||||
import { ReloadService } from '../reload/reload.service.js';
|
||||
import { McpClientService } from '../mcp-client/mcp-client.service.js';
|
||||
import { BRAIN } from '../brain/brain.tokens.js';
|
||||
import { COMMANDS_REDIS } from './commands.tokens.js';
|
||||
import { CommandRegistryService } from './command-registry.service.js';
|
||||
|
||||
@Injectable()
|
||||
export class CommandExecutorService {
|
||||
private readonly logger = new Logger(CommandExecutorService.name);
|
||||
|
||||
constructor(
|
||||
@Inject(CommandRegistryService) private readonly registry: CommandRegistryService,
|
||||
@Inject(AgentService) private readonly agentService: AgentService,
|
||||
@Inject(SystemOverrideService) private readonly systemOverride: SystemOverrideService,
|
||||
@Inject(SessionGCService) private readonly sessionGC: SessionGCService,
|
||||
@Inject(COMMANDS_REDIS) private readonly redis: QueueHandle['redis'],
|
||||
@Inject(BRAIN) private readonly brain: Brain,
|
||||
@Optional()
|
||||
@Inject(forwardRef(() => ReloadService))
|
||||
private readonly reloadService: ReloadService | null,
|
||||
@Optional()
|
||||
@Inject(forwardRef(() => ChatGateway))
|
||||
private readonly chatGateway: ChatGateway | null,
|
||||
@Optional()
|
||||
@Inject(McpClientService)
|
||||
private readonly mcpClient: McpClientService | null,
|
||||
) {}
|
||||
|
||||
async execute(payload: SlashCommandPayload, userId: string): Promise<SlashCommandResultPayload> {
|
||||
const { command, args, conversationId } = payload;
|
||||
|
||||
const def = this.registry.getManifest().commands.find((c) => c.name === command);
|
||||
if (!def) {
|
||||
return {
|
||||
command,
|
||||
conversationId,
|
||||
success: false,
|
||||
message: `Unknown command: /${command}`,
|
||||
};
|
||||
}
|
||||
|
||||
try {
|
||||
switch (command) {
|
||||
case 'model':
|
||||
return await this.handleModel(args ?? null, conversationId);
|
||||
case 'thinking':
|
||||
return await this.handleThinking(args ?? null, conversationId);
|
||||
case 'system':
|
||||
return await this.handleSystem(args ?? null, conversationId);
|
||||
case 'new':
|
||||
return {
|
||||
command,
|
||||
conversationId,
|
||||
success: true,
|
||||
message: 'Start a new conversation by selecting New Conversation.',
|
||||
};
|
||||
case 'clear':
|
||||
return {
|
||||
command,
|
||||
conversationId,
|
||||
success: true,
|
||||
message: 'Conversation display cleared.',
|
||||
};
|
||||
case 'compact':
|
||||
return {
|
||||
command,
|
||||
conversationId,
|
||||
success: true,
|
||||
message: 'Context compaction requested.',
|
||||
};
|
||||
case 'retry':
|
||||
return {
|
||||
command,
|
||||
conversationId,
|
||||
success: true,
|
||||
message: 'Retry last message requested.',
|
||||
};
|
||||
case 'gc': {
|
||||
// Admin-only: system-wide GC sweep across all sessions
|
||||
const result = await this.sessionGC.sweepOrphans();
|
||||
return {
|
||||
command: 'gc',
|
||||
success: true,
|
||||
message: `GC sweep complete: ${result.orphanedSessions} orphaned sessions cleaned in ${result.duration}ms.`,
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
case 'agent':
|
||||
return await this.handleAgent(args ?? null, conversationId, userId);
|
||||
case 'provider':
|
||||
return await this.handleProvider(args ?? null, userId, conversationId);
|
||||
case 'mission':
|
||||
return await this.handleMission(args ?? null, conversationId, userId);
|
||||
case 'prdy':
|
||||
return {
|
||||
command: 'prdy',
|
||||
success: true,
|
||||
message:
|
||||
'PRD wizard: run `mosaic prdy` in your project workspace to create or update a PRD.',
|
||||
conversationId,
|
||||
};
|
||||
case 'tools':
|
||||
return await this.handleTools(conversationId, userId);
|
||||
case 'mcp':
|
||||
return await this.handleMcp(args ?? null, conversationId);
|
||||
case 'reload': {
|
||||
if (!this.reloadService) {
|
||||
return {
|
||||
command: 'reload',
|
||||
conversationId,
|
||||
success: false,
|
||||
message: 'ReloadService is not available.',
|
||||
};
|
||||
}
|
||||
const reloadResult = await this.reloadService.reload('command');
|
||||
this.chatGateway?.broadcastReload(reloadResult);
|
||||
return {
|
||||
command: 'reload',
|
||||
success: true,
|
||||
message: reloadResult.message,
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
default:
|
||||
return {
|
||||
command,
|
||||
conversationId,
|
||||
success: false,
|
||||
message: `Command /${command} is not yet implemented.`,
|
||||
};
|
||||
}
|
||||
} catch (err) {
|
||||
this.logger.error(`Command /${command} failed: ${err}`);
|
||||
return { command, conversationId, success: false, message: String(err) };
|
||||
}
|
||||
}
|
||||
|
||||
private async handleModel(
|
||||
args: string | null,
|
||||
conversationId: string,
|
||||
): Promise<SlashCommandResultPayload> {
|
||||
if (!args || args.trim().length === 0) {
|
||||
// Show current override or usage hint
|
||||
const currentOverride = this.chatGateway?.getModelOverride(conversationId);
|
||||
if (currentOverride) {
|
||||
return {
|
||||
command: 'model',
|
||||
conversationId,
|
||||
success: true,
|
||||
message: `Current model override: "${currentOverride}". Use /model <name> to change or /model clear to reset.`,
|
||||
};
|
||||
}
|
||||
return {
|
||||
command: 'model',
|
||||
conversationId,
|
||||
success: true,
|
||||
message:
|
||||
'Usage: /model <model-name> — sets a per-session model override (bypasses routing). Use /model clear to reset.',
|
||||
};
|
||||
}
|
||||
|
||||
const modelName = args.trim();
|
||||
|
||||
// /model clear removes the override and re-enables automatic routing
|
||||
if (modelName === 'clear') {
|
||||
this.chatGateway?.setModelOverride(conversationId, null);
|
||||
return {
|
||||
command: 'model',
|
||||
conversationId,
|
||||
success: true,
|
||||
message: 'Model override cleared. Automatic routing will be used for new sessions.',
|
||||
};
|
||||
}
|
||||
|
||||
// Set the sticky per-session override (M4-007)
|
||||
this.chatGateway?.setModelOverride(conversationId, modelName);
|
||||
|
||||
const session = this.agentService.getSession(conversationId);
|
||||
if (!session) {
|
||||
return {
|
||||
command: 'model',
|
||||
conversationId,
|
||||
success: true,
|
||||
message: `Model override set to "${modelName}". Will apply when a new session starts for this conversation.`,
|
||||
};
|
||||
}
|
||||
return {
|
||||
command: 'model',
|
||||
conversationId,
|
||||
success: true,
|
||||
message: `Model override set to "${modelName}". The override is active for this conversation and will be used on the next message if a new session is needed.`,
|
||||
};
|
||||
}
|
||||
|
||||
private async handleThinking(
|
||||
args: string | null,
|
||||
conversationId: string,
|
||||
): Promise<SlashCommandResultPayload> {
|
||||
const level = args?.toLowerCase();
|
||||
if (!level || !['none', 'low', 'medium', 'high', 'auto'].includes(level)) {
|
||||
return {
|
||||
command: 'thinking',
|
||||
conversationId,
|
||||
success: true,
|
||||
message: 'Usage: /thinking <none|low|medium|high|auto>',
|
||||
};
|
||||
}
|
||||
return {
|
||||
command: 'thinking',
|
||||
conversationId,
|
||||
success: true,
|
||||
message: `Thinking level set to "${level}".`,
|
||||
};
|
||||
}
|
||||
|
||||
private async handleSystem(
|
||||
args: string | null,
|
||||
conversationId: string,
|
||||
): Promise<SlashCommandResultPayload> {
|
||||
if (!args || args.trim().length === 0) {
|
||||
// Clear the override when called with no args
|
||||
await this.systemOverride.clear(conversationId);
|
||||
return {
|
||||
command: 'system',
|
||||
conversationId,
|
||||
success: true,
|
||||
message: 'Session system prompt override cleared.',
|
||||
};
|
||||
}
|
||||
|
||||
await this.systemOverride.set(conversationId, args.trim());
|
||||
return {
|
||||
command: 'system',
|
||||
conversationId,
|
||||
success: true,
|
||||
message: `Session system prompt override set (expires in 5 minutes of inactivity).`,
|
||||
};
|
||||
}
|
||||
|
||||
private async handleAgent(
|
||||
args: string | null,
|
||||
conversationId: string,
|
||||
userId: string,
|
||||
): Promise<SlashCommandResultPayload> {
|
||||
if (!args) {
|
||||
return {
|
||||
command: 'agent',
|
||||
success: true,
|
||||
message:
|
||||
'Usage: /agent <agent-id> | /agent list | /agent new <name> to create a new agent.',
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
|
||||
if (args === 'list') {
|
||||
return {
|
||||
command: 'agent',
|
||||
success: true,
|
||||
message: 'Agent listing: use the web dashboard for full agent management.',
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
|
||||
// M5-006: /agent new <name> — create a new agent config via brain.agents.create()
|
||||
if (args.startsWith('new')) {
|
||||
const namePart = args.slice(3).trim();
|
||||
if (!namePart) {
|
||||
return {
|
||||
command: 'agent',
|
||||
success: false,
|
||||
message: 'Usage: /agent new <name> — provide a name for the new agent.',
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
|
||||
try {
|
||||
const defaultProvider = process.env['DEFAULT_PROVIDER'] ?? 'anthropic';
|
||||
const defaultModel = process.env['DEFAULT_MODEL'] ?? 'claude-sonnet-4-5-20251001';
|
||||
|
||||
const newAgent = await this.brain.agents.create({
|
||||
name: namePart,
|
||||
provider: defaultProvider,
|
||||
model: defaultModel,
|
||||
status: 'idle',
|
||||
ownerId: userId,
|
||||
isSystem: false,
|
||||
});
|
||||
|
||||
this.logger.log(`Created new agent "${newAgent.name}" (${newAgent.id}) for user ${userId}`);
|
||||
|
||||
return {
|
||||
command: 'agent',
|
||||
success: true,
|
||||
message: `Agent "${newAgent.name}" created with ID: ${newAgent.id}. Configure it via the web dashboard.`,
|
||||
conversationId,
|
||||
data: { agentId: newAgent.id, agentName: newAgent.name },
|
||||
};
|
||||
} catch (err) {
|
||||
this.logger.error(`Failed to create agent: ${err}`);
|
||||
return {
|
||||
command: 'agent',
|
||||
success: false,
|
||||
message: `Failed to create agent: ${String(err)}`,
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// M5-003: Look up agent by name (or ID) and apply to session mid-conversation
|
||||
const agentName = args.trim();
|
||||
try {
|
||||
// Try lookup by name first; fall back to ID-based lookup
|
||||
let agentConfig = await this.brain.agents.findByName(agentName);
|
||||
if (!agentConfig) {
|
||||
// Try by ID (UUID-style input)
|
||||
agentConfig = await this.brain.agents.findById(agentName);
|
||||
}
|
||||
|
||||
if (!agentConfig) {
|
||||
return {
|
||||
command: 'agent',
|
||||
success: false,
|
||||
message: `Agent "${agentName}" not found. Use /agent list to see available agents.`,
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
|
||||
// Apply the agent config to the live session and emit session:info (M5-003)
|
||||
this.agentService.applyAgentConfig(
|
||||
conversationId,
|
||||
agentConfig.id,
|
||||
agentConfig.name,
|
||||
agentConfig.model ?? undefined,
|
||||
);
|
||||
|
||||
// Broadcast updated session:info so TUI TopBar reflects new agent/model
|
||||
this.chatGateway?.broadcastSessionInfo(conversationId, { agentName: agentConfig.name });
|
||||
|
||||
this.logger.log(
|
||||
`Agent switched to "${agentConfig.name}" (${agentConfig.id}) for conversation ${conversationId} (M5-003)`,
|
||||
);
|
||||
|
||||
return {
|
||||
command: 'agent',
|
||||
success: true,
|
||||
message: `Switched to agent "${agentConfig.name}". System prompt and tools applied. Model: ${agentConfig.model ?? 'default'}.`,
|
||||
conversationId,
|
||||
data: { agentId: agentConfig.id, agentName: agentConfig.name, model: agentConfig.model },
|
||||
};
|
||||
} catch (err) {
|
||||
this.logger.error(`Failed to switch agent "${agentName}": ${err}`);
|
||||
return {
|
||||
command: 'agent',
|
||||
success: false,
|
||||
message: `Failed to switch agent: ${String(err)}`,
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
private async handleProvider(
|
||||
args: string | null,
|
||||
userId: string,
|
||||
conversationId: string,
|
||||
): Promise<SlashCommandResultPayload> {
|
||||
if (!args) {
|
||||
return {
|
||||
command: 'provider',
|
||||
success: true,
|
||||
message: 'Usage: /provider list | /provider login <name> | /provider logout <name>',
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
|
||||
const spaceIdx = args.indexOf(' ');
|
||||
const subcommand = spaceIdx >= 0 ? args.slice(0, spaceIdx) : args;
|
||||
const providerName = spaceIdx >= 0 ? args.slice(spaceIdx + 1).trim() : '';
|
||||
|
||||
switch (subcommand) {
|
||||
case 'list':
|
||||
return {
|
||||
command: 'provider',
|
||||
success: true,
|
||||
message: 'Use the web dashboard to manage providers.',
|
||||
conversationId,
|
||||
};
|
||||
|
||||
case 'login': {
|
||||
if (!providerName) {
|
||||
return {
|
||||
command: 'provider',
|
||||
success: false,
|
||||
message: 'Usage: /provider login <provider-name>',
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
const pollToken = crypto.randomUUID();
|
||||
const key = `mosaic:auth:poll:${pollToken}`;
|
||||
// Store pending state in Valkey (TTL 5 minutes)
|
||||
await this.redis.set(
|
||||
key,
|
||||
JSON.stringify({ status: 'pending', provider: providerName, userId }),
|
||||
'EX',
|
||||
300,
|
||||
);
|
||||
// In production this would construct an OAuth URL
|
||||
const loginUrl = `${process.env['MOSAIC_BASE_URL'] ?? 'http://localhost:3000'}/auth/provider/${providerName}?token=${pollToken}`;
|
||||
return {
|
||||
command: 'provider',
|
||||
success: true,
|
||||
message: `Open this URL to authenticate with ${providerName}:\n${loginUrl}`,
|
||||
conversationId,
|
||||
data: { loginUrl, pollToken, provider: providerName },
|
||||
};
|
||||
}
|
||||
|
||||
case 'logout': {
|
||||
if (!providerName) {
|
||||
return {
|
||||
command: 'provider',
|
||||
success: false,
|
||||
message: 'Usage: /provider logout <provider-name>',
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
return {
|
||||
command: 'provider',
|
||||
success: true,
|
||||
message: `Logout from ${providerName}: use the web dashboard to revoke provider tokens.`,
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
|
||||
default:
|
||||
return {
|
||||
command: 'provider',
|
||||
success: false,
|
||||
message: `Unknown subcommand: ${subcommand}. Use list, login, or logout.`,
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
private async handleMission(
|
||||
args: string | null,
|
||||
conversationId: string,
|
||||
_userId: string,
|
||||
): Promise<SlashCommandResultPayload> {
|
||||
if (!args || args === 'status') {
|
||||
// TODO: fetch active mission from DB when MissionsService is available
|
||||
return {
|
||||
command: 'mission',
|
||||
success: true,
|
||||
message: 'Mission status: use the web dashboard for full mission management.',
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
|
||||
if (args.startsWith('set ')) {
|
||||
const missionId = args.slice(4).trim();
|
||||
return {
|
||||
command: 'mission',
|
||||
success: true,
|
||||
message: `Mission set to ${missionId}. Session context updated.`,
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
command: 'mission',
|
||||
success: true,
|
||||
message: 'Usage: /mission [status|set <id>|list|tasks]',
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
|
||||
private async handleTools(
|
||||
conversationId: string,
|
||||
_userId: string,
|
||||
): Promise<SlashCommandResultPayload> {
|
||||
// TODO: fetch tool list from active agent session
|
||||
return {
|
||||
command: 'tools',
|
||||
success: true,
|
||||
message:
|
||||
'Available tools depend on the active agent configuration. Use the web dashboard to configure tool access.',
|
||||
conversationId,
|
||||
};
|
||||
}
|
||||
|
||||
private async handleMcp(
|
||||
args: string | null,
|
||||
conversationId: string,
|
||||
): Promise<SlashCommandResultPayload> {
|
||||
if (!this.mcpClient) {
|
||||
return {
|
||||
command: 'mcp',
|
||||
conversationId,
|
||||
success: false,
|
||||
message: 'MCP client service is not available.',
|
||||
};
|
||||
}
|
||||
|
||||
const action = args?.trim().split(/\s+/)[0] ?? 'status';
|
||||
|
||||
switch (action) {
|
||||
case 'status':
|
||||
case 'servers': {
|
||||
const statuses = this.mcpClient.getServerStatuses();
|
||||
if (statuses.length === 0) {
|
||||
return {
|
||||
command: 'mcp',
|
||||
conversationId,
|
||||
success: true,
|
||||
message:
|
||||
'No MCP servers configured. Set MCP_SERVERS env var to connect external tool servers.',
|
||||
};
|
||||
}
|
||||
const lines = ['MCP Server Status:\n'];
|
||||
for (const s of statuses) {
|
||||
const status = s.connected ? '✓ connected' : '✗ disconnected';
|
||||
lines.push(` ${s.name}: ${status}`);
|
||||
lines.push(` URL: ${s.url}`);
|
||||
lines.push(` Tools: ${s.toolCount}`);
|
||||
if (s.error) lines.push(` Error: ${s.error}`);
|
||||
lines.push('');
|
||||
}
|
||||
const tools = this.mcpClient.getToolDefinitions();
|
||||
if (tools.length > 0) {
|
||||
lines.push(`Total bridged tools: ${tools.length}`);
|
||||
lines.push(`Tool names: ${tools.map((t) => t.name).join(', ')}`);
|
||||
}
|
||||
return {
|
||||
command: 'mcp',
|
||||
conversationId,
|
||||
success: true,
|
||||
message: lines.join('\n'),
|
||||
};
|
||||
}
|
||||
|
||||
case 'reconnect': {
|
||||
const serverName = args?.trim().split(/\s+/).slice(1).join(' ');
|
||||
if (!serverName) {
|
||||
return {
|
||||
command: 'mcp',
|
||||
conversationId,
|
||||
success: false,
|
||||
message: 'Usage: /mcp reconnect <server-name>',
|
||||
};
|
||||
}
|
||||
try {
|
||||
await this.mcpClient.reconnectServer(serverName);
|
||||
return {
|
||||
command: 'mcp',
|
||||
conversationId,
|
||||
success: true,
|
||||
message: `MCP server "${serverName}" reconnected successfully.`,
|
||||
};
|
||||
} catch (err) {
|
||||
return {
|
||||
command: 'mcp',
|
||||
conversationId,
|
||||
success: false,
|
||||
message: `Failed to reconnect MCP server "${serverName}": ${err instanceof Error ? err.message : String(err)}`,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
default:
|
||||
return {
|
||||
command: 'mcp',
|
||||
conversationId,
|
||||
success: false,
|
||||
message: `Unknown MCP action: "${action}". Use: /mcp status, /mcp servers, /mcp reconnect <name>`,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,53 +0,0 @@
|
||||
import { describe, it, expect, beforeEach } from 'vitest';
|
||||
import { CommandRegistryService } from './command-registry.service.js';
|
||||
import type { CommandDef } from '@mosaic/types';
|
||||
|
||||
const mockCmd: CommandDef = {
|
||||
name: 'test',
|
||||
description: 'Test command',
|
||||
aliases: ['t'],
|
||||
scope: 'core',
|
||||
execution: 'local',
|
||||
available: true,
|
||||
};
|
||||
|
||||
describe('CommandRegistryService', () => {
|
||||
let service: CommandRegistryService;
|
||||
|
||||
beforeEach(() => {
|
||||
service = new CommandRegistryService();
|
||||
});
|
||||
|
||||
it('starts with empty manifest', () => {
|
||||
expect(service.getManifest().commands).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('registers a command', () => {
|
||||
service.registerCommand(mockCmd);
|
||||
expect(service.getManifest().commands).toHaveLength(1);
|
||||
});
|
||||
|
||||
it('updates existing command by name', () => {
|
||||
service.registerCommand(mockCmd);
|
||||
service.registerCommand({ ...mockCmd, description: 'Updated' });
|
||||
expect(service.getManifest().commands).toHaveLength(1);
|
||||
expect(service.getManifest().commands[0]?.description).toBe('Updated');
|
||||
});
|
||||
|
||||
it('onModuleInit registers core commands', () => {
|
||||
service.onModuleInit();
|
||||
const manifest = service.getManifest();
|
||||
expect(manifest.commands.length).toBeGreaterThan(5);
|
||||
expect(manifest.commands.some((c) => c.name === 'model')).toBe(true);
|
||||
expect(manifest.commands.some((c) => c.name === 'help')).toBe(true);
|
||||
});
|
||||
|
||||
it('manifest includes skills array', () => {
|
||||
const manifest = service.getManifest();
|
||||
expect(Array.isArray(manifest.skills)).toBe(true);
|
||||
});
|
||||
|
||||
it('manifest version is 1', () => {
|
||||
expect(service.getManifest().version).toBe(1);
|
||||
});
|
||||
});
|
||||
@@ -1,290 +0,0 @@
|
||||
import { Injectable, type OnModuleInit } from '@nestjs/common';
|
||||
import type { CommandDef, CommandManifest } from '@mosaic/types';
|
||||
|
||||
@Injectable()
|
||||
export class CommandRegistryService implements OnModuleInit {
|
||||
private readonly commands: CommandDef[] = [];
|
||||
|
||||
registerCommand(def: CommandDef): void {
|
||||
const existing = this.commands.findIndex((c) => c.name === def.name);
|
||||
if (existing >= 0) {
|
||||
this.commands[existing] = def;
|
||||
} else {
|
||||
this.commands.push(def);
|
||||
}
|
||||
}
|
||||
|
||||
registerCommands(defs: CommandDef[]): void {
|
||||
for (const def of defs) {
|
||||
this.registerCommand(def);
|
||||
}
|
||||
}
|
||||
|
||||
getManifest(): CommandManifest {
|
||||
return {
|
||||
version: 1,
|
||||
commands: [...this.commands],
|
||||
skills: [],
|
||||
};
|
||||
}
|
||||
|
||||
onModuleInit(): void {
|
||||
this.registerCommands([
|
||||
{
|
||||
name: 'model',
|
||||
description: 'Switch the active model',
|
||||
aliases: ['m'],
|
||||
args: [
|
||||
{
|
||||
name: 'model-name',
|
||||
type: 'string',
|
||||
optional: false,
|
||||
description: 'Model name to switch to',
|
||||
},
|
||||
],
|
||||
scope: 'core',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'thinking',
|
||||
description: 'Set thinking level (none/low/medium/high/auto)',
|
||||
aliases: ['t'],
|
||||
args: [
|
||||
{
|
||||
name: 'level',
|
||||
type: 'enum',
|
||||
optional: false,
|
||||
values: ['none', 'low', 'medium', 'high', 'auto'],
|
||||
description: 'Thinking level',
|
||||
},
|
||||
],
|
||||
scope: 'core',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'new',
|
||||
description: 'Start a new conversation',
|
||||
aliases: ['n'],
|
||||
scope: 'core',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'clear',
|
||||
description: 'Clear conversation context and GC session artifacts',
|
||||
aliases: [],
|
||||
scope: 'core',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'compact',
|
||||
description: 'Request context compaction',
|
||||
aliases: [],
|
||||
scope: 'core',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'retry',
|
||||
description: 'Retry the last message',
|
||||
aliases: [],
|
||||
scope: 'core',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'rename',
|
||||
description: 'Rename current conversation',
|
||||
aliases: [],
|
||||
args: [
|
||||
{ name: 'name', type: 'string', optional: false, description: 'New conversation name' },
|
||||
],
|
||||
scope: 'core',
|
||||
execution: 'rest',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'history',
|
||||
description: 'Show conversation history',
|
||||
aliases: [],
|
||||
args: [
|
||||
{
|
||||
name: 'limit',
|
||||
type: 'string',
|
||||
optional: true,
|
||||
description: 'Number of messages to show',
|
||||
},
|
||||
],
|
||||
scope: 'core',
|
||||
execution: 'rest',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'export',
|
||||
description: 'Export conversation to markdown or JSON',
|
||||
aliases: [],
|
||||
args: [
|
||||
{
|
||||
name: 'format',
|
||||
type: 'enum',
|
||||
optional: true,
|
||||
values: ['md', 'json'],
|
||||
description: 'Export format',
|
||||
},
|
||||
],
|
||||
scope: 'core',
|
||||
execution: 'rest',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'preferences',
|
||||
description: 'View or set user preferences',
|
||||
aliases: ['pref'],
|
||||
args: [
|
||||
{
|
||||
name: 'action',
|
||||
type: 'enum',
|
||||
optional: true,
|
||||
values: ['show', 'set', 'reset'],
|
||||
description: 'Action to perform',
|
||||
},
|
||||
],
|
||||
scope: 'core',
|
||||
execution: 'rest',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'system',
|
||||
description: 'Set session-scoped system prompt override',
|
||||
aliases: [],
|
||||
args: [
|
||||
{
|
||||
name: 'override',
|
||||
type: 'string',
|
||||
optional: false,
|
||||
description: 'System prompt text to inject for this session',
|
||||
},
|
||||
],
|
||||
scope: 'core',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'status',
|
||||
description: 'Show session and connection status',
|
||||
aliases: ['s'],
|
||||
scope: 'core',
|
||||
execution: 'hybrid',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'help',
|
||||
description: 'Show available commands',
|
||||
aliases: ['h'],
|
||||
scope: 'core',
|
||||
execution: 'local',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'gc',
|
||||
description: 'Trigger garbage collection sweep (admin only — system-wide)',
|
||||
aliases: [],
|
||||
scope: 'admin',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'agent',
|
||||
description: 'Switch or list available agents',
|
||||
aliases: ['a'],
|
||||
args: [
|
||||
{
|
||||
name: 'args',
|
||||
type: 'string',
|
||||
optional: true,
|
||||
description: 'list or <agent-id>',
|
||||
},
|
||||
],
|
||||
scope: 'agent',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'provider',
|
||||
description: 'Manage LLM providers (list/login/logout)',
|
||||
aliases: [],
|
||||
args: [
|
||||
{
|
||||
name: 'args',
|
||||
type: 'string',
|
||||
optional: true,
|
||||
description: 'list | login <name> | logout <name>',
|
||||
},
|
||||
],
|
||||
scope: 'agent',
|
||||
execution: 'hybrid',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'mission',
|
||||
description: 'View or set active mission',
|
||||
aliases: [],
|
||||
args: [
|
||||
{
|
||||
name: 'args',
|
||||
type: 'string',
|
||||
optional: true,
|
||||
description: 'status | set <id> | list | tasks',
|
||||
},
|
||||
],
|
||||
scope: 'agent',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'prdy',
|
||||
description: 'Launch PRD wizard',
|
||||
aliases: [],
|
||||
scope: 'agent',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'tools',
|
||||
description: 'List available agent tools',
|
||||
aliases: [],
|
||||
scope: 'agent',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'mcp',
|
||||
description: 'Manage MCP server connections (status/reconnect/servers)',
|
||||
aliases: [],
|
||||
args: [
|
||||
{
|
||||
name: 'action',
|
||||
type: 'enum',
|
||||
optional: true,
|
||||
values: ['status', 'reconnect', 'servers'],
|
||||
description: 'Action: status (default), reconnect <name>, servers',
|
||||
},
|
||||
],
|
||||
scope: 'agent',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
{
|
||||
name: 'reload',
|
||||
description: 'Soft-reload gateway plugins and command manifest (admin)',
|
||||
aliases: [],
|
||||
scope: 'admin',
|
||||
execution: 'socket',
|
||||
available: true,
|
||||
},
|
||||
]);
|
||||
}
|
||||
}
|
||||
@@ -1,263 +0,0 @@
|
||||
/**
|
||||
* Integration tests for the gateway command system (P8-019)
|
||||
*
|
||||
* Covers:
|
||||
* - CommandRegistryService.getManifest() returns 12+ core commands
|
||||
* - All core commands have correct execution types
|
||||
* - Alias resolution works for all defined aliases
|
||||
* - CommandExecutorService routes known/unknown commands correctly
|
||||
* - /gc handler calls SessionGCService.sweepOrphans
|
||||
* - /system handler calls SystemOverrideService.set
|
||||
* - Unknown command returns descriptive error
|
||||
*/
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
||||
import { CommandRegistryService } from './command-registry.service.js';
|
||||
import { CommandExecutorService } from './command-executor.service.js';
|
||||
import type { SlashCommandPayload } from '@mosaic/types';
|
||||
|
||||
// ─── Mocks ───────────────────────────────────────────────────────────────────
|
||||
|
||||
const mockAgentService = {
|
||||
getSession: vi.fn(() => undefined),
|
||||
};
|
||||
|
||||
const mockSystemOverride = {
|
||||
set: vi.fn().mockResolvedValue(undefined),
|
||||
get: vi.fn().mockResolvedValue(null),
|
||||
clear: vi.fn().mockResolvedValue(undefined),
|
||||
renew: vi.fn().mockResolvedValue(undefined),
|
||||
};
|
||||
|
||||
const mockSessionGC = {
|
||||
sweepOrphans: vi.fn().mockResolvedValue({ orphanedSessions: 3, totalCleaned: [], duration: 12 }),
|
||||
};
|
||||
|
||||
const mockRedis = {
|
||||
set: vi.fn().mockResolvedValue('OK'),
|
||||
get: vi.fn().mockResolvedValue(null),
|
||||
del: vi.fn().mockResolvedValue(0),
|
||||
keys: vi.fn().mockResolvedValue([]),
|
||||
};
|
||||
|
||||
const mockBrain = {
|
||||
agents: {
|
||||
findByName: vi.fn().mockResolvedValue(undefined),
|
||||
findById: vi.fn().mockResolvedValue(undefined),
|
||||
create: vi.fn(),
|
||||
},
|
||||
};
|
||||
|
||||
// ─── Helpers ─────────────────────────────────────────────────────────────────
|
||||
|
||||
function buildRegistry(): CommandRegistryService {
|
||||
const svc = new CommandRegistryService();
|
||||
svc.onModuleInit(); // seed core commands
|
||||
return svc;
|
||||
}
|
||||
|
||||
function buildExecutor(registry: CommandRegistryService): CommandExecutorService {
|
||||
return new CommandExecutorService(
|
||||
registry as never,
|
||||
mockAgentService as never,
|
||||
mockSystemOverride as never,
|
||||
mockSessionGC as never,
|
||||
mockRedis as never,
|
||||
mockBrain as never,
|
||||
null, // reloadService (optional)
|
||||
null, // chatGateway (optional)
|
||||
null, // mcpClient (optional)
|
||||
);
|
||||
}
|
||||
|
||||
// ─── Registry Tests ───────────────────────────────────────────────────────────
|
||||
|
||||
describe('CommandRegistryService — integration', () => {
|
||||
let registry: CommandRegistryService;
|
||||
|
||||
beforeEach(() => {
|
||||
registry = buildRegistry();
|
||||
});
|
||||
|
||||
it('getManifest() returns 12 or more core commands after onModuleInit', () => {
|
||||
const manifest = registry.getManifest();
|
||||
expect(manifest.commands.length).toBeGreaterThanOrEqual(12);
|
||||
});
|
||||
|
||||
it('manifest version is 1', () => {
|
||||
expect(registry.getManifest().version).toBe(1);
|
||||
});
|
||||
|
||||
it('manifest.skills is an array', () => {
|
||||
expect(Array.isArray(registry.getManifest().skills)).toBe(true);
|
||||
});
|
||||
|
||||
it('all commands have required fields: name, description, execution, scope, available', () => {
|
||||
for (const cmd of registry.getManifest().commands) {
|
||||
expect(typeof cmd.name).toBe('string');
|
||||
expect(typeof cmd.description).toBe('string');
|
||||
expect(['local', 'socket', 'rest', 'hybrid']).toContain(cmd.execution);
|
||||
expect(['core', 'agent', 'admin']).toContain(cmd.scope);
|
||||
expect(typeof cmd.available).toBe('boolean');
|
||||
}
|
||||
});
|
||||
|
||||
// Execution type verification for core commands
|
||||
const expectedExecutionTypes: Record<string, string> = {
|
||||
model: 'socket',
|
||||
thinking: 'socket',
|
||||
new: 'socket',
|
||||
clear: 'socket',
|
||||
compact: 'socket',
|
||||
retry: 'socket',
|
||||
rename: 'rest',
|
||||
history: 'rest',
|
||||
export: 'rest',
|
||||
preferences: 'rest',
|
||||
system: 'socket',
|
||||
help: 'local',
|
||||
gc: 'socket',
|
||||
agent: 'socket',
|
||||
provider: 'hybrid',
|
||||
mission: 'socket',
|
||||
prdy: 'socket',
|
||||
tools: 'socket',
|
||||
reload: 'socket',
|
||||
};
|
||||
|
||||
for (const [name, expectedExecution] of Object.entries(expectedExecutionTypes)) {
|
||||
it(`command "${name}" has execution type "${expectedExecution}"`, () => {
|
||||
const cmd = registry.getManifest().commands.find((c) => c.name === name);
|
||||
expect(cmd, `command "${name}" not found`).toBeDefined();
|
||||
expect(cmd!.execution).toBe(expectedExecution);
|
||||
});
|
||||
}
|
||||
|
||||
// Alias resolution checks
|
||||
const expectedAliases: Array<[string, string]> = [
|
||||
['m', 'model'],
|
||||
['t', 'thinking'],
|
||||
['n', 'new'],
|
||||
['a', 'agent'],
|
||||
['s', 'status'],
|
||||
['h', 'help'],
|
||||
['pref', 'preferences'],
|
||||
];
|
||||
|
||||
for (const [alias, commandName] of expectedAliases) {
|
||||
it(`alias "/${alias}" resolves to command "${commandName}" via aliases array`, () => {
|
||||
const cmd = registry
|
||||
.getManifest()
|
||||
.commands.find((c) => c.name === commandName || c.aliases?.includes(alias));
|
||||
expect(cmd, `command with alias "${alias}" not found`).toBeDefined();
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// ─── Executor Tests ───────────────────────────────────────────────────────────
|
||||
|
||||
describe('CommandExecutorService — integration', () => {
|
||||
let registry: CommandRegistryService;
|
||||
let executor: CommandExecutorService;
|
||||
const userId = 'user-integ-001';
|
||||
const conversationId = 'conv-integ-001';
|
||||
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
registry = buildRegistry();
|
||||
executor = buildExecutor(registry);
|
||||
});
|
||||
|
||||
// Unknown command returns error
|
||||
it('unknown command returns success:false with descriptive message', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'nonexistent', conversationId };
|
||||
const result = await executor.execute(payload, userId);
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.message).toContain('nonexistent');
|
||||
expect(result.command).toBe('nonexistent');
|
||||
});
|
||||
|
||||
// /gc handler calls SessionGCService.sweepOrphans (admin-only, no userId arg)
|
||||
it('/gc calls SessionGCService.sweepOrphans without arguments', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'gc', conversationId };
|
||||
const result = await executor.execute(payload, userId);
|
||||
expect(mockSessionGC.sweepOrphans).toHaveBeenCalledWith();
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.message).toContain('GC sweep complete');
|
||||
expect(result.message).toContain('3 orphaned sessions');
|
||||
});
|
||||
|
||||
// /system with args calls SystemOverrideService.set
|
||||
it('/system with text calls SystemOverrideService.set', async () => {
|
||||
const override = 'You are a helpful assistant.';
|
||||
const payload: SlashCommandPayload = { command: 'system', args: override, conversationId };
|
||||
const result = await executor.execute(payload, userId);
|
||||
expect(mockSystemOverride.set).toHaveBeenCalledWith(conversationId, override);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.message).toContain('override set');
|
||||
});
|
||||
|
||||
// /system with no args clears the override
|
||||
it('/system with no args calls SystemOverrideService.clear', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'system', conversationId };
|
||||
const result = await executor.execute(payload, userId);
|
||||
expect(mockSystemOverride.clear).toHaveBeenCalledWith(conversationId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.message).toContain('cleared');
|
||||
});
|
||||
|
||||
// /model with model name returns success
|
||||
it('/model with a model name returns success', async () => {
|
||||
const payload: SlashCommandPayload = {
|
||||
command: 'model',
|
||||
args: 'claude-3-opus',
|
||||
conversationId,
|
||||
};
|
||||
const result = await executor.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.command).toBe('model');
|
||||
expect(result.message).toContain('claude-3-opus');
|
||||
});
|
||||
|
||||
// /thinking with valid level returns success
|
||||
it('/thinking with valid level returns success', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'thinking', args: 'high', conversationId };
|
||||
const result = await executor.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.message).toContain('high');
|
||||
});
|
||||
|
||||
// /thinking with invalid level returns usage message
|
||||
it('/thinking with invalid level returns usage message', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'thinking', args: 'invalid', conversationId };
|
||||
const result = await executor.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.message).toContain('Usage:');
|
||||
});
|
||||
|
||||
// /new command returns success
|
||||
it('/new returns success', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'new', conversationId };
|
||||
const result = await executor.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.command).toBe('new');
|
||||
});
|
||||
|
||||
// /reload without reloadService returns failure
|
||||
it('/reload without ReloadService returns failure', async () => {
|
||||
const payload: SlashCommandPayload = { command: 'reload', conversationId };
|
||||
const result = await executor.execute(payload, userId);
|
||||
expect(result.success).toBe(false);
|
||||
expect(result.message).toContain('ReloadService');
|
||||
});
|
||||
|
||||
// Commands not yet fully implemented return a fallback response
|
||||
const stubCommands = ['clear', 'compact', 'retry'];
|
||||
for (const cmd of stubCommands) {
|
||||
it(`/${cmd} returns success (stub)`, async () => {
|
||||
const payload: SlashCommandPayload = { command: cmd, conversationId };
|
||||
const result = await executor.execute(payload, userId);
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.command).toBe(cmd);
|
||||
});
|
||||
}
|
||||
});
|
||||
@@ -1,37 +0,0 @@
|
||||
import { forwardRef, Inject, Module, type OnApplicationShutdown } from '@nestjs/common';
|
||||
import { createQueue, type QueueHandle } from '@mosaic/queue';
|
||||
import { ChatModule } from '../chat/chat.module.js';
|
||||
import { GCModule } from '../gc/gc.module.js';
|
||||
import { ReloadModule } from '../reload/reload.module.js';
|
||||
import { CommandExecutorService } from './command-executor.service.js';
|
||||
import { CommandRegistryService } from './command-registry.service.js';
|
||||
import { COMMANDS_REDIS } from './commands.tokens.js';
|
||||
|
||||
const COMMANDS_QUEUE_HANDLE = 'COMMANDS_QUEUE_HANDLE';
|
||||
|
||||
@Module({
|
||||
imports: [GCModule, forwardRef(() => ReloadModule), forwardRef(() => ChatModule)],
|
||||
providers: [
|
||||
{
|
||||
provide: COMMANDS_QUEUE_HANDLE,
|
||||
useFactory: (): QueueHandle => {
|
||||
return createQueue();
|
||||
},
|
||||
},
|
||||
{
|
||||
provide: COMMANDS_REDIS,
|
||||
useFactory: (handle: QueueHandle) => handle.redis,
|
||||
inject: [COMMANDS_QUEUE_HANDLE],
|
||||
},
|
||||
CommandRegistryService,
|
||||
CommandExecutorService,
|
||||
],
|
||||
exports: [CommandRegistryService, CommandExecutorService],
|
||||
})
|
||||
export class CommandsModule implements OnApplicationShutdown {
|
||||
constructor(@Inject(COMMANDS_QUEUE_HANDLE) private readonly handle: QueueHandle) {}
|
||||
|
||||
async onApplicationShutdown(): Promise<void> {
|
||||
await this.handle.close().catch(() => {});
|
||||
}
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
export const COMMANDS_REDIS = 'COMMANDS_REDIS';
|
||||
@@ -1,9 +1,7 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
Body,
|
||||
Controller,
|
||||
Delete,
|
||||
ForbiddenException,
|
||||
Get,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
@@ -12,18 +10,17 @@ import {
|
||||
Param,
|
||||
Patch,
|
||||
Post,
|
||||
Query,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import type { Brain } from '@mosaic/brain';
|
||||
import { BRAIN } from '../brain/brain.tokens.js';
|
||||
import { AuthGuard } from '../auth/auth.guard.js';
|
||||
import { CurrentUser } from '../auth/current-user.decorator.js';
|
||||
import { assertOwner } from '../auth/resource-ownership.js';
|
||||
import {
|
||||
CreateConversationDto,
|
||||
UpdateConversationDto,
|
||||
SendMessageDto,
|
||||
SearchMessagesDto,
|
||||
} from './conversations.dto.js';
|
||||
|
||||
@Controller('api/conversations')
|
||||
@@ -36,21 +33,9 @@ export class ConversationsController {
|
||||
return this.brain.conversations.findAll(user.id);
|
||||
}
|
||||
|
||||
@Get('search')
|
||||
async search(@Query() dto: SearchMessagesDto, @CurrentUser() user: { id: string }) {
|
||||
if (!dto.q || dto.q.trim().length === 0) {
|
||||
throw new BadRequestException('Query parameter "q" is required and must not be empty');
|
||||
}
|
||||
const limit = dto.limit ?? 20;
|
||||
const offset = dto.offset ?? 0;
|
||||
return this.brain.conversations.searchMessages(user.id, dto.q.trim(), limit, offset);
|
||||
}
|
||||
|
||||
@Get(':id')
|
||||
async findOne(@Param('id') id: string, @CurrentUser() user: { id: string }) {
|
||||
const conversation = await this.brain.conversations.findById(id, user.id);
|
||||
if (!conversation) throw new NotFoundException('Conversation not found');
|
||||
return conversation;
|
||||
return this.getOwnedConversation(id, user.id);
|
||||
}
|
||||
|
||||
@Post()
|
||||
@@ -68,7 +53,8 @@ export class ConversationsController {
|
||||
@Body() dto: UpdateConversationDto,
|
||||
@CurrentUser() user: { id: string },
|
||||
) {
|
||||
const conversation = await this.brain.conversations.update(id, user.id, dto);
|
||||
await this.getOwnedConversation(id, user.id);
|
||||
const conversation = await this.brain.conversations.update(id, dto);
|
||||
if (!conversation) throw new NotFoundException('Conversation not found');
|
||||
return conversation;
|
||||
}
|
||||
@@ -76,16 +62,15 @@ export class ConversationsController {
|
||||
@Delete(':id')
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
async remove(@Param('id') id: string, @CurrentUser() user: { id: string }) {
|
||||
const deleted = await this.brain.conversations.remove(id, user.id);
|
||||
await this.getOwnedConversation(id, user.id);
|
||||
const deleted = await this.brain.conversations.remove(id);
|
||||
if (!deleted) throw new NotFoundException('Conversation not found');
|
||||
}
|
||||
|
||||
@Get(':id/messages')
|
||||
async listMessages(@Param('id') id: string, @CurrentUser() user: { id: string }) {
|
||||
// Verify ownership explicitly to return a clear 404 rather than an empty list.
|
||||
const conversation = await this.brain.conversations.findById(id, user.id);
|
||||
if (!conversation) throw new NotFoundException('Conversation not found');
|
||||
return this.brain.conversations.findMessages(id, user.id);
|
||||
await this.getOwnedConversation(id, user.id);
|
||||
return this.brain.conversations.findMessages(id);
|
||||
}
|
||||
|
||||
@Post(':id/messages')
|
||||
@@ -94,16 +79,19 @@ export class ConversationsController {
|
||||
@Body() dto: SendMessageDto,
|
||||
@CurrentUser() user: { id: string },
|
||||
) {
|
||||
const message = await this.brain.conversations.addMessage(
|
||||
{
|
||||
conversationId: id,
|
||||
role: dto.role,
|
||||
content: dto.content,
|
||||
metadata: dto.metadata,
|
||||
},
|
||||
user.id,
|
||||
);
|
||||
if (!message) throw new ForbiddenException('Conversation not found or access denied');
|
||||
return message;
|
||||
await this.getOwnedConversation(id, user.id);
|
||||
return this.brain.conversations.addMessage({
|
||||
conversationId: id,
|
||||
role: dto.role,
|
||||
content: dto.content,
|
||||
metadata: dto.metadata,
|
||||
});
|
||||
}
|
||||
|
||||
private async getOwnedConversation(id: string, userId: string) {
|
||||
const conversation = await this.brain.conversations.findById(id);
|
||||
if (!conversation) throw new NotFoundException('Conversation not found');
|
||||
assertOwner(conversation.userId, userId, 'Conversation');
|
||||
return conversation;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,35 +1,4 @@
|
||||
import {
|
||||
IsBoolean,
|
||||
IsIn,
|
||||
IsInt,
|
||||
IsObject,
|
||||
IsOptional,
|
||||
IsString,
|
||||
IsUUID,
|
||||
Max,
|
||||
MaxLength,
|
||||
Min,
|
||||
} from 'class-validator';
|
||||
import { Type } from 'class-transformer';
|
||||
|
||||
export class SearchMessagesDto {
|
||||
@IsString()
|
||||
@MaxLength(500)
|
||||
q!: string;
|
||||
|
||||
@IsOptional()
|
||||
@Type(() => Number)
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
@Max(100)
|
||||
limit?: number = 20;
|
||||
|
||||
@IsOptional()
|
||||
@Type(() => Number)
|
||||
@IsInt()
|
||||
@Min(0)
|
||||
offset?: number = 0;
|
||||
}
|
||||
import { IsIn, IsObject, IsOptional, IsString, IsUUID, MaxLength } from 'class-validator';
|
||||
|
||||
export class CreateConversationDto {
|
||||
@IsOptional()
|
||||
@@ -51,10 +20,6 @@ export class UpdateConversationDto {
|
||||
@IsOptional()
|
||||
@IsUUID()
|
||||
projectId?: string | null;
|
||||
|
||||
@IsOptional()
|
||||
@IsBoolean()
|
||||
archived?: boolean;
|
||||
}
|
||||
|
||||
export class SendMessageDto {
|
||||
|
||||
@@ -44,10 +44,6 @@ function resolveAndValidatePath(raw: string | undefined): string {
|
||||
return resolved;
|
||||
}
|
||||
|
||||
/**
|
||||
* File-based coord endpoints for agent tool consumption.
|
||||
* DB-backed mission CRUD has moved to MissionsController at /api/missions.
|
||||
*/
|
||||
@Controller('api/coord')
|
||||
@UseGuards(AuthGuard)
|
||||
export class CoordController {
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// ── File-based coord DTOs (legacy file-system backed) ──
|
||||
|
||||
export interface CoordMissionStatusDto {
|
||||
mission: {
|
||||
id: string;
|
||||
@@ -49,42 +47,3 @@ export interface CoordTaskDetailDto {
|
||||
startedAt: string;
|
||||
};
|
||||
}
|
||||
|
||||
// ── DB-backed coord DTOs ──
|
||||
|
||||
export interface CreateDbMissionDto {
|
||||
name: string;
|
||||
description?: string;
|
||||
projectId?: string;
|
||||
phase?: string;
|
||||
milestones?: Record<string, unknown>[];
|
||||
config?: Record<string, unknown>;
|
||||
status?: 'planning' | 'active' | 'paused' | 'completed' | 'failed';
|
||||
}
|
||||
|
||||
export interface UpdateDbMissionDto {
|
||||
name?: string;
|
||||
description?: string;
|
||||
projectId?: string;
|
||||
phase?: string;
|
||||
milestones?: Record<string, unknown>[];
|
||||
config?: Record<string, unknown>;
|
||||
status?: 'planning' | 'active' | 'paused' | 'completed' | 'failed';
|
||||
}
|
||||
|
||||
export interface CreateMissionTaskDto {
|
||||
missionId: string;
|
||||
taskId?: string;
|
||||
status?: 'not-started' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
|
||||
description?: string;
|
||||
notes?: string;
|
||||
pr?: string;
|
||||
}
|
||||
|
||||
export interface UpdateMissionTaskDto {
|
||||
taskId?: string;
|
||||
status?: 'not-started' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
|
||||
description?: string;
|
||||
notes?: string;
|
||||
pr?: string;
|
||||
}
|
||||
|
||||
@@ -12,10 +12,6 @@ import {
|
||||
import { promises as fs } from 'node:fs';
|
||||
import path from 'node:path';
|
||||
|
||||
/**
|
||||
* File-based coord operations for agent tool consumption.
|
||||
* DB-backed mission CRUD is handled directly by MissionsController via Brain repos.
|
||||
*/
|
||||
@Injectable()
|
||||
export class CoordService {
|
||||
private readonly logger = new Logger(CoordService.name);
|
||||
|
||||
@@ -1,31 +0,0 @@
|
||||
import { Module, type OnApplicationShutdown, Inject } from '@nestjs/common';
|
||||
import { createQueue, type QueueHandle } from '@mosaic/queue';
|
||||
import { SessionGCService } from './session-gc.service.js';
|
||||
import { REDIS } from './gc.tokens.js';
|
||||
|
||||
const GC_QUEUE_HANDLE = 'GC_QUEUE_HANDLE';
|
||||
|
||||
@Module({
|
||||
providers: [
|
||||
{
|
||||
provide: GC_QUEUE_HANDLE,
|
||||
useFactory: (): QueueHandle => {
|
||||
return createQueue();
|
||||
},
|
||||
},
|
||||
{
|
||||
provide: REDIS,
|
||||
useFactory: (handle: QueueHandle) => handle.redis,
|
||||
inject: [GC_QUEUE_HANDLE],
|
||||
},
|
||||
SessionGCService,
|
||||
],
|
||||
exports: [SessionGCService],
|
||||
})
|
||||
export class GCModule implements OnApplicationShutdown {
|
||||
constructor(@Inject(GC_QUEUE_HANDLE) private readonly handle: QueueHandle) {}
|
||||
|
||||
async onApplicationShutdown(): Promise<void> {
|
||||
await this.handle.close().catch(() => {});
|
||||
}
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
export const REDIS = 'REDIS';
|
||||
@@ -1,112 +0,0 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
||||
import { Logger } from '@nestjs/common';
|
||||
import type { QueueHandle } from '@mosaic/queue';
|
||||
import type { LogService } from '@mosaic/log';
|
||||
import { SessionGCService } from './session-gc.service.js';
|
||||
|
||||
type MockRedis = {
|
||||
scan: ReturnType<typeof vi.fn>;
|
||||
del: ReturnType<typeof vi.fn>;
|
||||
};
|
||||
|
||||
describe('SessionGCService', () => {
|
||||
let service: SessionGCService;
|
||||
let mockRedis: MockRedis;
|
||||
let mockLogService: { logs: { promoteToWarm: ReturnType<typeof vi.fn> } };
|
||||
|
||||
/**
|
||||
* Helper: build a scan mock that returns all provided keys in a single
|
||||
* cursor iteration (cursor '0' in → ['0', keys] out).
|
||||
*/
|
||||
function makeScanMock(keys: string[]): ReturnType<typeof vi.fn> {
|
||||
return vi.fn().mockResolvedValue(['0', keys]);
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
mockRedis = {
|
||||
scan: makeScanMock([]),
|
||||
del: vi.fn().mockResolvedValue(0),
|
||||
};
|
||||
|
||||
mockLogService = {
|
||||
logs: {
|
||||
promoteToWarm: vi.fn().mockResolvedValue(0),
|
||||
},
|
||||
};
|
||||
|
||||
// Suppress logger output in tests
|
||||
vi.spyOn(Logger.prototype, 'log').mockImplementation(() => {});
|
||||
|
||||
service = new SessionGCService(
|
||||
mockRedis as unknown as QueueHandle['redis'],
|
||||
mockLogService as unknown as LogService,
|
||||
);
|
||||
});
|
||||
|
||||
it('collect() deletes Valkey keys for session', async () => {
|
||||
mockRedis.scan = makeScanMock(['mosaic:session:abc:system', 'mosaic:session:abc:foo']);
|
||||
const result = await service.collect('abc');
|
||||
expect(mockRedis.del).toHaveBeenCalledWith(
|
||||
'mosaic:session:abc:system',
|
||||
'mosaic:session:abc:foo',
|
||||
);
|
||||
expect(result.cleaned.valkeyKeys).toBe(2);
|
||||
});
|
||||
|
||||
it('collect() with no keys returns empty cleaned valkeyKeys', async () => {
|
||||
mockRedis.scan = makeScanMock([]);
|
||||
const result = await service.collect('abc');
|
||||
expect(result.cleaned.valkeyKeys).toBeUndefined();
|
||||
});
|
||||
|
||||
it('collect() returns sessionId in result', async () => {
|
||||
const result = await service.collect('test-session-id');
|
||||
expect(result.sessionId).toBe('test-session-id');
|
||||
});
|
||||
|
||||
it('fullCollect() deletes all session keys', async () => {
|
||||
mockRedis.scan = makeScanMock(['mosaic:session:abc:system', 'mosaic:session:xyz:foo']);
|
||||
const result = await service.fullCollect();
|
||||
expect(mockRedis.del).toHaveBeenCalled();
|
||||
expect(result.valkeyKeys).toBe(2);
|
||||
});
|
||||
|
||||
it('fullCollect() with no keys returns 0 valkeyKeys', async () => {
|
||||
mockRedis.scan = makeScanMock([]);
|
||||
const result = await service.fullCollect();
|
||||
expect(result.valkeyKeys).toBe(0);
|
||||
expect(mockRedis.del).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('fullCollect() returns duration', async () => {
|
||||
const result = await service.fullCollect();
|
||||
expect(result.duration).toBeGreaterThanOrEqual(0);
|
||||
});
|
||||
|
||||
it('sweepOrphans() extracts unique session IDs and collects them', async () => {
|
||||
// First scan call returns the global session list; subsequent calls return
|
||||
// per-session keys during collect().
|
||||
mockRedis.scan = vi
|
||||
.fn()
|
||||
.mockResolvedValueOnce([
|
||||
'0',
|
||||
['mosaic:session:abc:system', 'mosaic:session:abc:messages', 'mosaic:session:xyz:system'],
|
||||
])
|
||||
// collect('abc') scan
|
||||
.mockResolvedValueOnce(['0', ['mosaic:session:abc:system', 'mosaic:session:abc:messages']])
|
||||
// collect('xyz') scan
|
||||
.mockResolvedValueOnce(['0', ['mosaic:session:xyz:system']]);
|
||||
mockRedis.del.mockResolvedValue(1);
|
||||
|
||||
const result = await service.sweepOrphans();
|
||||
expect(result.orphanedSessions).toBeGreaterThanOrEqual(0);
|
||||
expect(result.duration).toBeGreaterThanOrEqual(0);
|
||||
});
|
||||
|
||||
it('sweepOrphans() returns empty when no session keys', async () => {
|
||||
mockRedis.scan = makeScanMock([]);
|
||||
const result = await service.sweepOrphans();
|
||||
expect(result.orphanedSessions).toBe(0);
|
||||
expect(result.totalCleaned).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
@@ -1,164 +0,0 @@
|
||||
import { Inject, Injectable, Logger, type OnModuleInit } from '@nestjs/common';
|
||||
import type { QueueHandle } from '@mosaic/queue';
|
||||
import type { LogService } from '@mosaic/log';
|
||||
import { LOG_SERVICE } from '../log/log.tokens.js';
|
||||
import { REDIS } from './gc.tokens.js';
|
||||
|
||||
export interface GCResult {
|
||||
sessionId: string;
|
||||
cleaned: {
|
||||
valkeyKeys?: number;
|
||||
logsDemoted?: number;
|
||||
tempFilesRemoved?: number;
|
||||
};
|
||||
}
|
||||
|
||||
export interface GCSweepResult {
|
||||
orphanedSessions: number;
|
||||
totalCleaned: GCResult[];
|
||||
duration: number;
|
||||
}
|
||||
|
||||
export interface FullGCResult {
|
||||
valkeyKeys: number;
|
||||
logsDemoted: number;
|
||||
jobsPurged: number;
|
||||
tempFilesRemoved: number;
|
||||
duration: number;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class SessionGCService implements OnModuleInit {
|
||||
private readonly logger = new Logger(SessionGCService.name);
|
||||
|
||||
constructor(
|
||||
@Inject(REDIS) private readonly redis: QueueHandle['redis'],
|
||||
@Inject(LOG_SERVICE) private readonly logService: LogService,
|
||||
) {}
|
||||
|
||||
onModuleInit(): void {
|
||||
// Fire-and-forget: run full GC asynchronously so it does not block the
|
||||
// NestJS bootstrap chain. Cold-start GC typically takes 100–500 ms
|
||||
// depending on Valkey key count; deferring it removes that latency from
|
||||
// the TTFB of the first HTTP request.
|
||||
this.fullCollect()
|
||||
.then((result) => {
|
||||
this.logger.log(
|
||||
`Full GC complete: ${result.valkeyKeys} Valkey keys, ` +
|
||||
`${result.logsDemoted} logs demoted, ` +
|
||||
`${result.jobsPurged} jobs purged, ` +
|
||||
`${result.tempFilesRemoved} temp dirs removed ` +
|
||||
`(${result.duration}ms)`,
|
||||
);
|
||||
})
|
||||
.catch((err: unknown) => {
|
||||
this.logger.error('Cold-start GC failed', err instanceof Error ? err.stack : String(err));
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan Valkey for all keys matching a pattern using SCAN (non-blocking).
|
||||
* KEYS is avoided because it blocks the Valkey event loop for the full scan
|
||||
* duration, which can cause latency spikes under production key volumes.
|
||||
*/
|
||||
private async scanKeys(pattern: string): Promise<string[]> {
|
||||
const collected: string[] = [];
|
||||
let cursor = '0';
|
||||
do {
|
||||
const [nextCursor, keys] = await this.redis.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
|
||||
cursor = nextCursor;
|
||||
collected.push(...keys);
|
||||
} while (cursor !== '0');
|
||||
return collected;
|
||||
}
|
||||
|
||||
/**
|
||||
* Immediate cleanup for a single session (call from destroySession).
|
||||
*/
|
||||
async collect(sessionId: string): Promise<GCResult> {
|
||||
const result: GCResult = { sessionId, cleaned: {} };
|
||||
|
||||
// 1. Valkey: delete all session-scoped keys
|
||||
const pattern = `mosaic:session:${sessionId}:*`;
|
||||
const valkeyKeys = await this.scanKeys(pattern);
|
||||
if (valkeyKeys.length > 0) {
|
||||
await this.redis.del(...valkeyKeys);
|
||||
result.cleaned.valkeyKeys = valkeyKeys.length;
|
||||
}
|
||||
|
||||
// 2. PG: demote hot-tier agent_logs for this session to warm
|
||||
const cutoff = new Date(); // demote all hot logs for this session
|
||||
const logsDemoted = await this.logService.logs.promoteToWarm(cutoff);
|
||||
if (logsDemoted > 0) {
|
||||
result.cleaned.logsDemoted = logsDemoted;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sweep GC — find orphaned artifacts from dead sessions.
|
||||
* System-wide operation: only call from admin-authorized paths or internal
|
||||
* scheduled jobs. Individual session cleanup is handled by collect().
|
||||
*/
|
||||
async sweepOrphans(): Promise<GCSweepResult> {
|
||||
const start = Date.now();
|
||||
const cleaned: GCResult[] = [];
|
||||
|
||||
// 1. Find all session-scoped Valkey keys (non-blocking SCAN)
|
||||
const allSessionKeys = await this.scanKeys('mosaic:session:*');
|
||||
|
||||
// Extract unique session IDs from keys
|
||||
const sessionIds = new Set<string>();
|
||||
for (const key of allSessionKeys) {
|
||||
const match = key.match(/^mosaic:session:([^:]+):/);
|
||||
if (match) sessionIds.add(match[1]!);
|
||||
}
|
||||
|
||||
// 2. For each session ID, collect stale keys
|
||||
for (const sessionId of sessionIds) {
|
||||
const gcResult = await this.collect(sessionId);
|
||||
if (Object.keys(gcResult.cleaned).length > 0) {
|
||||
cleaned.push(gcResult);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
orphanedSessions: cleaned.length,
|
||||
totalCleaned: cleaned,
|
||||
duration: Date.now() - start,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Full GC — aggressive collection for cold start.
|
||||
* Assumes no sessions survived the restart.
|
||||
*/
|
||||
async fullCollect(): Promise<FullGCResult> {
|
||||
const start = Date.now();
|
||||
|
||||
// 1. Valkey: delete ALL session-scoped keys (non-blocking SCAN)
|
||||
const sessionKeys = await this.scanKeys('mosaic:session:*');
|
||||
if (sessionKeys.length > 0) {
|
||||
await this.redis.del(...sessionKeys);
|
||||
}
|
||||
|
||||
// 2. NOTE: channel keys are NOT collected on cold start
|
||||
// (discord/telegram plugins may reconnect and resume)
|
||||
|
||||
// 3. PG: demote stale hot-tier logs older than 24h to warm
|
||||
const hotCutoff = new Date(Date.now() - 24 * 60 * 60 * 1000);
|
||||
const logsDemoted = await this.logService.logs.promoteToWarm(hotCutoff);
|
||||
|
||||
// 4. No summarization job purge API available yet
|
||||
const jobsPurged = 0;
|
||||
|
||||
return {
|
||||
valkeyKeys: sessionKeys.length,
|
||||
logsDemoted,
|
||||
jobsPurged,
|
||||
tempFilesRemoved: 0,
|
||||
duration: Date.now() - start,
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -1,76 +1,44 @@
|
||||
import {
|
||||
Inject,
|
||||
Injectable,
|
||||
Logger,
|
||||
type OnModuleInit,
|
||||
type OnModuleDestroy,
|
||||
} from '@nestjs/common';
|
||||
import { Injectable, Logger, type OnModuleInit, type OnModuleDestroy } from '@nestjs/common';
|
||||
import cron from 'node-cron';
|
||||
import { SummarizationService } from './summarization.service.js';
|
||||
import { SessionGCService } from '../gc/session-gc.service.js';
|
||||
import {
|
||||
QueueService,
|
||||
QUEUE_SUMMARIZATION,
|
||||
QUEUE_GC,
|
||||
QUEUE_TIER_MANAGEMENT,
|
||||
} from '../queue/queue.service.js';
|
||||
import type { Worker } from 'bullmq';
|
||||
import type { MosaicJobData } from '../queue/queue.service.js';
|
||||
|
||||
@Injectable()
|
||||
export class CronService implements OnModuleInit, OnModuleDestroy {
|
||||
private readonly logger = new Logger(CronService.name);
|
||||
private readonly registeredWorkers: Worker<MosaicJobData>[] = [];
|
||||
private readonly tasks: cron.ScheduledTask[] = [];
|
||||
|
||||
constructor(
|
||||
@Inject(SummarizationService) private readonly summarization: SummarizationService,
|
||||
@Inject(SessionGCService) private readonly sessionGC: SessionGCService,
|
||||
@Inject(QueueService) private readonly queueService: QueueService,
|
||||
) {}
|
||||
constructor(private readonly summarization: SummarizationService) {}
|
||||
|
||||
async onModuleInit(): Promise<void> {
|
||||
onModuleInit(): void {
|
||||
const summarizationSchedule = process.env['SUMMARIZATION_CRON'] ?? '0 */6 * * *'; // every 6 hours
|
||||
const tierManagementSchedule = process.env['TIER_MANAGEMENT_CRON'] ?? '0 3 * * *'; // daily at 3am
|
||||
const gcSchedule = process.env['SESSION_GC_CRON'] ?? '0 4 * * *'; // daily at 4am
|
||||
|
||||
// M6-003: Summarization repeatable job
|
||||
await this.queueService.addRepeatableJob(
|
||||
QUEUE_SUMMARIZATION,
|
||||
'summarization',
|
||||
{},
|
||||
summarizationSchedule,
|
||||
this.tasks.push(
|
||||
cron.schedule(summarizationSchedule, () => {
|
||||
this.summarization.runSummarization().catch((err) => {
|
||||
this.logger.error(`Scheduled summarization failed: ${err}`);
|
||||
});
|
||||
}),
|
||||
);
|
||||
const summarizationWorker = this.queueService.registerWorker(QUEUE_SUMMARIZATION, async () => {
|
||||
await this.summarization.runSummarization();
|
||||
});
|
||||
this.registeredWorkers.push(summarizationWorker);
|
||||
|
||||
// M6-005: Tier management repeatable job
|
||||
await this.queueService.addRepeatableJob(
|
||||
QUEUE_TIER_MANAGEMENT,
|
||||
'tier-management',
|
||||
{},
|
||||
tierManagementSchedule,
|
||||
this.tasks.push(
|
||||
cron.schedule(tierManagementSchedule, () => {
|
||||
this.summarization.runTierManagement().catch((err) => {
|
||||
this.logger.error(`Scheduled tier management failed: ${err}`);
|
||||
});
|
||||
}),
|
||||
);
|
||||
const tierWorker = this.queueService.registerWorker(QUEUE_TIER_MANAGEMENT, async () => {
|
||||
await this.summarization.runTierManagement();
|
||||
});
|
||||
this.registeredWorkers.push(tierWorker);
|
||||
|
||||
// M6-004: GC repeatable job
|
||||
await this.queueService.addRepeatableJob(QUEUE_GC, 'session-gc', {}, gcSchedule);
|
||||
const gcWorker = this.queueService.registerWorker(QUEUE_GC, async () => {
|
||||
await this.sessionGC.sweepOrphans();
|
||||
});
|
||||
this.registeredWorkers.push(gcWorker);
|
||||
|
||||
this.logger.log(
|
||||
`BullMQ jobs scheduled: summarization="${summarizationSchedule}", tier="${tierManagementSchedule}", gc="${gcSchedule}"`,
|
||||
`Cron scheduled: summarization="${summarizationSchedule}", tier="${tierManagementSchedule}"`,
|
||||
);
|
||||
}
|
||||
|
||||
async onModuleDestroy(): Promise<void> {
|
||||
// Workers are closed by QueueService.onModuleDestroy — nothing extra needed here.
|
||||
this.registeredWorkers.length = 0;
|
||||
this.logger.log('CronService destroyed (workers managed by QueueService)');
|
||||
onModuleDestroy(): void {
|
||||
for (const task of this.tasks) {
|
||||
task.stop();
|
||||
}
|
||||
this.tasks.length = 0;
|
||||
this.logger.log('Cron tasks stopped');
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,12 +6,9 @@ import { LOG_SERVICE } from './log.tokens.js';
|
||||
import { LogController } from './log.controller.js';
|
||||
import { SummarizationService } from './summarization.service.js';
|
||||
import { CronService } from './cron.service.js';
|
||||
import { GCModule } from '../gc/gc.module.js';
|
||||
import { QueueModule } from '../queue/queue.module.js';
|
||||
|
||||
@Global()
|
||||
@Module({
|
||||
imports: [GCModule, QueueModule],
|
||||
providers: [
|
||||
{
|
||||
provide: LOG_SERVICE,
|
||||
|
||||
@@ -29,7 +29,7 @@ export class SummarizationService {
|
||||
constructor(
|
||||
@Inject(LOG_SERVICE) private readonly logService: LogService,
|
||||
@Inject(MEMORY) private readonly memory: Memory,
|
||||
@Inject(EmbeddingService) private readonly embeddings: EmbeddingService,
|
||||
private readonly embeddings: EmbeddingService,
|
||||
@Inject(DB) private readonly db: Db,
|
||||
) {
|
||||
this.apiKey = process.env['OPENAI_API_KEY'];
|
||||
@@ -137,7 +137,7 @@ export class SummarizationService {
|
||||
|
||||
const promoted = await this.logService.logs.promoteToCold(warmCutoff);
|
||||
const purged = await this.logService.logs.purge(coldCutoff);
|
||||
const decayed = await this.memory.insights.decayAllInsights(decayCutoff);
|
||||
const decayed = await this.memory.insights.decayOldInsights(decayCutoff);
|
||||
|
||||
this.logger.log(
|
||||
`Tier management: ${promoted} logs→cold, ${purged} purged, ${decayed} insights decayed`,
|
||||
|
||||
@@ -1,44 +1,23 @@
|
||||
import { config } from 'dotenv';
|
||||
import { resolve } from 'node:path';
|
||||
|
||||
// Load .env from monorepo root (cwd is apps/gateway when run via pnpm filter)
|
||||
config({ path: resolve(process.cwd(), '../../.env') });
|
||||
config(); // Also load apps/gateway/.env if present (overrides)
|
||||
|
||||
import './tracing.js';
|
||||
import 'reflect-metadata';
|
||||
import { NestFactory } from '@nestjs/core';
|
||||
import { Logger, ValidationPipe } from '@nestjs/common';
|
||||
import { FastifyAdapter, type NestFastifyApplication } from '@nestjs/platform-fastify';
|
||||
import helmet from '@fastify/helmet';
|
||||
import { listSsoStartupWarnings } from '@mosaic/auth';
|
||||
import { AppModule } from './app.module.js';
|
||||
import { mountAuthHandler } from './auth/auth.controller.js';
|
||||
import { mountMcpHandler } from './mcp/mcp.controller.js';
|
||||
import { McpService } from './mcp/mcp.service.js';
|
||||
|
||||
async function bootstrap(): Promise<void> {
|
||||
const logger = new Logger('Bootstrap');
|
||||
|
||||
if (!process.env['BETTER_AUTH_SECRET']) {
|
||||
throw new Error('BETTER_AUTH_SECRET is required');
|
||||
}
|
||||
|
||||
for (const warning of listSsoStartupWarnings()) {
|
||||
logger.warn(warning);
|
||||
}
|
||||
|
||||
const logger = new Logger('Bootstrap');
|
||||
const app = await NestFactory.create<NestFastifyApplication>(
|
||||
AppModule,
|
||||
new FastifyAdapter({ bodyLimit: 1_048_576 }),
|
||||
);
|
||||
|
||||
app.enableCors({
|
||||
origin: process.env['GATEWAY_CORS_ORIGIN'] ?? 'http://localhost:3000',
|
||||
credentials: true,
|
||||
methods: ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
|
||||
});
|
||||
|
||||
await app.register(helmet as never, { contentSecurityPolicy: false });
|
||||
app.useGlobalPipes(
|
||||
new ValidationPipe({
|
||||
@@ -49,7 +28,6 @@ async function bootstrap(): Promise<void> {
|
||||
);
|
||||
|
||||
mountAuthHandler(app);
|
||||
mountMcpHandler(app, app.get(McpService));
|
||||
|
||||
const port = Number(process.env['GATEWAY_PORT'] ?? 4000);
|
||||
await app.listen(port, '0.0.0.0');
|
||||
|
||||
@@ -1,33 +0,0 @@
|
||||
/**
|
||||
* DTOs for MCP client configuration and tool discovery.
|
||||
*/
|
||||
|
||||
export interface McpServerConfigDto {
|
||||
/** Unique name identifying this MCP server */
|
||||
name: string;
|
||||
/** URL of the MCP server (streamable HTTP or SSE endpoint) */
|
||||
url: string;
|
||||
/** Optional HTTP headers to send with requests (e.g., Authorization) */
|
||||
headers?: Record<string, string>;
|
||||
}
|
||||
|
||||
export interface McpToolDto {
|
||||
/** Namespaced tool name: "<serverName>__<toolName>" */
|
||||
name: string;
|
||||
/** Human-readable description of the tool */
|
||||
description: string;
|
||||
/** JSON Schema for tool input parameters */
|
||||
inputSchema: Record<string, unknown>;
|
||||
/** MCP server this tool belongs to */
|
||||
serverName: string;
|
||||
/** Original tool name on the remote server */
|
||||
remoteName: string;
|
||||
}
|
||||
|
||||
export interface McpServerStatusDto {
|
||||
name: string;
|
||||
url: string;
|
||||
connected: boolean;
|
||||
toolCount: number;
|
||||
error?: string;
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { McpClientService } from './mcp-client.service.js';
|
||||
|
||||
@Module({
|
||||
providers: [McpClientService],
|
||||
exports: [McpClientService],
|
||||
})
|
||||
export class McpClientModule {}
|
||||
@@ -1,331 +0,0 @@
|
||||
import { Injectable, Logger, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
|
||||
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
|
||||
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
|
||||
import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
|
||||
import { Type } from '@sinclair/typebox';
|
||||
import type { ToolDefinition } from '@mariozechner/pi-coding-agent';
|
||||
import type { McpServerConfigDto, McpToolDto, McpServerStatusDto } from './mcp-client.dto.js';
|
||||
|
||||
interface ConnectedServer {
|
||||
config: McpServerConfigDto;
|
||||
client: Client;
|
||||
tools: McpToolDto[];
|
||||
connected: boolean;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* McpClientService connects to external MCP servers, discovers their tools,
|
||||
* and bridges them into Pi SDK ToolDefinition format for agent sessions.
|
||||
*
|
||||
* Configuration is read from the MCP_SERVERS environment variable:
|
||||
* MCP_SERVERS='[{"name":"my-server","url":"http://localhost:3001/mcp","headers":{"Authorization":"Bearer token"}}]'
|
||||
*/
|
||||
@Injectable()
|
||||
export class McpClientService implements OnModuleInit, OnModuleDestroy {
|
||||
private readonly logger = new Logger(McpClientService.name);
|
||||
private readonly servers = new Map<string, ConnectedServer>();
|
||||
|
||||
async onModuleInit(): Promise<void> {
|
||||
const configs = this.loadConfigs();
|
||||
if (configs.length === 0) {
|
||||
this.logger.log('No external MCP servers configured (MCP_SERVERS not set)');
|
||||
return;
|
||||
}
|
||||
|
||||
this.logger.log(`Connecting to ${configs.length} external MCP server(s)`);
|
||||
await Promise.allSettled(configs.map((cfg) => this.connectServer(cfg)));
|
||||
}
|
||||
|
||||
async onModuleDestroy(): Promise<void> {
|
||||
this.logger.log(`Disconnecting from ${this.servers.size} MCP server(s)`);
|
||||
const disconnects = Array.from(this.servers.values()).map((s) => this.disconnectServer(s));
|
||||
await Promise.allSettled(disconnects);
|
||||
this.servers.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all bridged Pi SDK ToolDefinitions from all connected MCP servers.
|
||||
*/
|
||||
getToolDefinitions(): ToolDefinition[] {
|
||||
const tools: ToolDefinition[] = [];
|
||||
for (const server of this.servers.values()) {
|
||||
if (!server.connected) continue;
|
||||
for (const mcpTool of server.tools) {
|
||||
tools.push(this.bridgeTool(server.client, mcpTool));
|
||||
}
|
||||
}
|
||||
return tools;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns status information for all configured MCP servers.
|
||||
*/
|
||||
getServerStatuses(): McpServerStatusDto[] {
|
||||
return Array.from(this.servers.values()).map((s) => ({
|
||||
name: s.config.name,
|
||||
url: s.config.url,
|
||||
connected: s.connected,
|
||||
toolCount: s.tools.length,
|
||||
error: s.error,
|
||||
}));
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to reconnect a server that has been disconnected.
|
||||
*/
|
||||
async reconnectServer(serverName: string): Promise<void> {
|
||||
const existing = this.servers.get(serverName);
|
||||
if (!existing) {
|
||||
throw new Error(`MCP server not found: ${serverName}`);
|
||||
}
|
||||
if (existing.connected) return;
|
||||
|
||||
this.logger.log(`Reconnecting to MCP server: ${serverName}`);
|
||||
await this.connectServer(existing.config);
|
||||
}
|
||||
|
||||
// ─── Private helpers ──────────────────────────────────────────────────────
|
||||
|
||||
private loadConfigs(): McpServerConfigDto[] {
|
||||
const raw = process.env['MCP_SERVERS'];
|
||||
if (!raw) return [];
|
||||
|
||||
try {
|
||||
const parsed: unknown = JSON.parse(raw);
|
||||
if (!Array.isArray(parsed)) {
|
||||
this.logger.warn('MCP_SERVERS must be a JSON array — ignoring');
|
||||
return [];
|
||||
}
|
||||
|
||||
const configs: McpServerConfigDto[] = [];
|
||||
for (const item of parsed) {
|
||||
if (
|
||||
typeof item === 'object' &&
|
||||
item !== null &&
|
||||
'name' in item &&
|
||||
typeof (item as Record<string, unknown>)['name'] === 'string' &&
|
||||
'url' in item &&
|
||||
typeof (item as Record<string, unknown>)['url'] === 'string'
|
||||
) {
|
||||
const cfg = item as McpServerConfigDto;
|
||||
configs.push({
|
||||
name: cfg.name,
|
||||
url: cfg.url,
|
||||
headers: cfg.headers,
|
||||
});
|
||||
} else {
|
||||
this.logger.warn(`Skipping invalid MCP server config entry: ${JSON.stringify(item)}`);
|
||||
}
|
||||
}
|
||||
|
||||
return configs;
|
||||
} catch (err) {
|
||||
this.logger.error(
|
||||
`Failed to parse MCP_SERVERS: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
private async connectServer(config: McpServerConfigDto): Promise<void> {
|
||||
const serverEntry: ConnectedServer = {
|
||||
config,
|
||||
client: new Client({ name: 'mosaic-gateway', version: '1.0.0' }),
|
||||
tools: [],
|
||||
connected: false,
|
||||
};
|
||||
|
||||
// Preserve existing entry if reconnecting
|
||||
this.servers.set(config.name, serverEntry);
|
||||
|
||||
try {
|
||||
const url = new URL(config.url);
|
||||
const headers = config.headers ?? {};
|
||||
|
||||
// Attempt StreamableHTTP first, fall back to SSE
|
||||
let connected = false;
|
||||
|
||||
try {
|
||||
const transport = new StreamableHTTPClientTransport(url, { requestInit: { headers } });
|
||||
await serverEntry.client.connect(transport);
|
||||
connected = true;
|
||||
this.logger.log(`Connected to MCP server "${config.name}" via StreamableHTTP`);
|
||||
} catch (streamErr) {
|
||||
this.logger.warn(
|
||||
`StreamableHTTP failed for "${config.name}", trying SSE: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`,
|
||||
);
|
||||
|
||||
// Reset client for SSE attempt
|
||||
serverEntry.client = new Client({ name: 'mosaic-gateway', version: '1.0.0' });
|
||||
|
||||
try {
|
||||
const transport = new SSEClientTransport(url, { requestInit: { headers } });
|
||||
await serverEntry.client.connect(transport);
|
||||
connected = true;
|
||||
this.logger.log(`Connected to MCP server "${config.name}" via SSE`);
|
||||
} catch (sseErr) {
|
||||
throw new Error(
|
||||
`Both transports failed for "${config.name}": SSE error: ${sseErr instanceof Error ? sseErr.message : String(sseErr)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
if (!connected) return;
|
||||
|
||||
// Discover tools
|
||||
const toolsResult = await serverEntry.client.listTools();
|
||||
serverEntry.tools = toolsResult.tools.map((t) => ({
|
||||
name: `${config.name}__${t.name}`,
|
||||
description: t.description ?? `Tool ${t.name} from MCP server ${config.name}`,
|
||||
inputSchema: (t.inputSchema as Record<string, unknown>) ?? {},
|
||||
serverName: config.name,
|
||||
remoteName: t.name,
|
||||
}));
|
||||
|
||||
serverEntry.connected = true;
|
||||
this.logger.log(
|
||||
`Discovered ${serverEntry.tools.length} tool(s) from MCP server "${config.name}"`,
|
||||
);
|
||||
} catch (err) {
|
||||
const message = err instanceof Error ? err.message : String(err);
|
||||
serverEntry.error = message;
|
||||
serverEntry.connected = false;
|
||||
this.logger.error(`Failed to connect to MCP server "${config.name}": ${message}`);
|
||||
}
|
||||
}
|
||||
|
||||
private async disconnectServer(server: ConnectedServer): Promise<void> {
|
||||
try {
|
||||
await server.client.close();
|
||||
} catch (err) {
|
||||
this.logger.warn(
|
||||
`Error closing MCP client for "${server.config.name}": ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Bridges a single McpToolDto into a Pi SDK ToolDefinition.
|
||||
* The MCP inputSchema is converted to a TypeBox schema representation.
|
||||
*/
|
||||
private bridgeTool(client: Client, mcpTool: McpToolDto): ToolDefinition {
|
||||
const schema = this.inputSchemaToTypeBox(mcpTool.inputSchema);
|
||||
|
||||
return {
|
||||
name: mcpTool.name,
|
||||
label: mcpTool.remoteName,
|
||||
description: mcpTool.description,
|
||||
parameters: schema,
|
||||
execute: async (_toolCallId: string, params: unknown) => {
|
||||
try {
|
||||
const result = await client.callTool({
|
||||
name: mcpTool.remoteName,
|
||||
arguments: (params as Record<string, unknown>) ?? {},
|
||||
});
|
||||
|
||||
// MCP callTool returns { content: [...], isError?: boolean }
|
||||
const content = Array.isArray(result.content) ? result.content : [];
|
||||
const textParts = content
|
||||
.filter((c): c is { type: 'text'; text: string } => c.type === 'text')
|
||||
.map((c) => c.text)
|
||||
.join('\n');
|
||||
|
||||
if (result.isError) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `MCP tool error from "${mcpTool.serverName}/${mcpTool.remoteName}": ${textParts || 'Unknown error'}`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
content:
|
||||
content.length > 0
|
||||
? (content as { type: 'text'; text: string }[])
|
||||
: [{ type: 'text' as const, text: '' }],
|
||||
details: undefined,
|
||||
};
|
||||
} catch (err) {
|
||||
const message = err instanceof Error ? err.message : String(err);
|
||||
this.logger.error(
|
||||
`MCP tool call failed: ${mcpTool.serverName}/${mcpTool.remoteName}: ${message}`,
|
||||
);
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: `Failed to call MCP tool "${mcpTool.name}": ${message}`,
|
||||
},
|
||||
],
|
||||
details: undefined,
|
||||
};
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a JSON Schema object to a TypeBox-compatible schema.
|
||||
* For simplicity, maps the inputSchema properties to TypeBox Type.Object.
|
||||
* Unknown/complex schemas fall back to Type.Object with Type.Unknown values.
|
||||
*/
|
||||
private inputSchemaToTypeBox(
|
||||
inputSchema: Record<string, unknown>,
|
||||
): ReturnType<typeof Type.Object> {
|
||||
const properties = inputSchema['properties'];
|
||||
|
||||
if (!properties || typeof properties !== 'object') {
|
||||
return Type.Object({});
|
||||
}
|
||||
|
||||
const required: string[] = Array.isArray(inputSchema['required'])
|
||||
? (inputSchema['required'] as string[])
|
||||
: [];
|
||||
|
||||
const tbProps: Record<string, ReturnType<typeof Type.String>> = {};
|
||||
|
||||
for (const [key, schemaDef] of Object.entries(properties as Record<string, unknown>)) {
|
||||
const def = schemaDef as Record<string, unknown>;
|
||||
const desc = typeof def['description'] === 'string' ? def['description'] : undefined;
|
||||
const isOptional = !required.includes(key);
|
||||
const base = this.jsonSchemaToTypeBox(def);
|
||||
tbProps[key] = isOptional
|
||||
? (Type.Optional(base) as unknown as ReturnType<typeof Type.String>)
|
||||
: (base as unknown as ReturnType<typeof Type.String>);
|
||||
if (desc && tbProps[key]) {
|
||||
// Attach description via metadata
|
||||
(tbProps[key] as Record<string, unknown>)['description'] = desc;
|
||||
}
|
||||
}
|
||||
|
||||
return Type.Object(tbProps as Parameters<typeof Type.Object>[0]);
|
||||
}
|
||||
|
||||
private jsonSchemaToTypeBox(
|
||||
def: Record<string, unknown>,
|
||||
):
|
||||
| ReturnType<typeof Type.String>
|
||||
| ReturnType<typeof Type.Number>
|
||||
| ReturnType<typeof Type.Boolean>
|
||||
| ReturnType<typeof Type.Unknown> {
|
||||
const type = def['type'];
|
||||
const desc = typeof def['description'] === 'string' ? { description: def['description'] } : {};
|
||||
|
||||
switch (type) {
|
||||
case 'string':
|
||||
return Type.String(desc);
|
||||
case 'number':
|
||||
case 'integer':
|
||||
return Type.Number(desc);
|
||||
case 'boolean':
|
||||
return Type.Boolean(desc);
|
||||
default:
|
||||
return Type.Unknown(desc);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
export const MCP_CLIENT_SERVICE = 'MCP_CLIENT_SERVICE';
|
||||
@@ -1,142 +0,0 @@
|
||||
import type { IncomingMessage, ServerResponse } from 'node:http';
|
||||
import { Logger } from '@nestjs/common';
|
||||
import { fromNodeHeaders } from 'better-auth/node';
|
||||
import type { Auth } from '@mosaic/auth';
|
||||
import type { NestFastifyApplication } from '@nestjs/platform-fastify';
|
||||
import type { McpService } from './mcp.service.js';
|
||||
import { AUTH } from '../auth/auth.tokens.js';
|
||||
|
||||
/**
|
||||
* Mounts the MCP streamable HTTP transport endpoint at /mcp on the Fastify instance.
|
||||
*
|
||||
* This follows the same low-level Fastify hook pattern used by the auth controller,
|
||||
* bypassing NestJS routing to directly delegate to the MCP SDK transport handlers.
|
||||
*
|
||||
* Endpoint: POST /mcp (and GET /mcp for SSE stream reconnect)
|
||||
* Auth: Requires a valid BetterAuth session (cookie or Authorization header).
|
||||
* Session: Stateful — each initialized client gets a session ID via Mcp-Session-Id header.
|
||||
*/
|
||||
export function mountMcpHandler(app: NestFastifyApplication, mcpService: McpService): void {
|
||||
const auth = app.get<Auth>(AUTH);
|
||||
const logger = new Logger('McpController');
|
||||
const fastify = app.getHttpAdapter().getInstance();
|
||||
|
||||
fastify.addHook(
|
||||
'onRequest',
|
||||
(
|
||||
req: { raw: IncomingMessage; url: string; method: string },
|
||||
reply: { raw: ServerResponse; hijack: () => void },
|
||||
done: () => void,
|
||||
) => {
|
||||
if (!req.url.startsWith('/mcp')) {
|
||||
done();
|
||||
return;
|
||||
}
|
||||
|
||||
reply.hijack();
|
||||
|
||||
handleMcpRequest(req, reply, auth, mcpService, logger).catch((err: unknown) => {
|
||||
logger.error(
|
||||
`MCP request handler error: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
if (!reply.raw.headersSent) {
|
||||
reply.raw.writeHead(500, { 'Content-Type': 'application/json' });
|
||||
}
|
||||
if (!reply.raw.writableEnded) {
|
||||
reply.raw.end(JSON.stringify({ error: 'Internal server error' }));
|
||||
}
|
||||
});
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
async function handleMcpRequest(
|
||||
req: { raw: IncomingMessage; url: string; method: string },
|
||||
reply: { raw: ServerResponse; hijack: () => void },
|
||||
auth: Auth,
|
||||
mcpService: McpService,
|
||||
logger: Logger,
|
||||
): Promise<void> {
|
||||
// ─── Authentication ─────────────────────────────────────────────────────
|
||||
const headers = fromNodeHeaders(req.raw.headers);
|
||||
const result = await auth.api.getSession({ headers });
|
||||
|
||||
if (!result) {
|
||||
reply.raw.writeHead(401, { 'Content-Type': 'application/json' });
|
||||
reply.raw.end(JSON.stringify({ error: 'Unauthorized: valid session required' }));
|
||||
return;
|
||||
}
|
||||
|
||||
const userId = result.user.id;
|
||||
|
||||
// ─── Session routing ─────────────────────────────────────────────────────
|
||||
const sessionId = req.raw.headers['mcp-session-id'];
|
||||
|
||||
if (typeof sessionId === 'string' && sessionId.length > 0) {
|
||||
// Existing session request
|
||||
const transport = mcpService.getSession(sessionId);
|
||||
if (!transport) {
|
||||
logger.warn(`MCP session not found: ${sessionId}`);
|
||||
reply.raw.writeHead(404, { 'Content-Type': 'application/json' });
|
||||
reply.raw.end(JSON.stringify({ error: 'Session not found' }));
|
||||
return;
|
||||
}
|
||||
|
||||
await transport.handleRequest(req.raw, reply.raw);
|
||||
return;
|
||||
}
|
||||
|
||||
// ─── Initialize new session ───────────────────────────────────────────────
|
||||
// Only POST requests can initialize a new session (must be initialize message)
|
||||
if (req.method !== 'POST') {
|
||||
reply.raw.writeHead(400, { 'Content-Type': 'application/json' });
|
||||
reply.raw.end(
|
||||
JSON.stringify({
|
||||
error: 'New session must be established via POST with initialize message',
|
||||
}),
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
// Parse body to verify this is an initialize request before creating a session
|
||||
let body: unknown;
|
||||
try {
|
||||
body = await readRequestBody(req.raw);
|
||||
} catch (err) {
|
||||
logger.warn(
|
||||
`Failed to parse MCP request body: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
reply.raw.writeHead(400, { 'Content-Type': 'application/json' });
|
||||
reply.raw.end(JSON.stringify({ error: 'Invalid request body' }));
|
||||
return;
|
||||
}
|
||||
|
||||
// Create new session and handle this initializing request
|
||||
const { transport } = mcpService.createSession(userId);
|
||||
logger.log(`New MCP session created for user ${userId}`);
|
||||
|
||||
await transport.handleRequest(req.raw, reply.raw, body);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads and parses the JSON body from a Node.js IncomingMessage.
|
||||
*/
|
||||
function readRequestBody(req: IncomingMessage): Promise<unknown> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const chunks: Buffer[] = [];
|
||||
req.on('data', (chunk: Buffer) => chunks.push(chunk));
|
||||
req.on('end', () => {
|
||||
const raw = Buffer.concat(chunks).toString('utf8');
|
||||
if (!raw) {
|
||||
resolve(undefined);
|
||||
return;
|
||||
}
|
||||
try {
|
||||
resolve(JSON.parse(raw));
|
||||
} catch (err) {
|
||||
reject(err);
|
||||
}
|
||||
});
|
||||
req.on('error', reject);
|
||||
});
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
/**
|
||||
* MCP (Model Context Protocol) DTOs
|
||||
*
|
||||
* Defines the data transfer objects for the MCP streamable HTTP transport.
|
||||
* See: https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http
|
||||
*/
|
||||
|
||||
export interface McpToolDescriptor {
|
||||
name: string;
|
||||
description: string;
|
||||
inputSchema: Record<string, unknown>;
|
||||
}
|
||||
|
||||
export interface McpServerInfo {
|
||||
name: string;
|
||||
version: string;
|
||||
protocolVersion: string;
|
||||
tools: McpToolDescriptor[];
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { McpService } from './mcp.service.js';
|
||||
import { CoordModule } from '../coord/coord.module.js';
|
||||
|
||||
@Module({
|
||||
imports: [CoordModule],
|
||||
providers: [McpService],
|
||||
exports: [McpService],
|
||||
})
|
||||
export class McpModule {}
|
||||
@@ -1,429 +0,0 @@
|
||||
import { Injectable, Logger, Inject, OnModuleDestroy } from '@nestjs/common';
|
||||
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
|
||||
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import { z } from 'zod';
|
||||
import type { Brain } from '@mosaic/brain';
|
||||
import type { Memory } from '@mosaic/memory';
|
||||
import { BRAIN } from '../brain/brain.tokens.js';
|
||||
import { MEMORY } from '../memory/memory.tokens.js';
|
||||
import { EmbeddingService } from '../memory/embedding.service.js';
|
||||
import { CoordService } from '../coord/coord.service.js';
|
||||
|
||||
interface SessionEntry {
|
||||
server: McpServer;
|
||||
transport: StreamableHTTPServerTransport;
|
||||
createdAt: Date;
|
||||
userId: string;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class McpService implements OnModuleDestroy {
|
||||
private readonly logger = new Logger(McpService.name);
|
||||
private readonly sessions = new Map<string, SessionEntry>();
|
||||
|
||||
constructor(
|
||||
@Inject(BRAIN) private readonly brain: Brain,
|
||||
@Inject(MEMORY) private readonly memory: Memory,
|
||||
@Inject(EmbeddingService) private readonly embeddings: EmbeddingService,
|
||||
@Inject(CoordService) private readonly coordService: CoordService,
|
||||
) {}
|
||||
|
||||
/**
|
||||
* Creates a new MCP session with its own server + transport pair.
|
||||
* Returns the transport for use by the controller.
|
||||
*/
|
||||
createSession(userId: string): { sessionId: string; transport: StreamableHTTPServerTransport } {
|
||||
const sessionId = randomUUID();
|
||||
|
||||
const transport = new StreamableHTTPServerTransport({
|
||||
sessionIdGenerator: () => sessionId,
|
||||
onsessioninitialized: (id) => {
|
||||
this.logger.log(`MCP session initialized: ${id} for user ${userId}`);
|
||||
},
|
||||
});
|
||||
|
||||
const server = new McpServer(
|
||||
{ name: 'mosaic-gateway', version: '1.0.0' },
|
||||
{ capabilities: { tools: {} } },
|
||||
);
|
||||
|
||||
this.registerTools(server, userId);
|
||||
|
||||
transport.onclose = () => {
|
||||
this.logger.log(`MCP session closed: ${sessionId}`);
|
||||
this.sessions.delete(sessionId);
|
||||
};
|
||||
|
||||
server.connect(transport).catch((err: unknown) => {
|
||||
this.logger.error(
|
||||
`MCP server connect error for session ${sessionId}: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
});
|
||||
|
||||
this.sessions.set(sessionId, { server, transport, createdAt: new Date(), userId });
|
||||
return { sessionId, transport };
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the transport for an existing session, or null if not found.
|
||||
*/
|
||||
getSession(sessionId: string): StreamableHTTPServerTransport | null {
|
||||
return this.sessions.get(sessionId)?.transport ?? null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers all platform tools on the given McpServer instance.
|
||||
*/
|
||||
private registerTools(server: McpServer, _userId: string): void {
|
||||
// ─── Brain: Project tools ────────────────────────────────────────────
|
||||
|
||||
server.registerTool(
|
||||
'brain_list_projects',
|
||||
{
|
||||
description: 'List all projects in the brain.',
|
||||
inputSchema: z.object({}),
|
||||
},
|
||||
async () => {
|
||||
const projects = await this.brain.projects.findAll();
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: JSON.stringify(projects, null, 2) }],
|
||||
};
|
||||
},
|
||||
);
|
||||
|
||||
server.registerTool(
|
||||
'brain_get_project',
|
||||
{
|
||||
description: 'Get a project by ID.',
|
||||
inputSchema: z.object({
|
||||
id: z.string().describe('Project ID (UUID)'),
|
||||
}),
|
||||
},
|
||||
async ({ id }) => {
|
||||
const project = await this.brain.projects.findById(id);
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: project ? JSON.stringify(project, null, 2) : `Project not found: ${id}`,
|
||||
},
|
||||
],
|
||||
};
|
||||
},
|
||||
);
|
||||
|
||||
// ─── Brain: Task tools ───────────────────────────────────────────────
|
||||
|
||||
server.registerTool(
|
||||
'brain_list_tasks',
|
||||
{
|
||||
description: 'List tasks, optionally filtered by project, mission, or status.',
|
||||
inputSchema: z.object({
|
||||
projectId: z.string().optional().describe('Filter by project ID'),
|
||||
missionId: z.string().optional().describe('Filter by mission ID'),
|
||||
status: z.string().optional().describe('Filter by status'),
|
||||
}),
|
||||
},
|
||||
async ({ projectId, missionId, status }) => {
|
||||
type TaskStatus = 'not-started' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
|
||||
let tasks;
|
||||
if (projectId) tasks = await this.brain.tasks.findByProject(projectId);
|
||||
else if (missionId) tasks = await this.brain.tasks.findByMission(missionId);
|
||||
else if (status) tasks = await this.brain.tasks.findByStatus(status as TaskStatus);
|
||||
else tasks = await this.brain.tasks.findAll();
|
||||
return { content: [{ type: 'text' as const, text: JSON.stringify(tasks, null, 2) }] };
|
||||
},
|
||||
);
|
||||
|
||||
server.registerTool(
|
||||
'brain_create_task',
|
||||
{
|
||||
description: 'Create a new task in the brain.',
|
||||
inputSchema: z.object({
|
||||
title: z.string().describe('Task title'),
|
||||
description: z.string().optional().describe('Task description'),
|
||||
projectId: z.string().optional().describe('Project ID'),
|
||||
missionId: z.string().optional().describe('Mission ID'),
|
||||
priority: z.string().optional().describe('Priority: low, medium, high, critical'),
|
||||
}),
|
||||
},
|
||||
async (params) => {
|
||||
type Priority = 'low' | 'medium' | 'high' | 'critical';
|
||||
const task = await this.brain.tasks.create({
|
||||
...params,
|
||||
priority: params.priority as Priority | undefined,
|
||||
});
|
||||
return { content: [{ type: 'text' as const, text: JSON.stringify(task, null, 2) }] };
|
||||
},
|
||||
);
|
||||
|
||||
server.registerTool(
|
||||
'brain_update_task',
|
||||
{
|
||||
description: 'Update an existing task.',
|
||||
inputSchema: z.object({
|
||||
id: z.string().describe('Task ID'),
|
||||
title: z.string().optional(),
|
||||
description: z.string().optional(),
|
||||
status: z
|
||||
.string()
|
||||
.optional()
|
||||
.describe('not-started, in-progress, blocked, done, cancelled'),
|
||||
priority: z.string().optional(),
|
||||
}),
|
||||
},
|
||||
async ({ id, ...updates }) => {
|
||||
type TaskStatus = 'not-started' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
|
||||
type Priority = 'low' | 'medium' | 'high' | 'critical';
|
||||
const task = await this.brain.tasks.update(id, {
|
||||
...updates,
|
||||
status: updates.status as TaskStatus | undefined,
|
||||
priority: updates.priority as Priority | undefined,
|
||||
});
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: task ? JSON.stringify(task, null, 2) : `Task not found: ${id}`,
|
||||
},
|
||||
],
|
||||
};
|
||||
},
|
||||
);
|
||||
|
||||
// ─── Brain: Mission tools ────────────────────────────────────────────
|
||||
|
||||
server.registerTool(
|
||||
'brain_list_missions',
|
||||
{
|
||||
description: 'List all missions, optionally filtered by project.',
|
||||
inputSchema: z.object({
|
||||
projectId: z.string().optional().describe('Filter by project ID'),
|
||||
}),
|
||||
},
|
||||
async ({ projectId }) => {
|
||||
const missions = projectId
|
||||
? await this.brain.missions.findByProject(projectId)
|
||||
: await this.brain.missions.findAll();
|
||||
return { content: [{ type: 'text' as const, text: JSON.stringify(missions, null, 2) }] };
|
||||
},
|
||||
);
|
||||
|
||||
server.registerTool(
|
||||
'brain_list_conversations',
|
||||
{
|
||||
description: 'List conversations for a user.',
|
||||
inputSchema: z.object({
|
||||
userId: z.string().describe('User ID'),
|
||||
}),
|
||||
},
|
||||
async ({ userId }) => {
|
||||
const conversations = await this.brain.conversations.findAll(userId);
|
||||
return {
|
||||
content: [{ type: 'text' as const, text: JSON.stringify(conversations, null, 2) }],
|
||||
};
|
||||
},
|
||||
);
|
||||
|
||||
// ─── Memory tools ────────────────────────────────────────────────────
|
||||
|
||||
server.registerTool(
|
||||
'memory_search',
|
||||
{
|
||||
description:
|
||||
'Search across stored insights and knowledge using natural language. Returns semantically similar results.',
|
||||
inputSchema: z.object({
|
||||
userId: z.string().describe('User ID to search memory for'),
|
||||
query: z.string().describe('Natural language search query'),
|
||||
limit: z.number().optional().describe('Max results (default 5)'),
|
||||
}),
|
||||
},
|
||||
async ({ userId, query, limit }) => {
|
||||
if (!this.embeddings.available) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: 'Semantic search unavailable — no embedding provider configured',
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
const embedding = await this.embeddings.embed(query);
|
||||
const results = await this.memory.insights.searchByEmbedding(userId, embedding, limit ?? 5);
|
||||
return { content: [{ type: 'text' as const, text: JSON.stringify(results, null, 2) }] };
|
||||
},
|
||||
);
|
||||
|
||||
server.registerTool(
|
||||
'memory_get_preferences',
|
||||
{
|
||||
description: 'Retrieve stored preferences for a user.',
|
||||
inputSchema: z.object({
|
||||
userId: z.string().describe('User ID'),
|
||||
category: z
|
||||
.string()
|
||||
.optional()
|
||||
.describe('Filter by category: communication, coding, workflow, appearance, general'),
|
||||
}),
|
||||
},
|
||||
async ({ userId, category }) => {
|
||||
type Cat = 'communication' | 'coding' | 'workflow' | 'appearance' | 'general';
|
||||
const prefs = category
|
||||
? await this.memory.preferences.findByUserAndCategory(userId, category as Cat)
|
||||
: await this.memory.preferences.findByUser(userId);
|
||||
return { content: [{ type: 'text' as const, text: JSON.stringify(prefs, null, 2) }] };
|
||||
},
|
||||
);
|
||||
|
||||
server.registerTool(
|
||||
'memory_save_preference',
|
||||
{
|
||||
description:
|
||||
'Store a learned user preference (e.g., "prefers tables over paragraphs", "timezone: America/Chicago").',
|
||||
inputSchema: z.object({
|
||||
userId: z.string().describe('User ID'),
|
||||
key: z.string().describe('Preference key'),
|
||||
value: z.string().describe('Preference value (JSON string)'),
|
||||
category: z
|
||||
.string()
|
||||
.optional()
|
||||
.describe('Category: communication, coding, workflow, appearance, general'),
|
||||
}),
|
||||
},
|
||||
async ({ userId, key, value, category }) => {
|
||||
type Cat = 'communication' | 'coding' | 'workflow' | 'appearance' | 'general';
|
||||
let parsedValue: unknown;
|
||||
try {
|
||||
parsedValue = JSON.parse(value);
|
||||
} catch {
|
||||
parsedValue = value;
|
||||
}
|
||||
const pref = await this.memory.preferences.upsert({
|
||||
userId,
|
||||
key,
|
||||
value: parsedValue,
|
||||
category: (category as Cat) ?? 'general',
|
||||
source: 'agent',
|
||||
});
|
||||
return { content: [{ type: 'text' as const, text: JSON.stringify(pref, null, 2) }] };
|
||||
},
|
||||
);
|
||||
|
||||
server.registerTool(
|
||||
'memory_save_insight',
|
||||
{
|
||||
description:
|
||||
'Store a learned insight, decision, or knowledge extracted from the current interaction.',
|
||||
inputSchema: z.object({
|
||||
userId: z.string().describe('User ID'),
|
||||
content: z.string().describe('The insight or knowledge to store'),
|
||||
category: z
|
||||
.string()
|
||||
.optional()
|
||||
.describe('Category: decision, learning, preference, fact, pattern, general'),
|
||||
}),
|
||||
},
|
||||
async ({ userId, content, category }) => {
|
||||
type Cat = 'decision' | 'learning' | 'preference' | 'fact' | 'pattern' | 'general';
|
||||
const embedding = this.embeddings.available ? await this.embeddings.embed(content) : null;
|
||||
const insight = await this.memory.insights.create({
|
||||
userId,
|
||||
content,
|
||||
embedding,
|
||||
source: 'agent',
|
||||
category: (category as Cat) ?? 'learning',
|
||||
});
|
||||
return { content: [{ type: 'text' as const, text: JSON.stringify(insight, null, 2) }] };
|
||||
},
|
||||
);
|
||||
|
||||
// ─── Coord tools ─────────────────────────────────────────────────────
|
||||
|
||||
server.registerTool(
|
||||
'coord_mission_status',
|
||||
{
|
||||
description:
|
||||
'Get the current orchestration mission status including milestones, tasks, and active session.',
|
||||
inputSchema: z.object({
|
||||
projectPath: z
|
||||
.string()
|
||||
.optional()
|
||||
.describe('Project path. Defaults to gateway working directory.'),
|
||||
}),
|
||||
},
|
||||
async ({ projectPath }) => {
|
||||
const resolvedPath = projectPath ?? process.cwd();
|
||||
const status = await this.coordService.getMissionStatus(resolvedPath);
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: status ? JSON.stringify(status, null, 2) : 'No active coord mission found.',
|
||||
},
|
||||
],
|
||||
};
|
||||
},
|
||||
);
|
||||
|
||||
server.registerTool(
|
||||
'coord_list_tasks',
|
||||
{
|
||||
description: 'List all tasks from the orchestration TASKS.md file.',
|
||||
inputSchema: z.object({
|
||||
projectPath: z
|
||||
.string()
|
||||
.optional()
|
||||
.describe('Project path. Defaults to gateway working directory.'),
|
||||
}),
|
||||
},
|
||||
async ({ projectPath }) => {
|
||||
const resolvedPath = projectPath ?? process.cwd();
|
||||
const tasks = await this.coordService.listTasks(resolvedPath);
|
||||
return { content: [{ type: 'text' as const, text: JSON.stringify(tasks, null, 2) }] };
|
||||
},
|
||||
);
|
||||
|
||||
server.registerTool(
|
||||
'coord_task_detail',
|
||||
{
|
||||
description: 'Get detailed status for a specific orchestration task.',
|
||||
inputSchema: z.object({
|
||||
taskId: z.string().describe('Task ID (e.g. P2-005)'),
|
||||
projectPath: z
|
||||
.string()
|
||||
.optional()
|
||||
.describe('Project path. Defaults to gateway working directory.'),
|
||||
}),
|
||||
},
|
||||
async ({ taskId, projectPath }) => {
|
||||
const resolvedPath = projectPath ?? process.cwd();
|
||||
const detail = await this.coordService.getTaskStatus(resolvedPath, taskId);
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: 'text' as const,
|
||||
text: detail
|
||||
? JSON.stringify(detail, null, 2)
|
||||
: `Task ${taskId} not found in coord mission.`,
|
||||
},
|
||||
],
|
||||
};
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
async onModuleDestroy(): Promise<void> {
|
||||
this.logger.log(`Closing ${this.sessions.size} MCP sessions on shutdown`);
|
||||
const closePromises = Array.from(this.sessions.values()).map(({ transport }) =>
|
||||
transport.close().catch((err: unknown) => {
|
||||
this.logger.warn(
|
||||
`Error closing MCP transport: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
}),
|
||||
);
|
||||
await Promise.all(closePromises);
|
||||
this.sessions.clear();
|
||||
}
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
export const MCP_SERVICE = 'MCP_SERVICE';
|
||||
@@ -1,122 +1,36 @@
|
||||
import { Injectable, Logger } from '@nestjs/common';
|
||||
import type { EmbeddingProvider } from '@mosaic/memory';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Environment-driven configuration
|
||||
//
|
||||
// EMBEDDING_PROVIDER — 'ollama' (default) | 'openai'
|
||||
// EMBEDDING_MODEL — model id, defaults differ per provider
|
||||
// EMBEDDING_DIMENSIONS — integer, defaults differ per provider
|
||||
// OLLAMA_BASE_URL — base URL for Ollama (used when provider=ollama)
|
||||
// EMBEDDING_API_URL — full base URL for OpenAI-compatible API
|
||||
// OPENAI_API_KEY — required for OpenAI provider
|
||||
// ---------------------------------------------------------------------------
|
||||
const DEFAULT_MODEL = 'text-embedding-3-small';
|
||||
const DEFAULT_DIMENSIONS = 1536;
|
||||
|
||||
const OLLAMA_DEFAULT_MODEL = 'nomic-embed-text';
|
||||
const OLLAMA_DEFAULT_DIMENSIONS = 768;
|
||||
|
||||
const OPENAI_DEFAULT_MODEL = 'text-embedding-3-small';
|
||||
const OPENAI_DEFAULT_DIMENSIONS = 1536;
|
||||
|
||||
/** Known dimension mismatch: warn if pgvector column likely has wrong size */
|
||||
const PGVECTOR_SCHEMA_DIMENSIONS = 1536;
|
||||
|
||||
type EmbeddingBackend = 'ollama' | 'openai';
|
||||
|
||||
interface OllamaEmbeddingResponse {
|
||||
embedding: number[];
|
||||
}
|
||||
|
||||
interface OpenAIEmbeddingResponse {
|
||||
interface EmbeddingResponse {
|
||||
data: Array<{ embedding: number[]; index: number }>;
|
||||
model: string;
|
||||
usage: { prompt_tokens: number; total_tokens: number };
|
||||
}
|
||||
|
||||
/**
|
||||
* Provider-agnostic embedding service.
|
||||
*
|
||||
* Defaults to Ollama's native embedding API using nomic-embed-text (768 dims).
|
||||
* Falls back to the OpenAI-compatible API when EMBEDDING_PROVIDER=openai or
|
||||
* when OPENAI_API_KEY is set and EMBEDDING_PROVIDER is not explicitly set to ollama.
|
||||
*
|
||||
* Dimension mismatch detection: if the configured dimensions differ from the
|
||||
* pgvector schema (1536), a warning is logged with re-embedding instructions.
|
||||
* Generates embeddings via the OpenAI-compatible embeddings API.
|
||||
* Supports OpenAI, Azure OpenAI, and any provider with a compatible endpoint.
|
||||
*/
|
||||
@Injectable()
|
||||
export class EmbeddingService implements EmbeddingProvider {
|
||||
private readonly logger = new Logger(EmbeddingService.name);
|
||||
private readonly backend: EmbeddingBackend;
|
||||
private readonly apiKey: string | undefined;
|
||||
private readonly baseUrl: string;
|
||||
private readonly model: string;
|
||||
readonly dimensions: number;
|
||||
|
||||
// Ollama-specific
|
||||
private readonly ollamaBaseUrl: string | undefined;
|
||||
|
||||
// OpenAI-compatible
|
||||
private readonly openaiApiKey: string | undefined;
|
||||
private readonly openaiBaseUrl: string;
|
||||
readonly dimensions = DEFAULT_DIMENSIONS;
|
||||
|
||||
constructor() {
|
||||
// Determine backend
|
||||
const providerEnv = process.env['EMBEDDING_PROVIDER'];
|
||||
const openaiKey = process.env['OPENAI_API_KEY'];
|
||||
const ollamaUrl = process.env['OLLAMA_BASE_URL'] ?? process.env['OLLAMA_HOST'];
|
||||
|
||||
if (providerEnv === 'openai') {
|
||||
this.backend = 'openai';
|
||||
} else if (providerEnv === 'ollama') {
|
||||
this.backend = 'ollama';
|
||||
} else if (process.env['EMBEDDING_API_URL']) {
|
||||
// Legacy: explicit API URL configured → use openai-compat path
|
||||
this.backend = 'openai';
|
||||
} else if (ollamaUrl) {
|
||||
// Ollama available and no explicit override → prefer Ollama
|
||||
this.backend = 'ollama';
|
||||
} else if (openaiKey) {
|
||||
// OpenAI key present → use OpenAI
|
||||
this.backend = 'openai';
|
||||
} else {
|
||||
// Nothing configured — default to ollama (will return zeros when unavailable)
|
||||
this.backend = 'ollama';
|
||||
}
|
||||
|
||||
// Set model and dimension defaults based on backend
|
||||
if (this.backend === 'ollama') {
|
||||
this.model = process.env['EMBEDDING_MODEL'] ?? OLLAMA_DEFAULT_MODEL;
|
||||
this.dimensions =
|
||||
parseInt(process.env['EMBEDDING_DIMENSIONS'] ?? '', 10) || OLLAMA_DEFAULT_DIMENSIONS;
|
||||
this.ollamaBaseUrl = ollamaUrl;
|
||||
this.openaiApiKey = undefined;
|
||||
this.openaiBaseUrl = '';
|
||||
} else {
|
||||
this.model = process.env['EMBEDDING_MODEL'] ?? OPENAI_DEFAULT_MODEL;
|
||||
this.dimensions =
|
||||
parseInt(process.env['EMBEDDING_DIMENSIONS'] ?? '', 10) || OPENAI_DEFAULT_DIMENSIONS;
|
||||
this.ollamaBaseUrl = undefined;
|
||||
this.openaiApiKey = openaiKey;
|
||||
this.openaiBaseUrl = process.env['EMBEDDING_API_URL'] ?? 'https://api.openai.com/v1';
|
||||
}
|
||||
|
||||
// Warn on dimension mismatch with the current schema
|
||||
if (this.dimensions !== PGVECTOR_SCHEMA_DIMENSIONS) {
|
||||
this.logger.warn(
|
||||
`Embedding dimensions (${this.dimensions}) differ from pgvector schema (${PGVECTOR_SCHEMA_DIMENSIONS}). ` +
|
||||
`If insights already contain ${PGVECTOR_SCHEMA_DIMENSIONS}-dim vectors, similarity search will fail. ` +
|
||||
`To fix: truncate the insights table and re-embed, or run a migration to ALTER COLUMN embedding TYPE vector(${this.dimensions}).`,
|
||||
);
|
||||
}
|
||||
|
||||
this.logger.log(
|
||||
`EmbeddingService initialized: backend=${this.backend}, model=${this.model}, dimensions=${this.dimensions}`,
|
||||
);
|
||||
this.apiKey = process.env['OPENAI_API_KEY'];
|
||||
this.baseUrl = process.env['EMBEDDING_API_URL'] ?? 'https://api.openai.com/v1';
|
||||
this.model = process.env['EMBEDDING_MODEL'] ?? DEFAULT_MODEL;
|
||||
}
|
||||
|
||||
get available(): boolean {
|
||||
if (this.backend === 'ollama') {
|
||||
return !!this.ollamaBaseUrl;
|
||||
}
|
||||
return !!this.openaiApiKey;
|
||||
return !!this.apiKey;
|
||||
}
|
||||
|
||||
async embed(text: string): Promise<number[]> {
|
||||
@@ -125,60 +39,16 @@ export class EmbeddingService implements EmbeddingProvider {
|
||||
}
|
||||
|
||||
async embedBatch(texts: string[]): Promise<number[][]> {
|
||||
if (!this.available) {
|
||||
const reason =
|
||||
this.backend === 'ollama'
|
||||
? 'OLLAMA_BASE_URL not configured'
|
||||
: 'No OPENAI_API_KEY configured';
|
||||
this.logger.warn(`${reason} — returning zero vectors`);
|
||||
if (!this.apiKey) {
|
||||
this.logger.warn('No OPENAI_API_KEY configured — returning zero vectors');
|
||||
return texts.map(() => new Array<number>(this.dimensions).fill(0));
|
||||
}
|
||||
|
||||
if (this.backend === 'ollama') {
|
||||
return this.embedBatchOllama(texts);
|
||||
}
|
||||
return this.embedBatchOpenAI(texts);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Ollama backend
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
private async embedBatchOllama(texts: string[]): Promise<number[][]> {
|
||||
const baseUrl = this.ollamaBaseUrl!;
|
||||
const results: number[][] = [];
|
||||
|
||||
// Ollama's /api/embeddings endpoint processes one text at a time
|
||||
for (const text of texts) {
|
||||
const response = await fetch(`${baseUrl}/api/embeddings`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ model: this.model, prompt: text }),
|
||||
});
|
||||
|
||||
if (!response.ok) {
|
||||
const body = await response.text();
|
||||
this.logger.error(`Ollama embedding API error: ${response.status} ${body}`);
|
||||
throw new Error(`Ollama embedding API returned ${response.status}`);
|
||||
}
|
||||
|
||||
const json = (await response.json()) as OllamaEmbeddingResponse;
|
||||
results.push(json.embedding);
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// OpenAI-compatible backend
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
private async embedBatchOpenAI(texts: string[]): Promise<number[][]> {
|
||||
const response = await fetch(`${this.openaiBaseUrl}/embeddings`, {
|
||||
const response = await fetch(`${this.baseUrl}/embeddings`, {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Content-Type': 'application/json',
|
||||
Authorization: `Bearer ${this.openaiApiKey}`,
|
||||
Authorization: `Bearer ${this.apiKey}`,
|
||||
},
|
||||
body: JSON.stringify({
|
||||
model: this.model,
|
||||
@@ -193,7 +63,7 @@ export class EmbeddingService implements EmbeddingProvider {
|
||||
throw new Error(`Embedding API returned ${response.status}`);
|
||||
}
|
||||
|
||||
const json = (await response.json()) as OpenAIEmbeddingResponse;
|
||||
const json = (await response.json()) as EmbeddingResponse;
|
||||
return json.data.sort((a, b) => a.index - b.index).map((d) => d.embedding);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -15,7 +15,6 @@ import {
|
||||
import type { Memory } from '@mosaic/memory';
|
||||
import { MEMORY } from './memory.tokens.js';
|
||||
import { AuthGuard } from '../auth/auth.guard.js';
|
||||
import { CurrentUser } from '../auth/current-user.decorator.js';
|
||||
import { EmbeddingService } from './embedding.service.js';
|
||||
import type { UpsertPreferenceDto, CreateInsightDto, SearchMemoryDto } from './memory.dto.js';
|
||||
|
||||
@@ -24,33 +23,33 @@ import type { UpsertPreferenceDto, CreateInsightDto, SearchMemoryDto } from './m
|
||||
export class MemoryController {
|
||||
constructor(
|
||||
@Inject(MEMORY) private readonly memory: Memory,
|
||||
@Inject(EmbeddingService) private readonly embeddings: EmbeddingService,
|
||||
private readonly embeddings: EmbeddingService,
|
||||
) {}
|
||||
|
||||
// ─── Preferences ────────────────────────────────────────────────────
|
||||
|
||||
@Get('preferences')
|
||||
async listPreferences(@CurrentUser() user: { id: string }, @Query('category') category?: string) {
|
||||
async listPreferences(@Query('userId') userId: string, @Query('category') category?: string) {
|
||||
if (category) {
|
||||
return this.memory.preferences.findByUserAndCategory(
|
||||
user.id,
|
||||
userId,
|
||||
category as Parameters<typeof this.memory.preferences.findByUserAndCategory>[1],
|
||||
);
|
||||
}
|
||||
return this.memory.preferences.findByUser(user.id);
|
||||
return this.memory.preferences.findByUser(userId);
|
||||
}
|
||||
|
||||
@Get('preferences/:key')
|
||||
async getPreference(@CurrentUser() user: { id: string }, @Param('key') key: string) {
|
||||
const pref = await this.memory.preferences.findByUserAndKey(user.id, key);
|
||||
async getPreference(@Query('userId') userId: string, @Param('key') key: string) {
|
||||
const pref = await this.memory.preferences.findByUserAndKey(userId, key);
|
||||
if (!pref) throw new NotFoundException('Preference not found');
|
||||
return pref;
|
||||
}
|
||||
|
||||
@Post('preferences')
|
||||
async upsertPreference(@CurrentUser() user: { id: string }, @Body() dto: UpsertPreferenceDto) {
|
||||
async upsertPreference(@Query('userId') userId: string, @Body() dto: UpsertPreferenceDto) {
|
||||
return this.memory.preferences.upsert({
|
||||
userId: user.id,
|
||||
userId,
|
||||
key: dto.key,
|
||||
value: dto.value,
|
||||
category: dto.category,
|
||||
@@ -60,33 +59,33 @@ export class MemoryController {
|
||||
|
||||
@Delete('preferences/:key')
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
async removePreference(@CurrentUser() user: { id: string }, @Param('key') key: string) {
|
||||
const deleted = await this.memory.preferences.remove(user.id, key);
|
||||
async removePreference(@Query('userId') userId: string, @Param('key') key: string) {
|
||||
const deleted = await this.memory.preferences.remove(userId, key);
|
||||
if (!deleted) throw new NotFoundException('Preference not found');
|
||||
}
|
||||
|
||||
// ─── Insights ───────────────────────────────────────────────────────
|
||||
|
||||
@Get('insights')
|
||||
async listInsights(@CurrentUser() user: { id: string }, @Query('limit') limit?: string) {
|
||||
return this.memory.insights.findByUser(user.id, limit ? Number(limit) : undefined);
|
||||
async listInsights(@Query('userId') userId: string, @Query('limit') limit?: string) {
|
||||
return this.memory.insights.findByUser(userId, limit ? Number(limit) : undefined);
|
||||
}
|
||||
|
||||
@Get('insights/:id')
|
||||
async getInsight(@CurrentUser() user: { id: string }, @Param('id') id: string) {
|
||||
const insight = await this.memory.insights.findById(id, user.id);
|
||||
async getInsight(@Param('id') id: string) {
|
||||
const insight = await this.memory.insights.findById(id);
|
||||
if (!insight) throw new NotFoundException('Insight not found');
|
||||
return insight;
|
||||
}
|
||||
|
||||
@Post('insights')
|
||||
async createInsight(@CurrentUser() user: { id: string }, @Body() dto: CreateInsightDto) {
|
||||
async createInsight(@Query('userId') userId: string, @Body() dto: CreateInsightDto) {
|
||||
const embedding = this.embeddings.available
|
||||
? await this.embeddings.embed(dto.content)
|
||||
: undefined;
|
||||
|
||||
return this.memory.insights.create({
|
||||
userId: user.id,
|
||||
userId,
|
||||
content: dto.content,
|
||||
source: dto.source,
|
||||
category: dto.category,
|
||||
@@ -97,15 +96,15 @@ export class MemoryController {
|
||||
|
||||
@Delete('insights/:id')
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
async removeInsight(@CurrentUser() user: { id: string }, @Param('id') id: string) {
|
||||
const deleted = await this.memory.insights.remove(id, user.id);
|
||||
async removeInsight(@Param('id') id: string) {
|
||||
const deleted = await this.memory.insights.remove(id);
|
||||
if (!deleted) throw new NotFoundException('Insight not found');
|
||||
}
|
||||
|
||||
// ─── Search ─────────────────────────────────────────────────────────
|
||||
|
||||
@Post('search')
|
||||
async searchMemory(@CurrentUser() user: { id: string }, @Body() dto: SearchMemoryDto) {
|
||||
async searchMemory(@Query('userId') userId: string, @Body() dto: SearchMemoryDto) {
|
||||
if (!this.embeddings.available) {
|
||||
return {
|
||||
query: dto.query,
|
||||
@@ -116,7 +115,7 @@ export class MemoryController {
|
||||
|
||||
const queryEmbedding = await this.embeddings.embed(dto.query);
|
||||
const results = await this.memory.insights.searchByEmbedding(
|
||||
user.id,
|
||||
userId,
|
||||
queryEmbedding,
|
||||
dto.limit ?? 10,
|
||||
dto.maxDistance ?? 0.8,
|
||||
|
||||
@@ -2,6 +2,7 @@ import {
|
||||
Body,
|
||||
Controller,
|
||||
Delete,
|
||||
ForbiddenException,
|
||||
Get,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
@@ -16,42 +17,30 @@ import type { Brain } from '@mosaic/brain';
|
||||
import { BRAIN } from '../brain/brain.tokens.js';
|
||||
import { AuthGuard } from '../auth/auth.guard.js';
|
||||
import { CurrentUser } from '../auth/current-user.decorator.js';
|
||||
import {
|
||||
CreateMissionDto,
|
||||
UpdateMissionDto,
|
||||
CreateMissionTaskDto,
|
||||
UpdateMissionTaskDto,
|
||||
} from './missions.dto.js';
|
||||
import { assertOwner } from '../auth/resource-ownership.js';
|
||||
import { CreateMissionDto, UpdateMissionDto } from './missions.dto.js';
|
||||
|
||||
@Controller('api/missions')
|
||||
@UseGuards(AuthGuard)
|
||||
export class MissionsController {
|
||||
constructor(@Inject(BRAIN) private readonly brain: Brain) {}
|
||||
|
||||
// ── Missions CRUD (user-scoped) ──
|
||||
|
||||
@Get()
|
||||
async list(@CurrentUser() user: { id: string }) {
|
||||
return this.brain.missions.findAllByUser(user.id);
|
||||
async list() {
|
||||
return this.brain.missions.findAll();
|
||||
}
|
||||
|
||||
@Get(':id')
|
||||
async findOne(@Param('id') id: string, @CurrentUser() user: { id: string }) {
|
||||
const mission = await this.brain.missions.findByIdAndUser(id, user.id);
|
||||
if (!mission) throw new NotFoundException('Mission not found');
|
||||
return mission;
|
||||
return this.getOwnedMission(id, user.id);
|
||||
}
|
||||
|
||||
@Post()
|
||||
async create(@Body() dto: CreateMissionDto, @CurrentUser() user: { id: string }) {
|
||||
async create(@Body() dto: CreateMissionDto) {
|
||||
return this.brain.missions.create({
|
||||
name: dto.name,
|
||||
description: dto.description,
|
||||
projectId: dto.projectId,
|
||||
userId: user.id,
|
||||
phase: dto.phase,
|
||||
milestones: dto.milestones,
|
||||
config: dto.config,
|
||||
status: dto.status,
|
||||
});
|
||||
}
|
||||
@@ -62,8 +51,10 @@ export class MissionsController {
|
||||
@Body() dto: UpdateMissionDto,
|
||||
@CurrentUser() user: { id: string },
|
||||
) {
|
||||
const existing = await this.brain.missions.findByIdAndUser(id, user.id);
|
||||
if (!existing) throw new NotFoundException('Mission not found');
|
||||
await this.getOwnedMission(id, user.id);
|
||||
if (dto.projectId) {
|
||||
await this.getOwnedProject(dto.projectId, user.id, 'Mission');
|
||||
}
|
||||
const mission = await this.brain.missions.update(id, dto);
|
||||
if (!mission) throw new NotFoundException('Mission not found');
|
||||
return mission;
|
||||
@@ -72,81 +63,33 @@ export class MissionsController {
|
||||
@Delete(':id')
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
async remove(@Param('id') id: string, @CurrentUser() user: { id: string }) {
|
||||
const existing = await this.brain.missions.findByIdAndUser(id, user.id);
|
||||
if (!existing) throw new NotFoundException('Mission not found');
|
||||
await this.getOwnedMission(id, user.id);
|
||||
const deleted = await this.brain.missions.remove(id);
|
||||
if (!deleted) throw new NotFoundException('Mission not found');
|
||||
}
|
||||
|
||||
// ── Mission Tasks sub-routes ──
|
||||
|
||||
@Get(':missionId/tasks')
|
||||
async listTasks(@Param('missionId') missionId: string, @CurrentUser() user: { id: string }) {
|
||||
const mission = await this.brain.missions.findByIdAndUser(missionId, user.id);
|
||||
private async getOwnedMission(id: string, userId: string) {
|
||||
const mission = await this.brain.missions.findById(id);
|
||||
if (!mission) throw new NotFoundException('Mission not found');
|
||||
return this.brain.missionTasks.findByMissionAndUser(missionId, user.id);
|
||||
await this.getOwnedProject(mission.projectId, userId, 'Mission');
|
||||
return mission;
|
||||
}
|
||||
|
||||
@Get(':missionId/tasks/:taskId')
|
||||
async getTask(
|
||||
@Param('missionId') missionId: string,
|
||||
@Param('taskId') taskId: string,
|
||||
@CurrentUser() user: { id: string },
|
||||
private async getOwnedProject(
|
||||
projectId: string | null | undefined,
|
||||
userId: string,
|
||||
resourceName: string,
|
||||
) {
|
||||
const mission = await this.brain.missions.findByIdAndUser(missionId, user.id);
|
||||
if (!mission) throw new NotFoundException('Mission not found');
|
||||
const task = await this.brain.missionTasks.findByIdAndUser(taskId, user.id);
|
||||
if (!task) throw new NotFoundException('Mission task not found');
|
||||
return task;
|
||||
}
|
||||
if (!projectId) {
|
||||
throw new ForbiddenException(`${resourceName} does not belong to the current user`);
|
||||
}
|
||||
|
||||
@Post(':missionId/tasks')
|
||||
async createTask(
|
||||
@Param('missionId') missionId: string,
|
||||
@Body() dto: CreateMissionTaskDto,
|
||||
@CurrentUser() user: { id: string },
|
||||
) {
|
||||
const mission = await this.brain.missions.findByIdAndUser(missionId, user.id);
|
||||
if (!mission) throw new NotFoundException('Mission not found');
|
||||
return this.brain.missionTasks.create({
|
||||
missionId,
|
||||
taskId: dto.taskId,
|
||||
userId: user.id,
|
||||
status: dto.status,
|
||||
description: dto.description,
|
||||
notes: dto.notes,
|
||||
pr: dto.pr,
|
||||
});
|
||||
}
|
||||
const project = await this.brain.projects.findById(projectId);
|
||||
if (!project) {
|
||||
throw new ForbiddenException(`${resourceName} does not belong to the current user`);
|
||||
}
|
||||
|
||||
@Patch(':missionId/tasks/:taskId')
|
||||
async updateTask(
|
||||
@Param('missionId') missionId: string,
|
||||
@Param('taskId') taskId: string,
|
||||
@Body() dto: UpdateMissionTaskDto,
|
||||
@CurrentUser() user: { id: string },
|
||||
) {
|
||||
const mission = await this.brain.missions.findByIdAndUser(missionId, user.id);
|
||||
if (!mission) throw new NotFoundException('Mission not found');
|
||||
const existing = await this.brain.missionTasks.findByIdAndUser(taskId, user.id);
|
||||
if (!existing) throw new NotFoundException('Mission task not found');
|
||||
const updated = await this.brain.missionTasks.update(taskId, dto);
|
||||
if (!updated) throw new NotFoundException('Mission task not found');
|
||||
return updated;
|
||||
}
|
||||
|
||||
@Delete(':missionId/tasks/:taskId')
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
async removeTask(
|
||||
@Param('missionId') missionId: string,
|
||||
@Param('taskId') taskId: string,
|
||||
@CurrentUser() user: { id: string },
|
||||
) {
|
||||
const mission = await this.brain.missions.findByIdAndUser(missionId, user.id);
|
||||
if (!mission) throw new NotFoundException('Mission not found');
|
||||
const existing = await this.brain.missionTasks.findByIdAndUser(taskId, user.id);
|
||||
if (!existing) throw new NotFoundException('Mission task not found');
|
||||
const deleted = await this.brain.missionTasks.remove(taskId);
|
||||
if (!deleted) throw new NotFoundException('Mission task not found');
|
||||
assertOwner(project.ownerId, userId, resourceName);
|
||||
return project;
|
||||
}
|
||||
}
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user