mcp-agentic-pipelines 1.0.1

package/packages/clinical/src/index.ts

@@ -0,0 +1,262 @@
+/**
+ * Clinical Intake Integration for Unified MCP Server
+ *
+ * USES THE REAL clinical-intake/pipeline.mjs — NOT A REWRITE.
+ * Imports directly from the cloned clinical-intake repo.
+ *
+ * Multi-provider LLM via the real pipeline's clinicalChat().
+ * STT: Groq (whisper-large-v3) via the real pipeline
+ * TTS: ElevenLabs via the real pipeline
+ *
+ * Privacy: Anonymous by design.
+ */
+
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+import type { Config, Logger, RateLimiter, ToolDefinition, ResourceDefinition, PromptDefinition } from '@unified-mcp/core';
+import { ValidationError, validateBase64 } from '@unified-mcp/core';
+
+// ═══════════════════════════════════════════════════════════════════════
+// Dynamic import of the REAL clinical-intake pipeline
+// ═══════════════════════════════════════════════════════════════════════
+
+const CLINICAL_PIPELINE_PATH = '../../../vendors/clinical-intake/pipeline.mjs';
+let _pipelineModule: any = null;
+async function getPipeline() {
+  if (!_pipelineModule) { _pipelineModule = await import(CLINICAL_PIPELINE_PATH); }
+  return _pipelineModule;
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// Types
+// ═══════════════════════════════════════════════════════════════════════
+
+export interface RegisterContext {
+  config: Config;
+  logger: Logger;
+  rateLimiter: RateLimiter;
+  tools: ToolDefinition[];
+  resources: ResourceDefinition[];
+  prompts: PromptDefinition[];
+  toolHandlers: Map<string, (args: unknown) => Promise<{ content: Array<{ type: 'text'; text: string }>; isError?: boolean }>>;
+  resourceHandlers: Map<string, (uri: string) => Promise<{ contents: Array<{ uri: string; mimeType: string; text?: string }> }>>;
+  promptHandlers: Map<string, (args?: Record<string, string>) => Promise<{ messages: Array<{ role: 'user' | 'assistant'; content: { type: 'text'; text: string } }> }>>;
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// Tool Schemas
+// ═══════════════════════════════════════════════════════════════════════
+
+const SESSION_START_SCHEMA = {
+  type: 'object',
+  properties: {
+    patient_name: { type: 'string', description: 'Patient first name (not persisted).', maxLength: 100 },
+    lang: { type: 'string', enum: ['en', 'fr'], default: 'fr', description: 'Interview language.' },
+  },
+};
+
+const PROCESS_AUDIO_SCHEMA = {
+  type: 'object',
+  properties: {
+    session_id: { type: 'string', description: 'Session ID from clinical_start_session.' },
+    audio_data: { type: 'string', description: 'Base64-encoded audio (webm, mp3, wav).' },
+  },
+  required: ['session_id', 'audio_data'],
+};
+
+const GENERATE_PODCAST_SCHEMA = {
+  type: 'object',
+  properties: {
+    session_id: { type: 'string', description: 'Session ID to compile into podcast MP3.' },
+  },
+  required: ['session_id'],
+};
+
+const LIST_SESSIONS_SCHEMA = { type: 'object', properties: {} };
+
+const GET_SESSION_SCHEMA = {
+  type: 'object',
+  properties: {
+    session_id: { type: 'string', description: 'Session ID to retrieve.' },
+  },
+  required: ['session_id'],
+};
+
+// ═══════════════════════════════════════════════════════════════════════
+// Registration — ALL logic from clinical-intake/pipeline.mjs
+// ═══════════════════════════════════════════════════════════════════════
+
+export function registerClinical(ctx: RegisterContext): void {
+  const { config, logger, rateLimiter, tools, resources, prompts, toolHandlers, resourceHandlers, promptHandlers } = ctx;
+
+  const llmConfig = config.clinicalLLM;
+  logger.info(`Clinical LLM: provider=${llmConfig.provider}, model=${llmConfig.model}`);
+  logger.info('Using REAL pipeline from clinical-intake/pipeline.mjs');
+
+  // ── clinical_start_session ─────────────────────────────────────
+  tools.push({
+    name: 'clinical_start_session',
+    description: 'Start a new anonymous clinical intake session. Uses the real clinical-intake pipeline: bilingual questionnaires (EN: Health Canada, FR: RAMQ), Groq STT, multi-provider LLM, ElevenLabs TTS. Returns session ID, greeting text, and greeting audio.',
+    inputSchema: SESSION_START_SCHEMA,
+  });
+
+  toolHandlers.set('clinical_start_session', async (args: unknown) => {
+    rateLimiter.check('clinical_start_session', 'costly');
+    const pipe = await getPipeline();
+
+    const { patient_name, lang } = (args ?? {}) as any;
+    const language = lang === 'en' ? 'en' : 'fr';
+    const sid = pipe.generateSessionId();
+    pipe.getSession(sid, patient_name || '', language);
+    const session = pipe.getSession(sid);
+
+    let greetingAudioBase64: string | null = null;
+    try {
+      const audioBuffer = await pipe.synthesize(session.primingText, config.ELEVENLABS_API_KEY, config.ELEVENLABS_VOICE_ID);
+      greetingAudioBase64 = audioBuffer.toString('base64');
+    } catch (err: any) {
+      logger.warn(`TTS unavailable: ${err.message}`, 'clinical_start_session');
+    }
+
+    logger.info(`Clinical session: ${sid} (${language})`, 'clinical_start_session');
+    return { content: [{ type: 'text' as const, text: JSON.stringify({
+      session_id: sid, greeting_text: session.primingText, greeting_audio_base64: greetingAudioBase64,
+      lang: session.lang, total_questions: session.questions.length,
+      _llm: { provider: llmConfig.provider, model: llmConfig.model, configured: !!llmConfig.apiKey },
+    }) }] };
+  });
+
+  // ── clinical_process_audio ─────────────────────────────────────
+  tools.push({
+    name: 'clinical_process_audio',
+    description: 'Process patient audio through the REAL clinical pipeline: Groq STT transcription → Multi-provider LLM clinical reasoning → ElevenLabs TTS voice reply. Returns transcript, LLM response, and audio reply.',
+    inputSchema: PROCESS_AUDIO_SCHEMA,
+  });
+
+  toolHandlers.set('clinical_process_audio', async (args: unknown) => {
+    rateLimiter.check('clinical_process_audio', 'costly');
+    const pipe = await getPipeline();
+
+    const { session_id, audio_data } = (args ?? {}) as any;
+    const validation = validateBase64(audio_data, 10 * 1024 * 1024);
+    if (!validation.valid) throw new ValidationError('audio_data', validation.error);
+
+    const session = pipe.getSession(session_id);
+    if (!session?.primingText) throw new ValidationError('session_id', `Session "${session_id}" not found.`);
+
+    const result = await pipe.processClinicalTurn(session_id, validation.buffer, {
+      groqApiKey: config.GROQ_API_KEY,
+      llmApiKey: llmConfig.apiKey,
+      llmBaseUrl: llmConfig.baseUrl,
+      llmModel: llmConfig.model,
+      elevenlabsApiKey: config.ELEVENLABS_API_KEY,
+      elevenlabsVoiceId: config.ELEVENLABS_VOICE_ID,
+    });
+
+    logger.info(`Turn ${result.turn_number}: "${result.user_text.slice(0, 60)}..."`, 'clinical_process_audio');
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] };
+  });
+
+  // ── clinical_generate_podcast ──────────────────────────────────
+  tools.push({
+    name: 'clinical_generate_podcast',
+    description: 'Compile a complete clinical encounter into an MP3 podcast using the REAL pipeline. All dialog turns + greeting combined.',
+    inputSchema: GENERATE_PODCAST_SCHEMA,
+  });
+
+  toolHandlers.set('clinical_generate_podcast', async (args: unknown) => {
+    rateLimiter.check('clinical_generate_podcast', 'costly');
+    const pipe = await getPipeline();
+
+    const { session_id } = (args ?? {}) as any;
+    const session = pipe.getSession(session_id);
+    if (!session?.primingText) throw new ValidationError('session_id', `Session "${session_id}" not found.`);
+    if (session.dialog.length === 0) {
+      return { content: [{ type: 'text' as const, text: JSON.stringify({ error: 'No conversation to render.' }) }], isError: true };
+    }
+
+    const podcast = await pipe.buildPodcast(session_id, {
+      elevenlabsApiKey: config.ELEVENLABS_API_KEY,
+      elevenlabsVoiceId: config.ELEVENLABS_VOICE_ID,
+    });
+
+    logger.info(`Podcast: ${session_id} (${(podcast.length / 1024).toFixed(1)} KB)`, 'clinical_generate_podcast');
+    return { content: [{ type: 'text' as const, text: JSON.stringify({
+      podcast_base64: podcast.toString('base64'), session_id, turns: session.dialog.length + 1,
+      duration_seconds: Math.round(session.dialog.length * 15), file_size_bytes: podcast.length,
+      patient_name: session.patientName || '(anonymous)', lang: session.lang,
+    }) }] };
+  });
+
+  // ── clinical_list_sessions ─────────────────────────────────────
+  tools.push({
+    name: 'clinical_list_sessions',
+    description: 'List all clinical intake sessions from the real pipeline. Anonymous by design.',
+    inputSchema: LIST_SESSIONS_SCHEMA,
+  });
+  toolHandlers.set('clinical_list_sessions', async () => {
+    rateLimiter.check('clinical_list_sessions', 'read');
+    const pipe = await getPipeline();
+    return { content: [{ type: 'text' as const, text: JSON.stringify({ sessions: pipe.listSessions() }) }] };
+  });
+
+  // ── clinical_get_session ───────────────────────────────────────
+  tools.push({
+    name: 'clinical_get_session',
+    description: 'Get full session detail with dialog turns (text only, audio excluded).',
+    inputSchema: GET_SESSION_SCHEMA,
+  });
+  toolHandlers.set('clinical_get_session', async (args: unknown) => {
+    rateLimiter.check('clinical_get_session', 'read');
+    const pipe = await getPipeline();
+    const { session_id } = (args ?? {}) as any;
+    const session = pipe.getSession(session_id);
+    if (!session?.primingText) throw new ValidationError('session_id', `Session "${session_id}" not found.`);
+    return { content: [{ type: 'text' as const, text: JSON.stringify({
+      session_id, lang: session.lang,
+      turns: session.dialog.map((t: any) => ({ role: t.role, text: t.text })),
+      is_complete: session.isComplete, questions_total: session.questions.length, questions_asked: session.questionIndex,
+      created_at: session.createdAt,
+    }) }] };
+  });
+
+  // ── Resources ──────────────────────────────────────────────────
+  resources.push({
+    uri: 'clinical://questions/{lang}',
+    name: 'Clinical Questionnaire',
+    description: 'Clinical intake questions from the real pipeline (clinical-intake/questions/).',
+    mimeType: 'application/json',
+  });
+  resourceHandlers.set('clinical://questions/{lang}', async (uri: string) => {
+    const pipe = await getPipeline();
+    const match = uri.match(/^clinical:\/\/questions\/(en|fr)$/);
+    if (!match) throw new ValidationError('uri', `Invalid: ${uri}`);
+    const lang = match[1] as 'en' | 'fr';
+    const questions = lang === 'fr' ? pipe.QUESTIONS_FR : pipe.QUESTIONS_EN;
+    return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify({ lang, questions, count: questions.length }) }] };
+  });
+
+  // ── Prompts ────────────────────────────────────────────────────
+  prompts.push({
+    name: 'clinical/intake-en',
+    description: 'English clinical intake prompt from the real pipeline. Includes all 8 Health Canada questions and clinical safety rules.',
+    arguments: [{ name: 'patient_name', description: 'Patient first name.', required: false }],
+  });
+  promptHandlers.set('clinical/intake-en', async (args?: Record<string, string>) => {
+    const pipe = await getPipeline();
+    return { messages: [{ role: 'user' as const, content: { type: 'text' as const, text: pipe.buildSystemPrompt('en', args?.patient_name || 'sir/madam') } }] };
+  });
+
+  prompts.push({
+    name: 'clinical/intake-fr',
+    description: 'French clinical intake prompt from the real pipeline (RAMQ). Includes all 8 questions and clinical safety rules.',
+    arguments: [{ name: 'patient_name', description: 'Patient first name.', required: false }],
+  });
+  promptHandlers.set('clinical/intake-fr', async (args?: Record<string, string>) => {
+    const pipe = await getPipeline();
+    return { messages: [{ role: 'user' as const, content: { type: 'text' as const, text: pipe.buildSystemPrompt('fr', args?.patient_name || 'M./Mme') } }] };
+  });
+
+  logger.info('Clinical: 5 tools, 1 resource, 2 prompts — using REAL clinical-intake/pipeline.mjs');
+}

