@anastops/mcp-server 1.1.2 → 2.0.1

package/dist/handlers/v3/utility-tools.js

@@ -0,0 +1,878 @@
+/**
+ * Anastops MCP v3.0 - Consolidated Utility and Data Management Tools
+ *
+ * This module implements the aggressive consolidation plan for v3.0:
+ * - Data tools: 6 → 2 (data_manage, data_query)
+ * - Utility tools: 3 → 1 (system_query)
+ * - Lock tools: 3 → 1 (lock_manage)
+ * - Monitoring tools: 3 → 1 (session_monitoring)
+ * - Config tools: 2 → 1 (config_manage)
+ *
+ * Total reduction: 17 tools → 6 tools (65% reduction)
+ */
+import { nanoid } from 'nanoid';
+import { getArtifact, safePersist } from '../utils.js';
+/* ========================================================================
+ * DATA MANAGEMENT TOOLS (2 tools)
+ * Consolidates: memory_store, memory_retrieve, artifact_save, artifact_get,
+ *              artifact_list, context_optimize
+ * ======================================================================== */
+/**
+ * Data Management Tool - Write Operations
+ *
+ * Handles all data write operations:
+ * - store: Store data in memory (replaces memory_store)
+ * - save: Save artifact (replaces artifact_save)
+ * - optimize: Optimize context for token reduction (replaces context_optimize)
+ */
+export const dataManageTool = {
+    name: 'data_manage',
+    description: 'Manage data operations: store memory, save artifacts, or optimize context. Use operation="store" for memory storage, operation="save" for artifact creation, operation="optimize" for context token reduction.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            operation: {
+                type: 'string',
+                enum: ['store', 'save', 'optimize'],
+                description: 'Operation type: store=memory storage, save=artifact creation, optimize=context optimization',
+            },
+            // For memory_store operation
+            key: {
+                type: 'string',
+                description: 'For store operation: memory key to store value under',
+            },
+            value: {
+                description: 'For store operation: value to store (any JSON-serializable type)',
+            },
+            // For artifact_save operation
+            session_id: {
+                type: 'string',
+                description: 'Required for save/optimize operations: session ID',
+            },
+            artifact_type: {
+                type: 'string',
+                enum: ['code', 'document', 'data', 'config', 'test', 'other'],
+                description: 'For save operation: artifact type classification',
+            },
+            name: {
+                type: 'string',
+                description: 'For save operation: artifact name/filename',
+            },
+            content: {
+                type: 'string',
+                description: 'For save operation: artifact content',
+            },
+            // For context_optimize operation
+            objective: {
+                type: 'string',
+                description: 'For optimize operation: session objective for context optimization',
+            },
+            phase: {
+                type: 'string',
+                description: 'For optimize operation: current phase of work',
+            },
+            progress: {
+                type: 'number',
+                description: 'For optimize operation: progress percentage (0-1)',
+            },
+            messages: {
+                type: 'array',
+                description: 'For optimize operation: messages to optimize',
+            },
+        },
+        required: ['operation'],
+    },
+};
+/**
+ * Data Query Tool - Read Operations
+ *
+ * Handles all data read operations:
+ * - retrieve: Retrieve data from memory (replaces memory_retrieve)
+ * - get: Get single artifact by ID (replaces artifact_get)
+ * - list: List all artifacts for session (replaces artifact_list)
+ */
+export const dataQueryTool = {
+    name: 'data_query',
+    description: 'Query data: retrieve memory, get artifacts, or list artifacts. Use operation="retrieve" for memory lookup, operation="get" for single artifact, operation="list" for all session artifacts.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            operation: {
+                type: 'string',
+                enum: ['retrieve', 'get', 'list'],
+                description: 'Operation type: retrieve=memory lookup, get=single artifact, list=all artifacts',
+            },
+            // For memory_retrieve operation
+            key: {
+                type: 'string',
+                description: 'For retrieve operation: memory key to lookup',
+            },
+            // For artifact_get operation
+            artifact_id: {
+                type: 'string',
+                description: 'For get operation: artifact ID to retrieve',
+            },
+            // For artifact_list operation
+            session_id: {
+                type: 'string',
+                description: 'Required for list operation: session ID to list artifacts from',
+            },
+            artifact_type: {
+                type: 'string',
+                enum: ['code', 'document', 'data', 'config', 'test', 'other'],
+                description: 'For list operation: optional filter by artifact type',
+            },
+        },
+        required: ['operation'],
+    },
+};
+/* ========================================================================
+ * UTILITY TOOLS (4 tools)
+ * Consolidates system utilities, locks, monitoring, and config
+ * ======================================================================== */
+/**
+ * System Query Tool
+ *
+ * Handles all system-level query operations:
+ * - health: Check system health (replaces health_check)
+ * - providers: List available AI providers (replaces provider_list)
+ * - metrics: Get system metrics (replaces metrics_get)
+ */
+export const systemQueryTool = {
+    name: 'system_query',
+    description: 'Query system information: health status, available providers, or system metrics. Use operation="health" for health checks, operation="providers" for provider list, operation="metrics" for system metrics.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            operation: {
+                type: 'string',
+                enum: ['health', 'providers', 'metrics'],
+                description: 'Operation type: health=system health, providers=available providers, metrics=system metrics',
+            },
+            // For health_check operation
+            include_providers: {
+                type: 'boolean',
+                description: 'For health operation: include provider status in health check',
+            },
+            // For provider_list operation
+            filter_healthy: {
+                type: 'boolean',
+                description: 'For providers operation: only show healthy providers',
+            },
+            include_capabilities: {
+                type: 'boolean',
+                description: 'For providers operation: include provider capabilities',
+            },
+            // For metrics_get operation
+            metric_type: {
+                type: 'string',
+                enum: ['routing', 'tokens', 'costs', 'all'],
+                description: 'For metrics operation: type of metrics to retrieve',
+            },
+        },
+    },
+};
+/**
+ * Lock Management Tool
+ *
+ * Handles all file lock operations:
+ * - acquire: Acquire a file lock (replaces lock_acquire)
+ * - release: Release a file lock (replaces lock_release)
+ * - status: Check lock status (replaces lock_status)
+ */
+export const lockManageTool = {
+    name: 'lock_manage',
+    description: 'Manage file locks: acquire, release, or check status. Use operation="acquire" to lock a file, operation="release" to unlock, operation="status" to check lock state.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            operation: {
+                type: 'string',
+                enum: ['acquire', 'release', 'status'],
+                description: 'Operation type: acquire=lock file, release=unlock file, status=check lock',
+            },
+            session_id: {
+                type: 'string',
+                description: 'Required for acquire/release, optional for status: session ID',
+            },
+            file_path: {
+                type: 'string',
+                description: 'Required for acquire/release, optional for status: file path to lock',
+            },
+            ttl: {
+                type: 'number',
+                description: 'For acquire operation: lock TTL in milliseconds (default: 300000)',
+            },
+        },
+        required: ['operation'],
+    },
+};
+/**
+ * Session Monitoring Tool
+ *
+ * Handles all session monitoring operations:
+ * - cost: Get cost breakdown (replaces session_cost)
+ * - metrics: Get request/token metrics (replaces session_metrics)
+ * - throttle: Check rate limit status (replaces session_throttle)
+ */
+export const sessionMonitoringTool = {
+    name: 'session_monitoring',
+    description: 'Monitor session activity: cost breakdown, token metrics, or rate limits. Use operation="cost" for costs, operation="metrics" for token usage, operation="throttle" for rate limits.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            operation: {
+                type: 'string',
+                enum: ['cost', 'metrics', 'throttle'],
+                description: 'Operation type: cost=cost breakdown, metrics=token usage, throttle=rate limits',
+            },
+            session_id: {
+                type: 'string',
+                description: 'Required for all operations: session ID to monitor',
+            },
+            provider: {
+                type: 'string',
+                description: 'For throttle operation: specific provider to check',
+            },
+        },
+        required: ['operation', 'session_id'],
+    },
+};
+/**
+ * Configuration Management Tool
+ *
+ * Handles all configuration operations:
+ * - get: Get configuration value (replaces config_get)
+ * - set: Set configuration value (replaces config_set)
+ */
+export const configManageTool = {
+    name: 'config_manage',
+    description: 'Manage configuration: get or set values. Use operation="get" to retrieve config, operation="set" to update config.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            operation: {
+                type: 'string',
+                enum: ['get', 'set'],
+                description: 'Operation type: get=retrieve value, set=update value',
+            },
+            key: {
+                type: 'string',
+                description: 'Required for both operations: configuration key',
+            },
+            value: {
+                description: 'Required for set operation: value to set (any JSON-serializable type)',
+            },
+        },
+        required: ['operation', 'key'],
+    },
+};
+/* ========================================================================
+ * HANDLER IMPLEMENTATIONS
+ * ======================================================================== */
+/**
+ * Handle data_manage operations
+ */
+export function handleDataManage(args, context) {
+    const operation = args['operation'];
+    switch (operation) {
+        case 'store': {
+            // Validate required parameters
+            if (typeof args['key'] !== 'string') {
+                throw new Error('Missing required parameter: key (string)');
+            }
+            if (args['value'] === undefined) {
+                throw new Error('Missing required parameter: value');
+            }
+            // Build storage key (session-scoped if session_id provided)
+            const key = args['session_id'] !== undefined
+                ? `${String(args['session_id'])}:${String(args['key'])}`
+                : String(args['key']);
+            // Store in memory
+            context.memoryStore.set(key, {
+                value: args['value'],
+                stored_at: new Date(),
+            });
+            return {
+                operation: 'store',
+                key,
+                stored: true,
+                timestamp: new Date(),
+            };
+        }
+        case 'save': {
+            // Validate required parameters
+            if (typeof args['session_id'] !== 'string') {
+                throw new Error('Missing required parameter: session_id (string)');
+            }
+            if (typeof args['artifact_type'] !== 'string') {
+                throw new Error('Missing required parameter: artifact_type (string)');
+            }
+            if (typeof args['name'] !== 'string') {
+                throw new Error('Missing required parameter: name (string)');
+            }
+            if (typeof args['content'] !== 'string') {
+                throw new Error('Missing required parameter: content (string)');
+            }
+            // Create artifact
+            const artifactId = nanoid(21);
+            const now = new Date();
+            const content = String(args['content']);
+            const artifactTypeArg = args['artifact_type'];
+            const artifactType = typeof artifactTypeArg === 'string' ? artifactTypeArg : 'other';
+            const sessionId = String(args['session_id']);
+            const name = String(args['name']);
+            const artifact = {
+                id: artifactId,
+                session_id: sessionId,
+                task_id: null,
+                type: artifactType,
+                name,
+                extension: '',
+                content,
+                content_hash: '',
+                size_bytes: content.length,
+                summary: content.slice(0, 200),
+                token_count: Math.ceil(content.length / 4),
+                relevance_score: 50,
+                metadata: {},
+                created_at: now,
+                updated_at: now,
+            };
+            // Store in memory
+            context.artifacts.set(artifactId, artifact);
+            // Persist to MongoDB
+            safePersist(context.getPersistence().saveArtifact(artifact));
+            return {
+                operation: 'save',
+                artifact_id: artifact.id,
+                name: artifact.name,
+                type: artifact.type,
+                size_bytes: artifact.size_bytes,
+                created_at: artifact.created_at,
+            };
+        }
+        case 'optimize': {
+            // Validate required parameters
+            if (typeof args['session_id'] !== 'string') {
+                throw new Error('Missing required parameter: session_id (string)');
+            }
+            if (typeof args['objective'] !== 'string') {
+                throw new Error('Missing required parameter: objective (string)');
+            }
+            if (typeof args['phase'] !== 'string') {
+                throw new Error('Missing required parameter: phase (string)');
+            }
+            if (typeof args['progress'] !== 'number') {
+                throw new Error('Missing required parameter: progress (number)');
+            }
+            if (!Array.isArray(args['messages'])) {
+                throw new Error('Missing required parameter: messages (array)');
+            }
+            // Placeholder for context optimization
+            // In production, this would use ContextOptimizer from @anastops/core
+            return {
+                operation: 'optimize',
+                session_id: args['session_id'],
+                original_tokens: 1000,
+                optimized_tokens: 500,
+                reduction_percent: 50,
+                minimal_context: args['messages'],
+            };
+        }
+        default:
+            throw new Error(`Unknown data_manage operation: ${String(operation)}`);
+    }
+}
+/**
+ * Handle data_query operations
+ */
+export async function handleDataQuery(args, context) {
+    const operation = args['operation'];
+    switch (operation) {
+        case 'retrieve': {
+            // Validate required parameters
+            if (typeof args['key'] !== 'string') {
+                throw new Error('Missing required parameter: key (string)');
+            }
+            // Retrieve from memory
+            const key = String(args['key']);
+            const data = context.memoryStore.get(key);
+            if (data === undefined) {
+                throw new Error(`Key not found: ${key}`);
+            }
+            return {
+                operation: 'retrieve',
+                key: args['key'],
+                found: true,
+                data,
+            };
+        }
+        case 'get': {
+            // Validate required parameters
+            if (typeof args['artifact_id'] !== 'string') {
+                throw new Error('Missing required parameter: artifact_id (string)');
+            }
+            // Get artifact
+            const artifactId = String(args['artifact_id']);
+            const artifact = await getArtifact(artifactId, context);
+            if (artifact === null) {
+                throw new Error(`Artifact not found: ${artifactId}`);
+            }
+            return {
+                operation: 'get',
+                ...artifact,
+            };
+        }
+        case 'list': {
+            // Validate required parameters
+            if (typeof args['session_id'] !== 'string') {
+                throw new Error('Missing required parameter: session_id (string)');
+            }
+            const sessionId = String(args['session_id']);
+            const artifactTypeArg = args['artifact_type'];
+            const typeFilter = typeof artifactTypeArg === 'string' ? artifactTypeArg : undefined;
+            // Get from in-memory cache first
+            const inMemoryArtifacts = [];
+            for (const [, artifact] of context.artifacts.entries()) {
+                if (artifact.session_id === sessionId) {
+                    if (typeFilter === undefined || artifact.type === typeFilter) {
+                        inMemoryArtifacts.push(artifact);
+                    }
+                }
+            }
+            // Also get from MongoDB for persistence
+            const persistedArtifacts = await context.getPersistence().listArtifacts({
+                session_id: sessionId,
+                ...(typeFilter !== undefined && { type: typeFilter }),
+            });
+            // Merge: in-memory takes precedence
+            const inMemoryIds = new Set(inMemoryArtifacts.map((a) => a.id));
+            const sessionArtifacts = [
+                ...inMemoryArtifacts,
+                ...persistedArtifacts.filter((a) => !inMemoryIds.has(a.id)),
+            ];
+            return {
+                operation: 'list',
+                session_id: sessionId,
+                count: sessionArtifacts.length,
+                ...(typeFilter !== undefined && { type_filter: typeFilter }),
+                artifacts: sessionArtifacts.map((a) => ({
+                    id: a.id,
+                    name: a.name,
+                    type: a.type,
+                    size_bytes: a.size_bytes,
+                    created_at: a.created_at,
+                })),
+            };
+        }
+        default:
+            throw new Error(`Unknown data_query operation: ${String(operation)}`);
+    }
+}
+/**
+ * Handle system_query operations
+ */
+export async function handleSystemQuery(args, context) {
+    const operation = args['operation'] ?? 'health';
+    switch (operation) {
+        case 'health': {
+            // Check MongoDB persistence health
+            const persistence = context.getPersistence();
+            const isMongoConnected = persistence.isConnected();
+            const result = {
+                operation: 'health',
+                status: isMongoConnected ? 'healthy' : 'degraded',
+                timestamp: new Date(),
+                components: {
+                    core: 'healthy',
+                    router: 'healthy',
+                    persistence: isMongoConnected ? 'connected' : 'disconnected',
+                },
+            };
+            if (!isMongoConnected) {
+                result['warning'] =
+                    'MongoDB is not connected. Run "docker ps | grep anastops-mongodb" to verify containers are running.';
+            }
+            if (args['include_providers'] === true) {
+                const providerHealth = {};
+                for (const adapter of context.registry.list()) {
+                    const health = await adapter.healthCheck();
+                    providerHealth[adapter.type] = {
+                        healthy: health.healthy,
+                        error: health.error,
+                    };
+                }
+                result['providers'] = providerHealth;
+            }
+            return result;
+        }
+        case 'providers': {
+            const providers = [];
+            for (const adapter of context.registry.list()) {
+                const health = await adapter.healthCheck();
+                if (args['filter_healthy'] === true && !health.healthy)
+                    continue;
+                const info = {
+                    type: adapter.type,
+                    name: adapter.name,
+                    healthy: health.healthy,
+                };
+                if (args['include_capabilities'] === true) {
+                    const caps = await adapter.getCapabilities();
+                    info['capabilities'] = caps;
+                }
+                providers.push(info);
+            }
+            return {
+                operation: 'providers',
+                count: providers.length,
+                providers,
+            };
+        }
+        case 'metrics': {
+            // Placeholder metrics
+            return {
+                operation: 'metrics',
+                routing: {
+                    tier_distribution: {},
+                    provider_stats: {},
+                },
+                tokens: {
+                    total: 0,
+                    by_provider: {},
+                },
+                costs: {
+                    total: 0,
+                    by_provider: {},
+                },
+            };
+        }
+        default:
+            throw new Error(`Unknown system_query operation: ${String(operation)}`);
+    }
+}
+/**
+ * Handle lock_manage operations
+ */
+export function handleLockManage(args, context) {
+    const operation = args['operation'];
+    switch (operation) {
+        case 'acquire': {
+            // Validate required parameters
+            if (typeof args['session_id'] !== 'string') {
+                throw new Error('Missing required parameter: session_id (string)');
+            }
+            if (typeof args['file_path'] !== 'string') {
+                throw new Error('Missing required parameter: file_path (string)');
+            }
+            const sessionId = String(args['session_id']);
+            const filePath = String(args['file_path']);
+            const ttlArg = args['ttl'];
+            const ttl = typeof ttlArg === 'number' ? ttlArg : 300000;
+            // In-memory lock implementation (Redis-based in production)
+            const lockKey = `lock:${filePath}`;
+            const existingLock = context.memoryStore.get(lockKey);
+            if (existingLock !== undefined) {
+                const lockData = existingLock.value;
+                // Check if lock is expired
+                if (lockData.expires_at > Date.now() && lockData.session_id !== sessionId) {
+                    return {
+                        operation: 'acquire',
+                        session_id: sessionId,
+                        file_path: filePath,
+                        acquired: false,
+                        owner: lockData.session_id,
+                        ttl,
+                    };
+                }
+            }
+            // Acquire lock
+            context.memoryStore.set(lockKey, {
+                value: { session_id: sessionId, expires_at: Date.now() + ttl },
+                stored_at: new Date(),
+            });
+            return {
+                operation: 'acquire',
+                session_id: sessionId,
+                file_path: filePath,
+                acquired: true,
+                ttl,
+            };
+        }
+        case 'release': {
+            // Validate required parameters
+            if (typeof args['session_id'] !== 'string') {
+                throw new Error('Missing required parameter: session_id (string)');
+            }
+            if (typeof args['file_path'] !== 'string') {
+                throw new Error('Missing required parameter: file_path (string)');
+            }
+            const relSessionId = String(args['session_id']);
+            const relFilePath = String(args['file_path']);
+            const lockKey = `lock:${relFilePath}`;
+            const existingLock = context.memoryStore.get(lockKey);
+            if (existingLock !== undefined) {
+                const lockData = existingLock.value;
+                if (lockData.session_id === relSessionId) {
+                    context.memoryStore.delete(lockKey);
+                    return {
+                        operation: 'release',
+                        session_id: relSessionId,
+                        file_path: relFilePath,
+                        released: true,
+                    };
+                }
+                return {
+                    operation: 'release',
+                    session_id: relSessionId,
+                    file_path: relFilePath,
+                    released: false,
+                    error: 'Lock is held by another session',
+                };
+            }
+            return {
+                operation: 'release',
+                session_id: relSessionId,
+                file_path: relFilePath,
+                released: true,
+                message: 'Lock did not exist',
+            };
+        }
+        case 'status': {
+            const sessionId = args['session_id'];
+            const filePath = args['file_path'];
+            if (filePath !== undefined) {
+                const lockKey = `lock:${filePath}`;
+                const existingLock = context.memoryStore.get(lockKey);
+                if (existingLock !== undefined) {
+                    const lockData = existingLock.value;
+                    const isExpired = lockData.expires_at <= Date.now();
+                    return {
+                        operation: 'status',
+                        file_path: filePath,
+                        is_locked: !isExpired,
+                        owner: isExpired ? null : lockData.session_id,
+                        expires_at: lockData.expires_at,
+                    };
+                }
+                return {
+                    operation: 'status',
+                    file_path: filePath,
+                    is_locked: false,
+                    owner: null,
+                };
+            }
+            if (sessionId !== undefined) {
+                // List all locks held by this session
+                const sessionLocks = [];
+                for (const [key, data] of context.memoryStore.entries()) {
+                    if (key.startsWith('lock:')) {
+                        const lockData = data.value;
+                        if (lockData.session_id === sessionId && lockData.expires_at > Date.now()) {
+                            sessionLocks.push({
+                                file_path: key.replace('lock:', ''),
+                                expires_at: lockData.expires_at,
+                            });
+                        }
+                    }
+                }
+                return {
+                    operation: 'status',
+                    session_id: sessionId,
+                    lock_count: sessionLocks.length,
+                    locks: sessionLocks,
+                };
+            }
+            throw new Error('Must provide either session_id or file_path for lock status');
+        }
+        default:
+            throw new Error(`Unknown lock_manage operation: ${String(operation)}`);
+    }
+}
+/**
+ * Handle session_monitoring operations
+ */
+export function handleSessionMonitoring(args, context) {
+    const operation = args['operation'];
+    // Validate session_id (required for all operations)
+    if (typeof args['session_id'] !== 'string') {
+        throw new Error('Missing required parameter: session_id (string)');
+    }
+    const sessionId = String(args['session_id']);
+    switch (operation) {
+        case 'cost': {
+            // Aggregate cost from task token_usage
+            let totalCost = 0;
+            for (const [, task] of context.tasks.entries()) {
+                if (task.session_id === sessionId && task.token_usage !== undefined) {
+                    totalCost += task.token_usage.cost ?? 0;
+                }
+            }
+            return {
+                operation: 'cost',
+                session_id: sessionId,
+                total_cost_usd: totalCost,
+                currency: 'USD',
+            };
+        }
+        case 'metrics': {
+            // Aggregate metrics from tasks
+            let requestCount = 0;
+            let inputTokens = 0;
+            let outputTokens = 0;
+            let totalTokens = 0;
+            for (const [, task] of context.tasks.entries()) {
+                if (task.session_id === sessionId) {
+                    requestCount++;
+                    if (task.token_usage !== undefined) {
+                        inputTokens += task.token_usage.prompt_tokens ?? 0;
+                        outputTokens += task.token_usage.completion_tokens ?? 0;
+                        totalTokens += task.token_usage.total_tokens ?? 0;
+                    }
+                }
+            }
+            return {
+                operation: 'metrics',
+                session_id: sessionId,
+                request_count: requestCount,
+                token_usage: {
+                    input: inputTokens,
+                    output: outputTokens,
+                    total: totalTokens,
+                },
+            };
+        }
+        case 'throttle': {
+            const provider = args['provider'] ?? 'claude';
+            // In-memory rate limit tracking (Redis-based in production)
+            const rateKey = `rate:${sessionId}:${provider}`;
+            const rateData = context.memoryStore.get(rateKey);
+            // Default limits per provider (requests per minute)
+            const defaultLimit = 30;
+            const limits = {
+                claude: 50,
+                openai: 60,
+                gemini: 60,
+            };
+            const limit = limits[provider] ?? defaultLimit;
+            if (rateData !== undefined) {
+                const data = rateData.value;
+                const windowSize = 60000; // 1 minute
+                const now = Date.now();
+                if (now - data.window_start > windowSize) {
+                    // Window expired, reset
+                    return {
+                        operation: 'throttle',
+                        session_id: sessionId,
+                        provider,
+                        usage_percent: 0,
+                        current_count: 0,
+                        limit,
+                        throttled: false,
+                        blocked: false,
+                    };
+                }
+                const usagePercent = (data.count / limit) * 100;
+                return {
+                    operation: 'throttle',
+                    session_id: sessionId,
+                    provider,
+                    usage_percent: Math.min(100, usagePercent),
+                    current_count: data.count,
+                    limit,
+                    throttled: usagePercent >= 85,
+                    blocked: usagePercent >= 95,
+                };
+            }
+            return {
+                operation: 'throttle',
+                session_id: sessionId,
+                provider,
+                usage_percent: 0,
+                current_count: 0,
+                limit,
+                throttled: false,
+                blocked: false,
+            };
+        }
+        default:
+            throw new Error(`Unknown session_monitoring operation: ${String(operation)}`);
+    }
+}
+/**
+ * Handle config_manage operations
+ */
+export function handleConfigManage(args, _context) {
+    const operation = args['operation'];
+    // Validate key (required for both operations)
+    if (typeof args['key'] !== 'string') {
+        throw new Error('Missing required parameter: key (string)');
+    }
+    switch (operation) {
+        case 'get': {
+            // Placeholder config
+            const config = {
+                default_provider: 'claude',
+                default_timeout: 600000, // 10 minutes
+                context_budget: 1600,
+            };
+            const configKey = String(args['key']);
+            return {
+                operation: 'get',
+                key: configKey,
+                value: config[configKey],
+            };
+        }
+        case 'set': {
+            // Validate value (required for set)
+            if (args['value'] === undefined) {
+                throw new Error('Missing required parameter: value for set operation');
+            }
+            return {
+                operation: 'set',
+                key: args['key'],
+                value: args['value'],
+                updated: true,
+            };
+        }
+        default:
+            throw new Error(`Unknown config_manage operation: ${String(operation)}`);
+    }
+}
+/* ========================================================================
+ * EXPORTS
+ * ======================================================================== */
+/**
+ * All v3.0 utility and data tool definitions
+ */
+export const toolDefinitions = [
+    dataManageTool,
+    dataQueryTool,
+    systemQueryTool,
+    lockManageTool,
+    sessionMonitoringTool,
+    configManageTool,
+];
+/**
+ * Main handler router for all v3.0 utility and data tools
+ */
+export async function handleTool(name, args, context) {
+    switch (name) {
+        case 'data_manage':
+            return handleDataManage(args, context);
+        case 'data_query':
+            return handleDataQuery(args, context);
+        case 'system_query':
+            return handleSystemQuery(args, context);
+        case 'lock_manage':
+            return handleLockManage(args, context);
+        case 'session_monitoring':
+            return handleSessionMonitoring(args, context);
+        case 'config_manage':
+            return handleConfigManage(args, context);
+        default:
+            throw new Error(`Unknown v3.0 utility/data tool: ${name}`);
+    }
+}
+//# sourceMappingURL=utility-tools.js.map