@wener/mcps 1.0.1

package/src/chat/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Chat API Module
+ * Provides unified AI model gateway with protocol conversion
+ */
+
+// Types
+export * from './types';
+
+// Converters
+export * from './converters';
+
+// Audit
+export * from './audit';
+
+// Handler
+export { createChatHandler, type ChatHandlerOptions } from './handler';

package/src/chat/types.ts

@@ -0,0 +1,72 @@
+/**
+ * Common types for chat API
+ */
+import { z } from 'zod';
+
+// ============================================================================
+// Provider Configuration (wener-mcps specific)
+// ============================================================================
+
+/**
+ * Protocol type for model providers
+ */
+export type ProtocolType = 'openai' | 'anthropic' | 'gemini';
+
+/**
+ * Provider endpoint configuration
+ */
+export const ProviderEndpointSchema = z.object({
+	baseUrl: z.string(),
+	headers: z.record(z.string(), z.string()).optional(),
+	processors: z.array(z.string()).optional(),
+});
+export type ProviderEndpoint = z.infer<typeof ProviderEndpointSchema>;
+
+/**
+ * Model configuration
+ */
+export const ModelConfigSchema = z.object({
+	/** Base URL for the API */
+	baseUrl: z.string().optional(),
+	/** API key (uses Authorization: Bearer header) */
+	apiKey: z.string().optional(),
+	/** Additional headers */
+	headers: z.record(z.string(), z.string()).optional(),
+	/** Default adapter for protocol conversion */
+	adapter: z.enum(['openai', 'anthropic', 'gemini']).optional(),
+	/** Adapter-specific endpoints */
+	adapters: z
+		.object({
+			openai: ProviderEndpointSchema.optional(),
+			anthropic: ProviderEndpointSchema.optional(),
+			gemini: ProviderEndpointSchema.optional(),
+		})
+		.optional(),
+	/** Processor chain */
+	processors: z.array(z.string()).optional(),
+});
+export type ModelConfig = z.infer<typeof ModelConfigSchema>;
+
+/**
+ * Chat configuration with models
+ */
+export const ChatConfigSchema = z.object({
+	models: z.record(z.string(), ModelConfigSchema).optional(),
+});
+export type ChatConfig = z.infer<typeof ChatConfigSchema>;
+
+// ============================================================================
+// Stream Event Types
+// ============================================================================
+
+/**
+ * Stream event types for SSE
+ */
+export type StreamEventType =
+	| 'message_start'
+	| 'content_block_start'
+	| 'content_block_delta'
+	| 'content_block_stop'
+	| 'message_delta'
+	| 'message_stop'
+	| 'error';

package/src/contracts/AuditContract.ts

