@wener/mcps 1.0.1

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@wener/mcps",
+  "version": "1.0.1",
+  "description": "",
+  "author": "",
+  "bin": {
+    "mcps": "./dist/mcps-cli.mjs"
+  },
+  "main": "./dist/index.mjs",
+  "imports": {
+    "#/*": "./*"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./lib/index.js"
+    },
+    "./server": {
+      "types": "./src/server/index.ts",
+      "default": "./lib/server/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "lib",
+    "src",
+    "README.md"
+  ],
+  "keywords": [],
+  "devDependencies": {
+    "@ai-sdk/mcp": "^1.0.18",
+    "@ai-sdk/openai-compatible": "^2.0.26",
+    "@ai-sdk/react": "^3.0.71",
+    "@base-ui/react": "^1.1.0",
+    "@hono/mcp": "^0.2.3",
+    "@hono/node-server": "^1.19.9",
+    "@hono/vite-dev-server": "^0.24.1",
+    "@mikro-orm/core": "^7.0.0-rc.0",
+    "@mikro-orm/decorators": "^7.0.0-rc.0",
+    "@mikro-orm/sqlite": "^7.0.0-rc.0",
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "@orpc/client": "^1.13.4",
+    "@orpc/contract": "^1.13.4",
+    "@orpc/json-schema": "^1.13.4",
+    "@orpc/openapi": "^1.13.4",
+    "@orpc/server": "^1.13.4",
+    "@orpc/zod": "^1.13.4",
+    "@streamdown/cjk": "^1.0.1",
+    "@streamdown/code": "^1.0.1",
+    "@streamdown/math": "^1.0.1",
+    "@streamdown/mermaid": "^1.0.1",
+    "@wener/client": "^1.0.26",
+    "@wener/common": "^2.0.3",
+    "ai": "^6.0.69",
+    "commander": "^14.0.3",
+    "consola": "^3.4.2",
+    "hono": "^4.11.7",
+    "kysely": "^0.28.11",
+    "lru-cache": "^11.2.5",
+    "lucide-react": "^0.562.0",
+    "mysql2": "^3.16.3",
+    "openai": "^6.17.0",
+    "pg-query-stream": "^4.12.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "react-markdown": "^10.1.0",
+    "react-router-dom": "^7.13.0",
+    "std-env": "^3.10.0",
+    "streamdown": "^2.1.0",
+    "tarn": "^3.0.2",
+    "tedious": "^19.2.0",
+    "yaml": "^2.8.2",
+    "zod": "^4.3.6",
+    "@wener/ai": "0.1.0"
+  },
+  "scripts": {
+    "build": "bun run ./src/scripts/bundle.ts",
+    "dev": "pnpm tsx --watch src/mcps-cli.ts",
+    "dev:web": "vite",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/chat/agent.ts

@@ -0,0 +1,240 @@
+/**
+ * Tool Loop Agent Handler
+ * Uses AI SDK with MCP tools for agentic chat
+ */
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { generateText, streamText, type Tool, stepCountIs } from 'ai';
+import consola from 'consola';
+import type { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import type { ModelConfig } from '../server/schema';
+
+const log = consola.withTag('agent');
+
+export interface AgentHandlerOptions {
+	resolveModelConfig: (modelName: string) => ModelConfig | null;
+	getMcpTools?: (servers?: string[]) => Promise<Record<string, Tool>>;
+}
+
+export interface AgentRequest {
+	model: string;
+	messages: Array<{
+		role: 'user' | 'assistant' | 'system';
+		content: string;
+	}>;
+	tools?: string[]; // Tool names to enable
+	mcpServers?: string[]; // MCP server names to load tools from
+	maxSteps?: number; // Max tool loop iterations (default: 5)
+	stream?: boolean;
+}
+
+/**
+ * Normalize base URL - strip trailing /v1 if present
+ */
+function normalizeBaseUrl(url: string): string {
+	return url.replace(/\/v1\/?$/, '');
+}
+
+/**
+ * Register agent routes on Hono app
+ */
+export function registerAgentRoutes(app: Hono, options: AgentHandlerOptions) {
+	const { resolveModelConfig, getMcpTools } = options;
+
+	/**
+	 * POST /v1/agent/chat
+	 * Agent chat with tool loop support
+	 */
+	app.post('/v1/agent/chat', async (c) => {
+		try {
+			const body = await c.req.json<AgentRequest>();
+			const { model: modelName, messages, mcpServers, maxSteps = 5, stream = false } = body;
+
+			// Resolve model config
+			const modelConfig = resolveModelConfig(modelName);
+			if (!modelConfig) {
+				return c.json(
+					{
+						error: {
+							message: `Model not found: ${modelName}`,
+							type: 'invalid_request_error',
+							code: 'model_not_found',
+						},
+					},
+					404,
+				);
+			}
+
+			// Get API key
+			const apiKey = modelConfig.apiKey;
+			const baseUrl = normalizeBaseUrl(modelConfig.baseUrl || '');
+
+			if (!baseUrl) {
+				return c.json(
+					{
+						error: {
+							message: 'Model has no baseUrl configured',
+							type: 'invalid_request_error',
+							code: 'invalid_model_config',
+						},
+					},
+					400,
+				);
+			}
+
+			// Create AI provider
+			const provider = createOpenAICompatible({
+				name: 'mcps-agent',
+				baseURL: `${baseUrl}/v1`,
+				apiKey: apiKey || 'not-needed',
+			});
+
+			const aiModel = provider.chatModel(modelName);
+
+			// Get MCP tools if available
+			let tools: Record<string, Tool> = {};
+			if (getMcpTools && mcpServers && mcpServers.length > 0) {
+				try {
+					tools = await getMcpTools(mcpServers);
+					log.info(`Loaded ${Object.keys(tools).length} tools from MCP servers: ${mcpServers.join(', ')}`);
+				} catch (err) {
+					log.warn('Failed to load MCP tools:', err);
+				}
+			}
+
+			// Convert messages
+			const aiMessages = messages.map((m) => ({
+				role: m.role as 'user' | 'assistant' | 'system',
+				content: m.content,
+			}));
+
+			log.info(
+				`→ POST /v1/agent/chat model=${modelName} messages=${messages.length} tools=${Object.keys(tools).length} maxSteps=${maxSteps}`,
+			);
+
+			if (stream) {
+				// Streaming response
+				return streamSSE(c, async (sseStream) => {
+					try {
+						const result = streamText({
+							model: aiModel,
+							messages: aiMessages,
+							tools: Object.keys(tools).length > 0 ? tools : undefined,
+							stopWhen: stepCountIs(maxSteps),
+							onStepFinish: async (step) => {
+								// Send step info
+								await sseStream.writeSSE({
+									data: JSON.stringify({
+										type: 'step',
+										text: step.text,
+										toolCalls: step.toolCalls?.map((tc) => ({
+											id: tc.toolCallId,
+											name: tc.toolName,
+											arguments: 'input' in tc ? tc.input : undefined,
+										})),
+										toolResults: step.toolResults?.map((tr) => ({
+											id: tr.toolCallId,
+											name: tr.toolName,
+											result: 'output' in tr ? tr.output : undefined,
+										})),
+									}),
+								});
+							},
+						});
+
+						// Stream text deltas
+						for await (const part of result.textStream) {
+							await sseStream.writeSSE({
+								data: JSON.stringify({
+									type: 'text',
+									content: part,
+								}),
+							});
+						}
+
+						// Get final result
+						const finalResult = await result;
+						const usage = await finalResult.usage;
+						const steps = await finalResult.steps;
+
+						// Send usage info
+						await sseStream.writeSSE({
+							data: JSON.stringify({
+								type: 'usage',
+								usage: {
+									promptTokens: usage?.inputTokens,
+									completionTokens: usage?.outputTokens,
+									totalTokens: (usage?.inputTokens || 0) + (usage?.outputTokens || 0),
+								},
+							}),
+						});
+
+						// Send done
+						await sseStream.writeSSE({ data: '[DONE]' });
+
+						log.info(`← 200 /v1/agent/chat model=${modelName} steps=${steps?.length || 1}`);
+					} catch (err) {
+						log.error('Agent streaming error:', err);
+						await sseStream.writeSSE({
+							data: JSON.stringify({
+								type: 'error',
+								error: err instanceof Error ? err.message : 'Streaming error',
+							}),
+						});
+					}
+				});
+			}
+
+			// Non-streaming response
+			const result = await generateText({
+				model: aiModel,
+				messages: aiMessages,
+				tools: Object.keys(tools).length > 0 ? tools : undefined,
+				stopWhen: stepCountIs(maxSteps),
+			});
+
+			log.info(
+				`← 200 /v1/agent/chat model=${modelName} steps=${result.steps?.length || 1} tokens=${result.usage?.totalTokens || 0}`,
+			);
+
+			// Format response
+			return c.json({
+				id: `agent-${Date.now()}`,
+				object: 'agent.chat.completion',
+				model: modelName,
+				content: result.text,
+				reasoning: result.reasoning,
+				steps: result.steps?.map((step) => ({
+					text: step.text,
+					toolCalls: step.toolCalls?.map((tc) => ({
+						id: tc.toolCallId,
+						name: tc.toolName,
+						arguments: 'input' in tc ? tc.input : undefined,
+					})),
+					toolResults: step.toolResults?.map((tr) => ({
+						id: tr.toolCallId,
+						name: tr.toolName,
+						result: 'output' in tr ? tr.output : undefined,
+					})),
+				})),
+				usage: {
+					prompt_tokens: result.usage?.inputTokens,
+					completion_tokens: result.usage?.outputTokens,
+					total_tokens: (result.usage?.inputTokens || 0) + (result.usage?.outputTokens || 0),
+				},
+			});
+		} catch (error) {
+			log.error('Agent error:', error);
+			return c.json(
+				{
+					error: {
+						message: error instanceof Error ? error.message : 'Internal server error',
+						type: 'api_error',
+						code: 'internal_error',
+					},
+				},
+				500,
+			);
+		}
+	});
+}

package/src/chat/audit.ts

@@ -0,0 +1,377 @@
+/**
+ * Chat Request Audit Service
+ * Records all chat/LLM API requests for auditing and metering
+ */
+import type { Context } from 'hono';
+import consola from 'consola';
+import type { ChatProtocolType, RequestStatus as RequestStatusType, ChatAuditStats } from '../entities/types';
+
+const log = consola.withTag('chat-audit');
+
+/**
+ * Re-export protocol and status constants for convenience
+ */
+export const ChatProtocol = {
+	OPENAI: 'openai' as ChatProtocolType,
+	ANTHROPIC: 'anthropic' as ChatProtocolType,
+	GEMINI: 'gemini' as ChatProtocolType,
+};
+
+export const RequestStatus = {
+	PENDING: 'pending' as RequestStatusType,
+	SUCCESS: 'success' as RequestStatusType,
+	ERROR: 'error' as RequestStatusType,
+	TIMEOUT: 'timeout' as RequestStatusType,
+};
+
+/**
+ * Chat audit record (in-memory representation)
+ */
+export interface ChatAuditRecord {
+	requestId: string;
+	requestedAt: Date;
+	completedAt?: Date;
+	status: RequestStatusType;
+	method: string;
+	endpoint: string;
+	inputProtocol: ChatProtocolType;
+	outputProtocol: ChatProtocolType;
+	model: string;
+	resolvedModel?: string;
+	provider?: string;
+	upstreamUrl?: string;
+	streaming: boolean;
+	inputTokens?: number;
+	outputTokens?: number;
+	totalTokens?: number;
+	durationMs?: number;
+	ttftMs?: number;
+	httpStatus?: number;
+	errorMessage?: string;
+	errorCode?: string;
+	clientIp?: string;
+	userAgent?: string;
+	userId?: string;
+	orgId?: string;
+	apiKeyId?: string;
+	requestMeta?: Record<string, unknown>;
+	responseMeta?: Record<string, unknown>;
+	cost?: string;
+	currency?: string;
+}
+
+/**
+ * Audit store interface
+ */
+export interface ChatAuditStore {
+	/**
+	 * Save a chat audit record
+	 */
+	save(record: ChatAuditRecord): Promise<void>;
+
+	/**
+	 * Query audit records
+	 */
+	query(options: ChatAuditQueryOptions): Promise<{ records: ChatAuditRecord[]; total: number }>;
+
+	/**
+	 * Get aggregate statistics
+	 */
+	getStats(options: { from?: Date; to?: Date }): Promise<import('../entities/types').ChatAuditStats>;
+}
+
+export interface ChatAuditQueryOptions {
+	limit?: number;
+	offset?: number;
+	model?: string;
+	provider?: string;
+	status?: RequestStatusType;
+	from?: Date;
+	to?: Date;
+	userId?: string;
+	orgId?: string;
+}
+
+// Re-export ChatAuditStats from entities
+export type { ChatAuditStats } from '../entities/types';
+
+/**
+ * In-memory audit store implementation
+ */
+export class InMemoryChatAuditStore implements ChatAuditStore {
+	private records: ChatAuditRecord[] = [];
+	private maxSize: number;
+
+	constructor(maxSize = 10000) {
+		this.maxSize = maxSize;
+	}
+
+	async save(record: ChatAuditRecord): Promise<void> {
+		this.records.unshift(record);
+
+		// Trim to max size
+		if (this.records.length > this.maxSize) {
+			this.records = this.records.slice(0, this.maxSize);
+		}
+
+		log.debug(`Saved audit record: ${record.requestId} model=${record.model} status=${record.status}`);
+	}
+
+	async query(options: ChatAuditQueryOptions): Promise<{ records: ChatAuditRecord[]; total: number }> {
+		let filtered = [...this.records];
+
+		if (options.model) {
+			filtered = filtered.filter((r) => r.model === options.model);
+		}
+		if (options.provider) {
+			filtered = filtered.filter((r) => r.provider === options.provider);
+		}
+		if (options.status) {
+			filtered = filtered.filter((r) => r.status === options.status);
+		}
+		if (options.userId) {
+			filtered = filtered.filter((r) => r.userId === options.userId);
+		}
+		if (options.orgId) {
+			filtered = filtered.filter((r) => r.orgId === options.orgId);
+		}
+		if (options.from) {
+			const from = options.from;
+			filtered = filtered.filter((r) => r.requestedAt >= from);
+		}
+		if (options.to) {
+			const to = options.to;
+			filtered = filtered.filter((r) => r.requestedAt <= to);
+		}
+
+		const total = filtered.length;
+		const offset = options.offset || 0;
+		const limit = options.limit || 50;
+
+		return {
+			records: filtered.slice(offset, offset + limit),
+			total,
+		};
+	}
+
+	async getStats(options: { from?: Date; to?: Date }): Promise<ChatAuditStats> {
+		let filtered = [...this.records];
+
+		if (options.from) {
+			const from = options.from;
+			filtered = filtered.filter((r) => r.requestedAt >= from);
+		}
+		if (options.to) {
+			const to = options.to;
+			filtered = filtered.filter((r) => r.requestedAt <= to);
+		}
+
+		const totalRequests = filtered.length;
+		const successfulRequests = filtered.filter((r) => r.status === RequestStatus.SUCCESS).length;
+		const failedRequests = filtered.filter((r) => r.status === RequestStatus.ERROR).length;
+
+		const totalInputTokens = filtered.reduce((sum, r) => sum + (r.inputTokens || 0), 0);
+		const totalOutputTokens = filtered.reduce((sum, r) => sum + (r.outputTokens || 0), 0);
+
+		const durations = filtered.map((r) => r.durationMs).filter((d): d is number => d != null);
+		const avgDurationMs = durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0;
+
+		// Group by model
+		const modelMap = new Map<string, { count: number; tokens: number }>();
+		for (const r of filtered) {
+			const existing = modelMap.get(r.model) || { count: 0, tokens: 0 };
+			existing.count++;
+			existing.tokens += (r.inputTokens || 0) + (r.outputTokens || 0);
+			modelMap.set(r.model, existing);
+		}
+		const byModel = Array.from(modelMap.entries())
+			.map(([model, data]) => ({ model, ...data }))
+			.sort((a, b) => b.count - a.count);
+
+		// Group by provider
+		const providerMap = new Map<string, { count: number; tokens: number }>();
+		for (const r of filtered) {
+			const provider = r.provider || 'unknown';
+			const existing = providerMap.get(provider) || { count: 0, tokens: 0 };
+			existing.count++;
+			existing.tokens += (r.inputTokens || 0) + (r.outputTokens || 0);
+			providerMap.set(provider, existing);
+		}
+		const byProvider = Array.from(providerMap.entries())
+			.map(([provider, data]) => ({ provider, ...data }))
+			.sort((a, b) => b.count - a.count);
+
+		return {
+			totalRequests,
+			successfulRequests,
+			failedRequests,
+			totalInputTokens,
+			totalOutputTokens,
+			avgDurationMs,
+			byModel,
+			byProvider,
+		};
+	}
+}
+
+// Global audit store instance
+let auditStore: ChatAuditStore = new InMemoryChatAuditStore();
+
+/**
+ * Set the audit store implementation
+ */
+export function setChatAuditStore(store: ChatAuditStore) {
+	auditStore = store;
+}
+
+/**
+ * Get the current audit store
+ */
+export function getChatAuditStore(): ChatAuditStore {
+	return auditStore;
+}
+
+/**
+ * Generate a unique request ID
+ */
+export function generateRequestId(): string {
+	return `chat-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+
+/**
+ * Create an audit context for tracking a request
+ */
+export function createAuditContext(options: {
+	method: string;
+	endpoint: string;
+	model: string;
+	inputProtocol: ChatProtocolType;
+	outputProtocol: ChatProtocolType;
+	streaming: boolean;
+	clientIp?: string;
+	userAgent?: string;
+	userId?: string;
+	requestMeta?: Record<string, unknown>;
+}): ChatAuditContext {
+	return new ChatAuditContext(options);
+}
+
+/**
+ * Audit context for tracking a single request lifecycle
+ */
+export class ChatAuditContext {
+	private record: ChatAuditRecord;
+	private startTime: number;
+	private firstTokenTime?: number;
+
+	constructor(options: {
+		method: string;
+		endpoint: string;
+		model: string;
+		inputProtocol: ChatProtocolType;
+		outputProtocol: ChatProtocolType;
+		streaming: boolean;
+		clientIp?: string;
+		userAgent?: string;
+		userId?: string;
+		requestMeta?: Record<string, unknown>;
+	}) {
+		this.startTime = Date.now();
+		this.record = {
+			requestId: generateRequestId(),
+			requestedAt: new Date(),
+			status: RequestStatus.PENDING,
+			method: options.method,
+			endpoint: options.endpoint,
+			inputProtocol: options.inputProtocol,
+			outputProtocol: options.outputProtocol,
+			model: options.model,
+			streaming: options.streaming,
+			clientIp: options.clientIp,
+			userAgent: options.userAgent,
+			userId: options.userId,
+			requestMeta: options.requestMeta,
+		};
+	}
+
+	get requestId(): string {
+		return this.record.requestId;
+	}
+
+	/**
+	 * Set the resolved model and provider info
+	 */
+	setProvider(options: { resolvedModel?: string; provider?: string; upstreamUrl?: string }) {
+		Object.assign(this.record, options);
+	}
+
+	/**
+	 * Record first token received (for TTFT)
+	 */
+	recordFirstToken() {
+		if (!this.firstTokenTime) {
+			this.firstTokenTime = Date.now();
+			this.record.ttftMs = this.firstTokenTime - this.startTime;
+		}
+	}
+
+	/**
+	 * Record token usage
+	 */
+	setTokenUsage(input: number, output: number) {
+		this.record.inputTokens = input;
+		this.record.outputTokens = output;
+		this.record.totalTokens = input + output;
+	}
+
+	/**
+	 * Set response metadata
+	 */
+	setResponseMeta(meta: Record<string, unknown>) {
+		this.record.responseMeta = meta;
+	}
+
+	/**
+	 * Get current duration in ms
+	 */
+	getDuration(): number {
+		return Date.now() - this.startTime;
+	}
+
+	/**
+	 * Complete the request successfully
+	 */
+	async complete(httpStatus: number = 200) {
+		this.record.status = RequestStatus.SUCCESS;
+		this.record.httpStatus = httpStatus;
+		this.record.completedAt = new Date();
+		this.record.durationMs = Date.now() - this.startTime;
+
+		await auditStore.save(this.record);
+	}
+
+	/**
+	 * Complete the request with an error
+	 */
+	async error(errorMessage: string, errorCode?: string, httpStatus: number = 500) {
+		this.record.status = RequestStatus.ERROR;
+		this.record.httpStatus = httpStatus;
+		this.record.errorMessage = errorMessage;
+		this.record.errorCode = errorCode;
+		this.record.completedAt = new Date();
+		this.record.durationMs = Date.now() - this.startTime;
+
+		await auditStore.save(this.record);
+	}
+}
+
+/**
+ * Extract client IP from Hono context
+ */
+export function extractClientIp(c: Context): string | undefined {
+	return (
+		c.req.header('x-forwarded-for')?.split(',')[0]?.trim() ||
+		c.req.header('x-real-ip') ||
+		c.req.header('cf-connecting-ip')
+	);
+}