agent-orchestrator-mcp-server 0.2.4 → 0.3.0

package/shared/orchestrator-client/orchestrator-client.integration-mock.js

@@ -111,7 +111,6 @@ export function createIntegrationMockOrchestratorClient(initialMockData) {
             const paginatedSessions = sessions.slice(start, start + perPage);
             return {
                 query,
-                search_contents: options?.search_contents || false,
                 sessions: paginatedSessions,
                 pagination: {
                     page,
@@ -443,5 +442,318 @@ export function createIntegrationMockOrchestratorClient(initialMockData) {
                 session_id: session.id,
             };
         },
+        // Session Extensions
+        async forkSession(id, _messageIndex) {
+            const session = mockData.sessions?.find((s) => s.id === Number(id) || s.slug === String(id));
+            if (!session)
+                throw new Error(`API Error (404): Session not found`);
+            sessionIdCounter++;
+            const forked = {
+                ...session,
+                id: sessionIdCounter,
+                title: `Forked: ${session.title}`,
+                status: 'waiting',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+            mockData.sessions?.push(forked);
+            return { session: forked, message: 'Session forked successfully' };
+        },
+        async refreshSession(id) {
+            const session = mockData.sessions?.find((s) => s.id === Number(id) || s.slug === String(id));
+            if (!session)
+                throw new Error(`API Error (404): Session not found`);
+            return { session, message: 'Session refreshed' };
+        },
+        async refreshAllSessions() {
+            return {
+                message: 'All sessions refreshed',
+                refreshed: mockData.sessions?.length || 0,
+                restarted: 0,
+                continued: 0,
+                errors: 0,
+            };
+        },
+        async updateSessionNotes(id, _notes) {
+            const session = mockData.sessions?.find((s) => s.id === Number(id) || s.slug === String(id));
+            if (!session)
+                throw new Error(`API Error (404): Session not found`);
+            session.updated_at = new Date().toISOString();
+            return session;
+        },
+        async toggleFavorite(id) {
+            const session = mockData.sessions?.find((s) => s.id === Number(id) || s.slug === String(id));
+            if (!session)
+                throw new Error(`API Error (404): Session not found`);
+            return { ...session, favorited: true };
+        },
+        async bulkArchiveSessions(sessionIds) {
+            let archived = 0;
+            for (const sid of sessionIds) {
+                const session = mockData.sessions?.find((s) => s.id === sid);
+                if (session) {
+                    session.status = 'archived';
+                    session.archived_at = new Date().toISOString();
+                    archived++;
+                }
+            }
+            return { archived_count: archived, errors: [] };
+        },
+        async getTranscript(_id, _format) {
+            return { transcript_text: 'User: Hello\nAssistant: Hi there!' };
+        },
+        // Enqueued Messages
+        async listEnqueuedMessages(_sessionId, options) {
+            const page = options?.page || 1;
+            const perPage = options?.per_page || 25;
+            return {
+                enqueued_messages: [],
+                pagination: { page, per_page: perPage, total_count: 0, total_pages: 0 },
+            };
+        },
+        async getEnqueuedMessage(_sessionId, messageId) {
+            return {
+                id: messageId,
+                session_id: 1,
+                content: 'Test message',
+                stop_condition: null,
+                position: 1,
+                status: 'pending',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async createEnqueuedMessage(sessionId, data) {
+            return {
+                id: 1,
+                session_id: Number(sessionId),
+                content: data.content,
+                stop_condition: data.stop_condition || null,
+                position: 1,
+                status: 'pending',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async updateEnqueuedMessage(_sessionId, messageId, data) {
+            return {
+                id: messageId,
+                session_id: 1,
+                content: data.content || 'Updated message',
+                stop_condition: data.stop_condition || null,
+                position: 1,
+                status: 'pending',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async deleteEnqueuedMessage(_sessionId, _messageId) {
+            // No-op
+        },
+        async reorderEnqueuedMessage(_sessionId, messageId, position) {
+            return {
+                id: messageId,
+                session_id: 1,
+                content: 'Test message',
+                stop_condition: null,
+                position,
+                status: 'pending',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async interruptEnqueuedMessage(sessionId, _messageId) {
+            const session = mockData.sessions?.find((s) => s.id === Number(sessionId) || s.slug === String(sessionId));
+            if (!session)
+                throw new Error(`API Error (404): Session not found`);
+            return { session, message: 'Message sent as interrupt' };
+        },
+        // Triggers
+        async listTriggers(options) {
+            const page = options?.page || 1;
+            const perPage = options?.per_page || 25;
+            return {
+                triggers: [],
+                pagination: { page, per_page: perPage, total_count: 0, total_pages: 0 },
+            };
+        },
+        async getTrigger(id) {
+            const trigger = {
+                id,
+                name: 'Test Trigger',
+                trigger_type: 'schedule',
+                status: 'enabled',
+                agent_root_name: 'mcp-servers',
+                prompt_template: 'Test prompt',
+                stop_condition: null,
+                reuse_session: false,
+                mcp_servers: [],
+                configuration: {},
+                schedule_description: 'Every day',
+                last_session_id: null,
+                last_triggered_at: null,
+                last_polled_at: null,
+                sessions_created_count: 0,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+            return { trigger, recent_sessions: [] };
+        },
+        async createTrigger(data) {
+            return {
+                id: 1,
+                name: data.name,
+                trigger_type: data.trigger_type,
+                status: data.status || 'enabled',
+                agent_root_name: data.agent_root_name,
+                prompt_template: data.prompt_template,
+                stop_condition: data.stop_condition || null,
+                reuse_session: data.reuse_session || false,
+                mcp_servers: data.mcp_servers || [],
+                configuration: data.configuration || {},
+                schedule_description: null,
+                last_session_id: null,
+                last_triggered_at: null,
+                last_polled_at: null,
+                sessions_created_count: 0,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async updateTrigger(id, data) {
+            return {
+                id,
+                name: data.name || 'Updated Trigger',
+                trigger_type: data.trigger_type || 'schedule',
+                status: data.status || 'enabled',
+                agent_root_name: data.agent_root_name || 'mcp-servers',
+                prompt_template: data.prompt_template || 'Test prompt',
+                stop_condition: data.stop_condition || null,
+                reuse_session: data.reuse_session || false,
+                mcp_servers: data.mcp_servers || [],
+                configuration: data.configuration || {},
+                schedule_description: null,
+                last_session_id: null,
+                last_triggered_at: null,
+                last_polled_at: null,
+                sessions_created_count: 0,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async deleteTrigger(_id) {
+            // No-op
+        },
+        async toggleTrigger(id) {
+            return {
+                id,
+                name: 'Toggled Trigger',
+                trigger_type: 'schedule',
+                status: 'disabled',
+                agent_root_name: 'mcp-servers',
+                prompt_template: 'Test prompt',
+                stop_condition: null,
+                reuse_session: false,
+                mcp_servers: [],
+                configuration: {},
+                schedule_description: null,
+                last_session_id: null,
+                last_triggered_at: null,
+                last_polled_at: null,
+                sessions_created_count: 0,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async getTriggerChannels() {
+            return {
+                channels: [{ id: 'C123', name: 'general', is_private: false, num_members: 50 }],
+            };
+        },
+        // Notification Management
+        async listNotifications(options) {
+            const page = options?.page || 1;
+            const perPage = options?.per_page || 25;
+            return {
+                notifications: [],
+                pagination: { page, per_page: perPage, total_count: 0, total_pages: 0 },
+            };
+        },
+        async getNotification(id) {
+            return {
+                id,
+                session_id: 1,
+                notification_type: 'session_needs_input',
+                read: false,
+                stale: false,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async getNotificationBadge() {
+            return { pending_count: 0 };
+        },
+        async markNotificationRead(id) {
+            return {
+                id,
+                session_id: 1,
+                notification_type: 'session_needs_input',
+                read: true,
+                stale: false,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async markAllNotificationsRead() {
+            return { marked_count: 0, pending_count: 0 };
+        },
+        async dismissNotification(_id) {
+            // No-op
+        },
+        async dismissAllReadNotifications() {
+            return { dismissed_count: 0, pending_count: 0 };
+        },
+        // Health
+        async getHealth() {
+            return {
+                health_report: { sessions: { running: 1 } },
+                timestamp: new Date().toISOString(),
+                rails_env: 'test',
+                ruby_version: '3.3.0',
+            };
+        },
+        async cleanupProcesses() {
+            return { cleaned: 0, message: 'No orphaned processes' };
+        },
+        async retrySessions(_sessionIds) {
+            return { retried: 0, message: 'No sessions to retry' };
+        },
+        async archiveOldSessions(_days) {
+            return { archived: 0, message: 'No old sessions' };
+        },
+        // CLIs
+        async getCliStatus() {
+            return { cli_status: {}, unauthenticated_count: 0 };
+        },
+        async refreshCli() {
+            return { queued: true, message: 'CLI refresh queued' };
+        },
+        async clearCliCache() {
+            return { queued: true, message: 'CLI cache clear queued' };
+        },
+        // Transcript Archive
+        async getTranscriptArchiveStatus() {
+            return {
+                generated_at: '2025-01-15T15:00:00Z',
+                session_count: 10,
+                file_size_bytes: 524288,
+            };
+        },
+        getTranscriptArchiveDownloadUrl() {
+            return {
+                url: 'http://localhost:3000/api/v1/transcript_archive/download',
+                apiKey: 'test-api-key',
+            };
+        },
     };
 }

package/shared/orchestrator-client/orchestrator-client.js

@@ -98,6 +98,67 @@ export class AgentOrchestratorClient {
         }
         return response.json();
     }
+    /**
+     * Like request(), but reads the response as text and wraps it in a TranscriptResponse.
+     * Used for API endpoints that return raw text instead of JSON (e.g., transcript with format=text).
+     */
+    async requestText(method, path, body, queryParams) {
+        const url = new URL(`${this.baseUrl}${path}`);
+        if (queryParams) {
+            Object.entries(queryParams).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.append(key, String(value));
+                }
+            });
+        }
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+        };
+        if (body) {
+            headers['Content-Type'] = 'application/json';
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+        const options = {
+            method,
+            headers,
+            signal: controller.signal,
+        };
+        if (body && (method === 'POST' || method === 'PATCH' || method === 'PUT')) {
+            options.body = JSON.stringify(body);
+        }
+        let response;
+        try {
+            response = await fetch(url.toString(), options);
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(`Request timeout after ${this.timeoutMs}ms`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        if (!response.ok) {
+            const errorText = await response.text();
+            let errorMessage;
+            try {
+                const errorJson = JSON.parse(errorText);
+                errorMessage = errorJson.message || errorJson.error || errorText;
+            }
+            catch {
+                errorMessage = errorText;
+            }
+            throw new Error(`API Error (${response.status}): ${errorMessage}`);
+        }
+        if (response.status === 204) {
+            return { transcript_text: '' };
+        }
+        const text = await response.text();
+        return { transcript_text: text };
+    }
     // Sessions
     async listSessions(options) {
         return this.request('GET', '/sessions', undefined, options);
@@ -207,4 +268,148 @@ export class AgentOrchestratorClient {
             message,
         });
     }
+    // Session Extensions
+    async forkSession(id, messageIndex) {
+        return this.request('POST', `/sessions/${id}/fork`, {
+            message_index: messageIndex,
+        });
+    }
+    async refreshSession(id) {
+        return this.request('POST', `/sessions/${id}/refresh`);
+    }
+    async refreshAllSessions() {
+        return this.request('POST', '/sessions/refresh_all');
+    }
+    async updateSessionNotes(id, notes) {
+        const response = await this.request('PATCH', `/sessions/${id}/notes`, {
+            session_notes: notes,
+        });
+        return response.session;
+    }
+    async toggleFavorite(id) {
+        return this.request('POST', `/sessions/${id}/toggle_favorite`);
+    }
+    async bulkArchiveSessions(sessionIds) {
+        return this.request('POST', '/sessions/bulk_archive', {
+            session_ids: sessionIds,
+        });
+    }
+    async getTranscript(id, format = 'json') {
+        if (format === 'text') {
+            // The API returns raw text (not JSON) when format=text,
+            // so we must use response.text() instead of response.json()
+            return this.requestText('GET', `/sessions/${id}/transcript`, undefined, { format });
+        }
+        return this.request('GET', `/sessions/${id}/transcript`, undefined, {
+            format,
+        });
+    }
+    // Enqueued Messages
+    async listEnqueuedMessages(sessionId, options) {
+        return this.request('GET', `/sessions/${sessionId}/enqueued_messages`, undefined, options);
+    }
+    async getEnqueuedMessage(sessionId, messageId) {
+        const response = await this.request('GET', `/sessions/${sessionId}/enqueued_messages/${messageId}`);
+        return response.enqueued_message;
+    }
+    async createEnqueuedMessage(sessionId, data) {
+        const response = await this.request('POST', `/sessions/${sessionId}/enqueued_messages`, data);
+        return response.enqueued_message;
+    }
+    async updateEnqueuedMessage(sessionId, messageId, data) {
+        const response = await this.request('PATCH', `/sessions/${sessionId}/enqueued_messages/${messageId}`, data);
+        return response.enqueued_message;
+    }
+    async deleteEnqueuedMessage(sessionId, messageId) {
+        await this.request('DELETE', `/sessions/${sessionId}/enqueued_messages/${messageId}`);
+    }
+    async reorderEnqueuedMessage(sessionId, messageId, position) {
+        const response = await this.request('PATCH', `/sessions/${sessionId}/enqueued_messages/${messageId}/reorder`, { position });
+        return response.enqueued_message;
+    }
+    async interruptEnqueuedMessage(sessionId, messageId) {
+        return this.request('POST', `/sessions/${sessionId}/enqueued_messages/${messageId}/interrupt`);
+    }
+    // Triggers
+    async listTriggers(options) {
+        return this.request('GET', '/triggers', undefined, options);
+    }
+    async getTrigger(id) {
+        return this.request('GET', `/triggers/${id}`);
+    }
+    async createTrigger(data) {
+        const response = await this.request('POST', '/triggers', data);
+        return response.trigger;
+    }
+    async updateTrigger(id, data) {
+        const response = await this.request('PATCH', `/triggers/${id}`, data);
+        return response.trigger;
+    }
+    async deleteTrigger(id) {
+        await this.request('DELETE', `/triggers/${id}`);
+    }
+    async toggleTrigger(id) {
+        const response = await this.request('POST', `/triggers/${id}/toggle`);
+        return response.trigger;
+    }
+    async getTriggerChannels() {
+        return this.request('GET', '/triggers/channels');
+    }
+    // Notification Management
+    async listNotifications(options) {
+        return this.request('GET', '/notifications', undefined, options);
+    }
+    async getNotification(id) {
+        const response = await this.request('GET', `/notifications/${id}`);
+        return response.notification;
+    }
+    async getNotificationBadge() {
+        return this.request('GET', '/notifications/badge');
+    }
+    async markNotificationRead(id) {
+        const response = await this.request('PATCH', `/notifications/${id}/mark_read`);
+        return response.notification;
+    }
+    async markAllNotificationsRead() {
+        return this.request('PATCH', '/notifications/mark_all_read');
+    }
+    async dismissNotification(id) {
+        await this.request('DELETE', `/notifications/${id}`);
+    }
+    async dismissAllReadNotifications() {
+        return this.request('DELETE', '/notifications/dismiss_all_read');
+    }
+    // Health
+    async getHealth() {
+        return this.request('GET', '/health');
+    }
+    async cleanupProcesses() {
+        return this.request('POST', '/health/cleanup_processes');
+    }
+    async retrySessions(sessionIds) {
+        return this.request('POST', '/health/retry_sessions', sessionIds ? { session_ids: sessionIds } : undefined);
+    }
+    async archiveOldSessions(days) {
+        return this.request('POST', '/health/archive_old', days ? { days } : undefined);
+    }
+    // CLIs
+    async getCliStatus() {
+        return this.request('GET', '/clis/status');
+    }
+    async refreshCli() {
+        return this.request('POST', '/clis/refresh');
+    }
+    async clearCliCache() {
+        return this.request('POST', '/clis/clear_cache');
+    }
+    // Transcript Archive
+    async getTranscriptArchiveStatus() {
+        return this.request('GET', '/transcript_archive/status');
+    }
+    getTranscriptArchiveDownloadUrl() {
+        return {
+            url: `${this.baseUrl}/api/v1/transcript_archive/download`,
+            apiKey: this.apiKey,
+        };
+    }
 }

package/shared/resources.js

@@ -58,7 +58,7 @@ export function createRegisterResources(clientFactory) {
                         AGENT_ORCHESTRATOR_API_KEY: process.env.AGENT_ORCHESTRATOR_API_KEY
                             ? '***configured***'
                             : 'not set',
-                        ENABLED_TOOLGROUPS: process.env.ENABLED_TOOLGROUPS || 'all (default)',
+                        TOOL_GROUPS: process.env.TOOL_GROUPS || 'all (default)',
                         SKIP_HEALTH_CHECKS: process.env.SKIP_HEALTH_CHECKS || 'false',
                     },
                     capabilities: {
@@ -66,9 +66,14 @@ export function createRegisterResources(clientFactory) {
                         resources: true,
                     },
                     toolGroups: {
-                        readonly: 'Read-only operations (list, get, search)',
-                        write: 'Write operations (create, update, follow_up, pause, restart, archive, unarchive)',
-                        admin: 'Administrative operations (delete)',
+                        sessions: 'All session tools (read + write): search, get, configs, start, action, enqueued messages',
+                        sessions_readonly: 'Session tools (read only): quick_search_sessions, get_session, get_configs',
+                        notifications: 'All notification tools (read + write): get, send, mark read, dismiss',
+                        notifications_readonly: 'Notification tools (read only): get_notifications',
+                        triggers: 'All trigger tools (read + write): search, create, update, delete, toggle',
+                        triggers_readonly: 'Trigger tools (read only): search_triggers',
+                        health: 'All health tools (read + write): health report, CLI status, maintenance actions',
+                        health_readonly: 'Health tools (read only): get_system_health',
                     },
                 };
                 return {

package/shared/tools/action-health.d.ts

@@ -0,0 +1,58 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+import type { IAgentOrchestratorClient } from '../orchestrator-client/orchestrator-client.js';
+export declare const ActionHealthSchema: z.ZodObject<{
+    action: z.ZodEnum<["cleanup_processes", "retry_sessions", "archive_old", "cli_refresh", "cli_clear_cache"]>;
+    session_ids: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    days: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    action: "cleanup_processes" | "retry_sessions" | "archive_old" | "cli_refresh" | "cli_clear_cache";
+    session_ids?: number[] | undefined;
+    days?: number | undefined;
+}, {
+    action: "cleanup_processes" | "retry_sessions" | "archive_old" | "cli_refresh" | "cli_clear_cache";
+    session_ids?: number[] | undefined;
+    days?: number | undefined;
+}>;
+export declare function actionHealthTool(_server: Server, clientFactory: () => IAgentOrchestratorClient): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            action: {
+                type: string;
+                enum: readonly ["cleanup_processes", "retry_sessions", "archive_old", "cli_refresh", "cli_clear_cache"];
+                description: string;
+            };
+            session_ids: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            days: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: unknown) => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    }>;
+};
+//# sourceMappingURL=action-health.d.ts.map