@@ -0,0 +1,93 @@
+import { oc } from '@orpc/contract';
+import { z } from 'zod';
+
+// Audit event schema
+export const AuditEventSchema = z.object({
+	id: z.string(),
+	timestamp: z.string(),
+	method: z.string(),
+	path: z.string(),
+	serverName: z.string().nullish(),
+	serverType: z.string().nullish(),
+	status: z.number().nullish(),
+	durationMs: z.number().nullish(),
+	requestHeaders: z.record(z.string(), z.string()).nullish(),
+	responseHeaders: z.record(z.string(), z.string()).nullish(),
+	requestBody: z.unknown().nullish(),
+	responseBody: z.unknown().nullish(),
+	error: z.string().nullish(),
+	toolName: z.string().nullish(),
+	toolArgs: z.unknown().nullish(),
+});
+export type AuditEvent = z.infer<typeof AuditEventSchema>;
+
+// Query params
+export const AuditQuerySchema = z.object({
+	limit: z.coerce.number().default(50),
+	offset: z.coerce.number().default(0),
+	serverName: z.string().nullish(),
+	serverType: z.string().nullish(),
+	method: z.string().nullish(),
+	from: z.string().nullish(),
+	to: z.string().nullish(),
+});
+
+// Audit stats
+export const AuditStatsSchema = z.object({
+	totalRequests: z.number(),
+	totalErrors: z.number(),
+	avgDurationMs: z.number(),
+	byServer: z.array(
+		z.object({
+			name: z.string(),
+			count: z.number(),
+		}),
+	),
+	byMethod: z.array(
+		z.object({
+			method: z.string(),
+			count: z.number(),
+		}),
+	),
+});
+
+// Contract definition
+export const AuditContract = oc.prefix('/audit').router({
+	// List audit events
+	list: oc
+		.input(AuditQuerySchema)
+		.output(
+			z.object({
+				events: z.array(AuditEventSchema),
+				total: z.number(),
+			}),
+		)
+		.route({ method: 'GET', path: '/', summary: 'List audit events' }),
+
+	// Get single event
+	get: oc
+		.input(z.object({ id: z.string() }))
+		.output(AuditEventSchema.nullable())
+		.route({ method: 'GET', path: '/{id}', summary: 'Get audit event by ID' }),
+
+	// Get stats
+	stats: oc
+		.input(
+			z.object({
+				from: z.string().nullish(),
+				to: z.string().nullish(),
+			}),
+		)
+		.output(AuditStatsSchema)
+		.route({ method: 'GET', path: '/stats', summary: 'Get audit statistics' }),
+
+	// Clear old events
+	clear: oc
+		.input(
+			z.object({
+				before: z.string().describe('Clear events before this timestamp'),
+			}),
+		)
+		.output(z.object({ deleted: z.number() }))
+		.route({ method: 'DELETE', path: '/', summary: 'Clear audit events' }),
+});

package/src/contracts/McpsContract.ts

@@ -0,0 +1,141 @@
+import { oc } from '@orpc/contract';
+import { z } from 'zod';
+
+// Server info schema
+export const ServerInfoSchema = z.object({
+	name: z.string(),
+	type: z.string(),
+	disabled: z.boolean().optional(),
+});
+export type ServerInfo = z.infer<typeof ServerInfoSchema>;
+
+// Server type info schema
+export const ServerTypeInfoSchema = z.object({
+	type: z.string(),
+	description: z.string(),
+	dynamicEndpoint: z.string(),
+});
+export type ServerTypeInfo = z.infer<typeof ServerTypeInfoSchema>;
+
+// Model info schema
+export const ModelInfoSchema = z.object({
+	name: z.string(),
+	adapter: z.string().nullish(),
+	baseUrl: z.string().nullish(),
+	contextWindow: z.number().nullish(),
+	maxInputTokens: z.number().nullish(),
+	maxOutputTokens: z.number().nullish(),
+});
+export type ModelInfo = z.infer<typeof ModelInfoSchema>;
+
+// Service overview schema
+export const ServiceOverviewSchema = z.object({
+	name: z.string(),
+	version: z.string(),
+	servers: z.array(ServerInfoSchema),
+	serverTypes: z.array(ServerTypeInfoSchema),
+	models: z.array(ModelInfoSchema),
+	endpoints: z.array(z.string()),
+});
+export type ServiceOverview = z.infer<typeof ServiceOverviewSchema>;
+
+// Request stats schema
+export const RequestStatsSchema = z.object({
+	totalRequests: z.number(),
+	totalErrors: z.number(),
+	avgDurationMs: z.number(),
+	byServer: z.array(
+		z.object({
+			name: z.string(),
+			count: z.number(),
+		}),
+	),
+	byMethod: z.array(
+		z.object({
+			method: z.string(),
+			count: z.number(),
+		}),
+	),
+	byEndpoint: z.array(
+		z.object({
+			endpoint: z.string(),
+			count: z.number(),
+		}),
+	),
+});
+export type RequestStats = z.infer<typeof RequestStatsSchema>;
+
+// Tool parameter schema
+export const ToolParameterSchema = z.object({
+	name: z.string(),
+	type: z.string(),
+	description: z.string().nullish(),
+	required: z.boolean(),
+});
+export type ToolParameter = z.infer<typeof ToolParameterSchema>;
+
+// Tool info schema for display
+export const ToolInfoSchema = z.object({
+	name: z.string(),
+	description: z.string().nullish(),
+	serverName: z.string(),
+	serverType: z.string(),
+	parameters: z.array(ToolParameterSchema),
+	inputSchemaCompact: z.string().nullish(), // Compact TS-like schema representation
+});
+export type ToolInfo = z.infer<typeof ToolInfoSchema>;
+
+// MCPS Contract
+export const McpsContract = oc.prefix('/mcps').router({
+	// Get service overview
+	overview: oc
+		.input(z.object({}))
+		.output(ServiceOverviewSchema)
+		.route({ method: 'GET', path: '/overview', summary: 'Get service overview' }),
+
+	// Get request statistics
+	stats: oc
+		.input(
+			z.object({
+				from: z.string().nullish(),
+				to: z.string().nullish(),
+			}),
+		)
+		.output(RequestStatsSchema)
+		.route({ method: 'GET', path: '/stats', summary: 'Get request statistics' }),
+
+	// List configured servers
+	servers: oc
+		.input(z.object({}))
+		.output(
+			z.object({
+				servers: z.array(ServerInfoSchema),
+			}),
+		)
+		.route({ method: 'GET', path: '/servers', summary: 'List configured servers' }),
+
+	// List configured models
+	models: oc
+		.input(z.object({}))
+		.output(
+			z.object({
+				models: z.array(ModelInfoSchema),
+			}),
+		)
+		.route({ method: 'GET', path: '/models', summary: 'List configured models' }),
+
+	// List tools from all servers
+	tools: oc
+		.input(
+			z.object({
+				server: z.string().nullish(), // Filter by server name
+				filter: z.string().nullish(), // Glob pattern filter (like X-MCP-Include)
+			}),
+		)
+		.output(
+			z.object({
+				tools: z.array(ToolInfoSchema),
+			}),
+		)
+		.route({ method: 'GET', path: '/tools', summary: 'List tools from MCP servers' }),
+});