package/packages/clinical/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "composite": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist", "__tests__"],
+  "references": [
+    { "path": "../core" }
+  ]
+}

package/packages/core/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@unified-mcp/core",
+  "version": "0.1.0",
+  "description": "Shared utilities, types, config, and multi-provider LLM abstraction for the unified MCP server",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.5",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "vitest": "^2.0.0"
+  }
+}

package/packages/core/src/config.ts

@@ -0,0 +1,138 @@
+/**
+ * Central Configuration Loader
+ *
+ * Loads and validates all environment variables using Zod schemas.
+ * Re-exports the resolved LLM config for convenience.
+ */
+
+import { z } from 'zod';
+import dotenv from 'dotenv';
+import { resolveLLMConfig, llmProviderSchema, type ResolvedLLMConfig } from './llm-config.js';
+
+dotenv.config();
+
+// ── Full configuration schema ────────────────────────────────────────
+
+export const configSchema = z.object({
+  // --- LLM Defaults ---
+  LLM_DEFAULT_PROVIDER: z.string().default('openai'),
+  LLM_DEFAULT_API_KEY: z.string().default(''),
+  LLM_DEFAULT_BASE_URL: z.string().default(''),
+  LLM_DEFAULT_MODEL: z.string().default(''),
+
+  // --- Azure ---
+  AZURE_OPENAI_ENDPOINT: z.string().default(''),
+  AZURE_OPENAI_API_KEY: z.string().default(''),
+  AZURE_OPENAI_DEPLOYMENT: z.string().default(''),
+  AZURE_OPENAI_API_VERSION: z.string().default('2024-08-01-preview'),
+
+  // --- Anthropic ---
+  ANTHROPIC_API_KEY: z.string().default(''),
+  ANTHROPIC_BASE_URL: z.string().default(''),
+
+  // --- Google ---
+  GOOGLE_API_KEY: z.string().default(''),
+
+  // --- Ollama ---
+  OLLAMA_HOST: z.string().default('http://localhost:11434'),
+
+  // --- DeepPipe ---
+  DEEPPIPE_INDEX_PATH: z.string().default('./data/deeppipe.db'),
+  DEEPPIPE_LLM_PROVIDER: z.string().default(''),
+  DEEPPIPE_LLM_API_KEY: z.string().default(''),
+  DEEPPIPE_LLM_MODEL: z.string().default(''),
+
+  // --- Piste ---
+  PISTE_API_URL: z.string().default('http://localhost:8000'),
+  PISTE_LLM_PROVIDER: z.string().default(''),
+  PISTE_LLM_API_KEY: z.string().default(''),
+  TAVILY_API_KEY: z.string().default(''),
+  SERPER_API_KEY: z.string().default(''),
+  GOOGLE_CSE_API_KEY: z.string().default(''),
+  GOOGLE_CSE_ID: z.string().default(''),
+
+  // --- Precis ---
+  PRECIS_API_URL: z.string().default('http://localhost:8001'),
+  PRECIS_LLM_PROVIDER: z.string().default(''),
+  PRECIS_LLM_API_KEY: z.string().default(''),
+
+  // --- Clinical ---
+  CLINICAL_LLM_PROVIDER: z.string().default(''),
+  CLINICAL_LLM_API_KEY: z.string().default(''),
+  CLINICAL_LLM_MODEL: z.string().default(''),
+  CLINICAL_STT_PROVIDER: z.string().default('groq'),
+  GROQ_API_KEY: z.string().default(''),
+  CLINICAL_TTS_PROVIDER: z.string().default('elevenlabs'),
+  ELEVENLABS_API_KEY: z.string().default(''),
+  ELEVENLABS_VOICE_ID: z.string().default('21m00Tcm4TlvDq8ikWAM'),
+
+  // --- MCP Server ---
+  MCP_SERVER_NAME: z.string().default('mcp-agentic-pipelines'),
+  MCP_SERVER_VERSION: z.string().default('1.0.0'),
+  MCP_TRANSPORT: z.enum(['stdio', 'sse']).default('stdio'),
+  MCP_SSE_PORT: z.coerce.number().int().positive().default(3100),
+  MCP_LOG_LEVEL: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
+  MCP_RATE_LIMIT_ENABLED: z.enum(['true', 'false', '1', '0']).default('false').transform(v => v === 'true' || v === '1'),
+  MCP_RATE_LIMIT_MAX_RPS: z.coerce.number().int().positive().default(10),
+});
+
+export type RawConfig = z.infer<typeof configSchema>;
+
+// ── Enriched config with resolved LLM settings ───────────────────────
+
+export interface Config extends RawConfig {
+  /** Resolved LLM config for DeepPipe (chat feature). */
+  deepPipeLLM: ResolvedLLMConfig;
+  /** Resolved LLM config for Piste. */
+  pisteLLM: ResolvedLLMConfig;
+  /** Resolved LLM config for Precis. */
+  precisLLM: ResolvedLLMConfig;
+  /** Resolved LLM config for Clinical Intake. */
+  clinicalLLM: ResolvedLLMConfig;
+}
+
+/** Singleton config instance, loaded once at startup. */
+let _config: Config | null = null;
+
+/**
+ * Load and validate configuration from environment variables.
+ * Safe to call multiple times — returns cached instance after first call.
+ */
+export function loadConfig(): Config {
+  if (_config) return _config;
+
+  const raw = configSchema.parse(process.env);
+
+  _config = {
+    ...raw,
+    deepPipeLLM: resolveLLMConfig({
+      provider: raw.DEEPPIPE_LLM_PROVIDER || undefined,
+      apiKey: raw.DEEPPIPE_LLM_API_KEY || undefined,
+      model: raw.DEEPPIPE_LLM_MODEL || undefined,
+    }),
+    pisteLLM: resolveLLMConfig({
+      provider: raw.PISTE_LLM_PROVIDER || undefined,
+      apiKey: raw.PISTE_LLM_API_KEY || undefined,
+    }),
+    precisLLM: resolveLLMConfig({
+      provider: raw.PRECIS_LLM_PROVIDER || undefined,
+      apiKey: raw.PRECIS_LLM_API_KEY || undefined,
+    }),
+    clinicalLLM: resolveLLMConfig({
+      provider: raw.CLINICAL_LLM_PROVIDER || undefined,
+      apiKey: raw.CLINICAL_LLM_API_KEY || undefined,
+      model: raw.CLINICAL_LLM_MODEL || undefined,
+    }),
+  };
+
+  return _config;
+}
+
+/**
+ * Reset cached config (useful in tests).
+ */
+export function resetConfig(): void {
+  _config = null;
+}
+
+export { resolveLLMConfig, type ResolvedLLMConfig } from './llm-config.js';