package/src/contracts/index.ts

@@ -0,0 +1,18 @@
+export { AuditContract, AuditEventSchema, AuditQuerySchema, AuditStatsSchema, type AuditEvent } from './AuditContract';
+export {
+	McpsContract,
+	ServiceOverviewSchema,
+	ServerInfoSchema,
+	ServerTypeInfoSchema,
+	ModelInfoSchema,
+	RequestStatsSchema,
+	ToolInfoSchema,
+	ToolParameterSchema,
+	type ServiceOverview,
+	type ServerInfo,
+	type ServerTypeInfo,
+	type ModelInfo,
+	type RequestStats,
+	type ToolInfo,
+	type ToolParameter,
+} from './McpsContract';

package/src/dev.server.ts

@@ -0,0 +1,7 @@
+import { createServer } from '#/server/server';
+
+const { app } = createServer({});
+
+export default {
+	fetch: app.fetch,
+};

package/src/entities/ChatRequestEntity.ts

@@ -0,0 +1,157 @@
+import { Entity, Enum, PrimaryKey, Property } from '@mikro-orm/decorators/es';
+
+/**
+ * Chat protocol type
+ */
+export const ChatProtocolType = Object.freeze({
+	OpenAI: 'openai',
+	Anthropic: 'anthropic',
+	Gemini: 'gemini',
+} as const);
+export type ChatProtocolType = (typeof ChatProtocolType)[keyof typeof ChatProtocolType];
+
+/**
+ * Request status
+ */
+export const RequestStatus = Object.freeze({
+	Pending: 'pending',
+	Success: 'success',
+	Error: 'error',
+	Timeout: 'timeout',
+} as const);
+export type RequestStatus = (typeof RequestStatus)[keyof typeof RequestStatus];
+
+/**
+ * Chat Request Entity for auditing and metering
+ */
+@Entity({ tableName: 'chat_request' })
+export class ChatRequestEntity {
+	@PrimaryKey({ type: 'integer' })
+	id!: number;
+
+	/** Unique request ID for tracing */
+	@Property({ type: 'string', unique: true })
+	requestId!: string;
+
+	/** Request timestamp */
+	@Property({ type: 'datetime' })
+	requestedAt: Date = new Date();
+
+	/** Response timestamp */
+	@Property({ type: 'datetime', nullable: true })
+	completedAt?: Date;
+
+	/** Request status */
+	@Enum(() => RequestStatus)
+	status: RequestStatus = RequestStatus.Pending;
+
+	/** HTTP method */
+	@Property({ type: 'string' })
+	method!: string;
+
+	/** Request path/endpoint */
+	@Property({ type: 'string' })
+	endpoint!: string;
+
+	/** Input protocol (client-facing) */
+	@Enum(() => ChatProtocolType)
+	inputProtocol!: ChatProtocolType;
+
+	/** Output protocol (upstream provider) */
+	@Enum(() => ChatProtocolType)
+	outputProtocol!: ChatProtocolType;
+
+	/** Model name requested */
+	@Property({ type: 'string' })
+	model!: string;
+
+	/** Resolved model name */
+	@Property({ type: 'string', nullable: true })
+	resolvedModel?: string;
+
+	/** Provider name */
+	@Property({ type: 'string', nullable: true })
+	provider?: string;
+
+	/** Upstream base URL */
+	@Property({ type: 'string', nullable: true })
+	upstreamUrl?: string;
+
+	/** Whether request was streaming */
+	@Property({ type: 'boolean', default: false })
+	streaming: boolean = false;
+
+	/** Input token count */
+	@Property({ type: 'integer', nullable: true })
+	inputTokens?: number;
+
+	/** Output token count */
+	@Property({ type: 'integer', nullable: true })
+	outputTokens?: number;
+
+	/** Total token count */
+	@Property({ type: 'integer', nullable: true })
+	totalTokens?: number;
+
+	/** Request duration in ms */
+	@Property({ type: 'integer', nullable: true })
+	durationMs?: number;
+
+	/** Time to first token in ms */
+	@Property({ type: 'integer', nullable: true })
+	ttftMs?: number;
+
+	/** HTTP status code */
+	@Property({ type: 'integer', nullable: true })
+	httpStatus?: number;
+
+	/** Error message */
+	@Property({ type: 'text', nullable: true })
+	errorMessage?: string;
+
+	/** Error code */
+	@Property({ type: 'string', nullable: true })
+	errorCode?: string;
+
+	/** Client IP */
+	@Property({ type: 'string', nullable: true })
+	clientIp?: string;
+
+	/** User agent */
+	@Property({ type: 'string', nullable: true })
+	userAgent?: string;
+
+	/** User ID */
+	@Property({ type: 'string', nullable: true })
+	userId?: string;
+
+	/** Organization ID */
+	@Property({ type: 'string', nullable: true })
+	orgId?: string;
+
+	/** API key ID (not the actual key) */
+	@Property({ type: 'string', nullable: true })
+	apiKeyId?: string;
+
+	/** Request metadata (JSON) */
+	@Property({ type: 'json', nullable: true })
+	requestMeta?: Record<string, unknown>;
+
+	/** Response metadata (JSON) */
+	@Property({ type: 'json', nullable: true })
+	responseMeta?: Record<string, unknown>;
+
+	/** Cost in credits (decimal string) */
+	@Property({ type: 'string', nullable: true })
+	cost?: string;
+
+	/** Currency */
+	@Property({ type: 'string', nullable: true })
+	currency?: string;
+
+	@Property({ type: 'datetime' })
+	createdAt: Date = new Date();
+
+	@Property({ type: 'datetime', onUpdate: () => new Date() })
+	updatedAt: Date = new Date();
+}