package/packages/core/src/errors.ts

@@ -0,0 +1,100 @@
+/**
+ * Structured Error Types
+ *
+ * MCPToolError maps directly to MCP protocol error responses.
+ * All tool handlers should throw or return these.
+ */
+
+/** Base error class for all MCP tool errors. */
+export class MCPToolError extends Error {
+  public readonly name = 'MCPToolError';
+
+  constructor(
+    public readonly code: string,
+    message: string,
+    public readonly statusCode: number = 400,
+  ) {
+    super(message);
+  }
+
+  /** Convert to MCP protocol error response shape. */
+  toMCPResponse(): { content: Array<{ type: 'text'; text: string }>; isError: true } {
+    return {
+      content: [{
+        type: 'text' as const,
+        text: JSON.stringify({ code: this.code, message: this.message }),
+      }],
+      isError: true,
+    };
+  }
+
+  /** Convert to a plain JSON-serializable error object. */
+  toJSON(): { code: string; message: string } {
+    return { code: this.code, message: this.message };
+  }
+}
+
+/** Thrown when an external service (piste, precis) is unreachable. */
+export class ServiceUnavailableError extends MCPToolError {
+  constructor(service: string) {
+    super(
+      'SERVICE_UNAVAILABLE',
+      `${service} is not reachable. Ensure the service is running and PISTE_API_URL / PRECIS_API_URL are correctly configured.`,
+      503,
+    );
+  }
+}
+
+/** Thrown when tool input fails validation. */
+export class ValidationError extends MCPToolError {
+  constructor(field: string, message: string) {
+    super('VALIDATION_ERROR', `${field}: ${message}`, 400);
+  }
+}
+
+/** Thrown when rate limit is exceeded. */
+export class RateLimitError extends MCPToolError {
+  constructor(toolName: string, retryAfterMs: number = 1000) {
+    super(
+      'RATE_LIMITED',
+      `Rate limit exceeded for tool "${toolName}". Retry after ${Math.ceil(retryAfterMs / 1000)}s.`,
+      429,
+    );
+  }
+}
+
+/** Thrown when an LLM provider is not configured. */
+export class LLMNotConfiguredError extends MCPToolError {
+  constructor(component: string, provider: string) {
+    super(
+      'LLM_NOT_CONFIGURED',
+      `${component}: LLM provider "${provider}" requires an API key. Set the appropriate env variable (e.g. LLM_DEFAULT_API_KEY or ${component.toUpperCase()}_LLM_API_KEY).`,
+      400,
+    );
+  }
+}
+
+/** Thrown when authentication fails for an external API. */
+export class AuthenticationError extends MCPToolError {
+  constructor(service: string) {
+    super(
+      'AUTHENTICATION_ERROR',
+      `${service} rejected the API key. Verify your credentials.`,
+      401,
+    );
+  }
+}
+
+/** Thrown when a requested resource is not found. */
+export class NotFoundError extends MCPToolError {
+  constructor(resourceType: string, id: string) {
+    super('NOT_FOUND', `${resourceType} with id "${id}" not found.`, 404);
+  }
+}
+
+/** Thrown for internal/unexpected errors. */
+export class InternalError extends MCPToolError {
+  constructor(message: string = 'An unexpected internal error occurred.') {
+    super('INTERNAL', message, 500);
+  }
+}