package/src/entities/McpRequestEntity.ts

@@ -0,0 +1,149 @@
+import { Entity, Enum, PrimaryKey, Property } from '@mikro-orm/decorators/es';
+
+/**
+ * MCP server type
+ */
+export const McpServerType = Object.freeze({
+	TencentCls: 'tencent-cls',
+	Sql: 'sql',
+	Prometheus: 'prometheus',
+	Relay: 'relay',
+	Custom: 'custom',
+} as const);
+export type McpServerType = (typeof McpServerType)[keyof typeof McpServerType];
+
+/**
+ * MCP request type (JSON-RPC method)
+ */
+export const McpRequestType = Object.freeze({
+	Initialize: 'initialize',
+	ToolsList: 'tools/list',
+	ToolsCall: 'tools/call',
+	ResourcesList: 'resources/list',
+	ResourcesRead: 'resources/read',
+	PromptsList: 'prompts/list',
+	PromptsGet: 'prompts/get',
+	CompletionComplete: 'completion/complete',
+	LoggingSetLevel: 'logging/setLevel',
+	Ping: 'ping',
+	Other: 'other',
+} as const);
+export type McpRequestType = (typeof McpRequestType)[keyof typeof McpRequestType];
+
+/**
+ * Request status
+ */
+export const RequestStatus = Object.freeze({
+	Pending: 'pending',
+	Success: 'success',
+	Error: 'error',
+	Timeout: 'timeout',
+} as const);
+export type RequestStatus = (typeof RequestStatus)[keyof typeof RequestStatus];
+
+/**
+ * MCP Request Entity for auditing
+ */
+@Entity({ tableName: 'mcp_request' })
+export class McpRequestEntity {
+	@PrimaryKey({ type: 'integer' })
+	id!: number;
+
+	/** Unique request ID */
+	@Property({ type: 'string' })
+	requestId!: string;
+
+	/** MCP session ID */
+	@Property({ type: 'string', nullable: true })
+	sessionId?: string;
+
+	/** Request timestamp */
+	@Property({ type: 'datetime' })
+	requestedAt: Date = new Date();
+
+	/** Response timestamp */
+	@Property({ type: 'datetime', nullable: true })
+	completedAt?: Date;
+
+	/** Request status */
+	@Enum(() => RequestStatus)
+	status: RequestStatus = RequestStatus.Pending;
+
+	/** HTTP method */
+	@Property({ type: 'string' })
+	method!: string;
+
+	/** Request path */
+	@Property({ type: 'string' })
+	path!: string;
+
+	/** MCP server name */
+	@Property({ type: 'string' })
+	serverName!: string;
+
+	/** MCP server type */
+	@Enum(() => McpServerType)
+	serverType: McpServerType = McpServerType.Custom;
+
+	/** MCP request type (JSON-RPC method) */
+	@Enum(() => McpRequestType)
+	mcpMethod: McpRequestType = McpRequestType.Other;
+
+	/** Tool name (for tools/call) */
+	@Property({ type: 'string', nullable: true })
+	toolName?: string;
+
+	/** Resource URI (for resources/read) */
+	@Property({ type: 'string', nullable: true })
+	resourceUri?: string;
+
+	/** Prompt name (for prompts/get) */
+	@Property({ type: 'string', nullable: true })
+	promptName?: string;
+
+	/** Request duration in ms */
+	@Property({ type: 'integer', nullable: true })
+	durationMs?: number;
+
+	/** HTTP status code */
+	@Property({ type: 'integer', nullable: true })
+	httpStatus?: number;
+
+	/** Error message */
+	@Property({ type: 'text', nullable: true })
+	errorMessage?: string;
+
+	/** Error code */
+	@Property({ type: 'string', nullable: true })
+	errorCode?: string;
+
+	/** Client IP */
+	@Property({ type: 'string', nullable: true })
+	clientIp?: string;
+
+	/** User agent */
+	@Property({ type: 'string', nullable: true })
+	userAgent?: string;
+
+	/** User ID */
+	@Property({ type: 'string', nullable: true })
+	userId?: string;
+
+	/** Request headers (JSON) */
+	@Property({ type: 'json', nullable: true })
+	requestHeaders?: Record<string, string>;
+
+	/** Request body (JSON) */
+	@Property({ type: 'json', nullable: true })
+	requestBody?: Record<string, unknown>;
+
+	/** Response metadata (JSON) */
+	@Property({ type: 'json', nullable: true })
+	responseMeta?: Record<string, unknown>;
+
+	@Property({ type: 'datetime' })
+	createdAt: Date = new Date();
+
+	@Property({ type: 'datetime', onUpdate: () => new Date() })
+	updatedAt: Date = new Date();
+}