package/packages/core/src/index.ts

@@ -0,0 +1,104 @@
+/**
+ * @unified-mcp/core — Barrel Export
+ *
+ * Shared utilities, types, config, rate limiting, logging,
+ * and multi-provider LLM configuration for all integration packages.
+ */
+
+// Config
+export {
+  loadConfig,
+  resetConfig,
+  resolveLLMConfig,
+  configSchema,
+  type Config,
+  type RawConfig,
+  type ResolvedLLMConfig,
+} from './config.js';
+
+// Multi-Provider LLM
+export {
+  LLM_PROVIDERS,
+  PROVIDER_DEFAULTS,
+  OPENAI_COMPATIBLE_PROVIDERS,
+  NATIVE_SDK_PROVIDERS,
+  resolveLLMConfig as resolveLLM,
+  listProviders,
+  isValidProvider,
+  llmProviderSchema,
+  llmConfigSchema,
+  type LLMProvider,
+} from './llm-config.js';
+
+// Errors
+export {
+  MCPToolError,
+  ServiceUnavailableError,
+  ValidationError,
+  RateLimitError,
+  LLMNotConfiguredError,
+  AuthenticationError,
+  NotFoundError,
+  InternalError,
+} from './errors.js';
+
+// Validation
+export {
+  validateArgs,
+  sanitizeString,
+  validateBase64,
+  clampInt,
+  intSchema,
+  stringSchema,
+  localeSchema,
+  base64Schema,
+} from './validation.js';
+
+// Logging
+export {
+  Logger,
+  createLogger,
+  defaultLogger,
+  type LogLevel,
+  type LogEntry,
+} from './logging.js';
+
+// Rate Limiting
+export {
+  TokenBucket,
+  RateLimiter,
+  createRateLimiter,
+  type RateCategory,
+} from './rate-limiter.js';
+
+// Python Bridge
+export {
+  PythonService,
+  PythonServiceManager,
+  findPython,
+  resetPythonCache,
+  type PythonServiceOptions,
+} from './python-bridge.js';
+
+// Types
+export type {
+  MCPTextContent,
+  MCPToolResponse,
+  MCPResourceContent,
+  ToolDefinition,
+  ResourceDefinition,
+  PromptDefinition,
+  ServiceHealth,
+  LLMProviderInfo,
+  AudioTurn,
+  ClinicalSession,
+  SearchHit,
+  SearchResults,
+  StoredDocument,
+  ChatSource,
+  ChatContext,
+  FactCheckVerdict,
+  VerdictLabel,
+  PrecisQueryResult,
+  WorkOrder,
+} from './types.js';