agent-orchestrator-mcp-server 0.2.4 → 0.2.5

package/shared/tools/manage-enqueued-messages.d.ts

@@ -0,0 +1,94 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+import type { IAgentOrchestratorClient } from '../orchestrator-client/orchestrator-client.js';
+export declare const ManageEnqueuedMessagesSchema: z.ZodObject<{
+    session_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    action: z.ZodEnum<["list", "get", "create", "update", "delete", "reorder", "interrupt"]>;
+    message_id: z.ZodOptional<z.ZodNumber>;
+    content: z.ZodOptional<z.ZodString>;
+    stop_condition: z.ZodOptional<z.ZodString>;
+    position: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    session_id: string | number;
+    action: "list" | "get" | "create" | "update" | "delete" | "reorder" | "interrupt";
+    per_page?: number | undefined;
+    page?: number | undefined;
+    content?: string | undefined;
+    stop_condition?: string | undefined;
+    message_id?: number | undefined;
+    position?: number | undefined;
+}, {
+    session_id: string | number;
+    action: "list" | "get" | "create" | "update" | "delete" | "reorder" | "interrupt";
+    per_page?: number | undefined;
+    page?: number | undefined;
+    content?: string | undefined;
+    stop_condition?: string | undefined;
+    message_id?: number | undefined;
+    position?: number | undefined;
+}>;
+export declare function manageEnqueuedMessagesTool(_server: Server, clientFactory: () => IAgentOrchestratorClient): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            session_id: {
+                oneOf: {
+                    type: string;
+                }[];
+                description: string;
+            };
+            action: {
+                type: string;
+                enum: readonly ["list", "get", "create", "update", "delete", "reorder", "interrupt"];
+                description: string;
+            };
+            message_id: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            stop_condition: {
+                type: string;
+                description: string;
+            };
+            position: {
+                type: string;
+                minimum: number;
+                description: string;
+            };
+            page: {
+                type: string;
+                minimum: number;
+                description: string;
+            };
+            per_page: {
+                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=manage-enqueued-messages.d.ts.map

package/shared/tools/manage-enqueued-messages.js

@@ -0,0 +1,259 @@
+import { z } from 'zod';
+const ACTION_ENUM = ['list', 'get', 'create', 'update', 'delete', 'reorder', 'interrupt'];
+export const ManageEnqueuedMessagesSchema = z.object({
+    session_id: z.union([z.string(), z.number()]),
+    action: z.enum(ACTION_ENUM),
+    message_id: z.number().optional(),
+    content: z.string().optional(),
+    stop_condition: z.string().optional(),
+    position: z.number().min(1).optional(),
+    page: z.number().min(1).optional(),
+    per_page: z.number().min(1).max(100).optional(),
+});
+const TOOL_DESCRIPTION = `Manage the enqueued message queue for an agent session.
+
+**Actions:**
+- **list**: List all enqueued messages for a session (supports pagination)
+- **get**: Get a specific enqueued message by ID
+- **create**: Add a new message to the queue (requires "content")
+- **update**: Update an existing message (requires "message_id")
+- **delete**: Remove a message from the queue (requires "message_id")
+- **reorder**: Change a message's position in the queue (requires "message_id" and "position")
+- **interrupt**: Pause the session and send this message immediately (requires "message_id")
+
+Enqueued messages are follow-up prompts queued to be sent to the agent in order.`;
+export function manageEnqueuedMessagesTool(_server, clientFactory) {
+    return {
+        name: 'manage_enqueued_messages',
+        description: TOOL_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: {
+                    oneOf: [{ type: 'string' }, { type: 'number' }],
+                    description: 'Session ID (numeric) or slug (string).',
+                },
+                action: {
+                    type: 'string',
+                    enum: ACTION_ENUM,
+                    description: 'Action to perform on enqueued messages.',
+                },
+                message_id: {
+                    type: 'number',
+                    description: 'Message ID. Required for get, update, delete, reorder, and interrupt.',
+                },
+                content: {
+                    type: 'string',
+                    description: 'Message content. Required for create. Optional for update.',
+                },
+                stop_condition: {
+                    type: 'string',
+                    description: 'Stop condition for this message. Optional for create and update.',
+                },
+                position: {
+                    type: 'number',
+                    minimum: 1,
+                    description: 'New position in queue. Required for reorder.',
+                },
+                page: { type: 'number', minimum: 1, description: 'Page number for list. Default: 1' },
+                per_page: {
+                    type: 'number',
+                    minimum: 1,
+                    maximum: 100,
+                    description: 'Results per page for list. Default: 25',
+                },
+            },
+            required: ['session_id', 'action'],
+        },
+        handler: async (args) => {
+            try {
+                const validated = ManageEnqueuedMessagesSchema.parse(args);
+                const client = clientFactory();
+                const { session_id, action, message_id, content, stop_condition, position, page, per_page, } = validated;
+                let result;
+                switch (action) {
+                    case 'list': {
+                        const response = await client.listEnqueuedMessages(session_id, { page, per_page });
+                        if (response.enqueued_messages.length === 0) {
+                            result = '## Enqueued Messages\n\nNo enqueued messages found.';
+                        }
+                        else {
+                            const lines = [
+                                `## Enqueued Messages (${response.pagination.total_count} total, page ${response.pagination.page} of ${response.pagination.total_pages})`,
+                                '',
+                            ];
+                            response.enqueued_messages.forEach((msg) => {
+                                lines.push(`### Position ${msg.position} (ID: ${msg.id})`);
+                                lines.push(`- **Status:** ${msg.status}`);
+                                lines.push(`- **Content:** ${msg.content.substring(0, 200)}${msg.content.length > 200 ? '...' : ''}`);
+                                if (msg.stop_condition)
+                                    lines.push(`- **Stop Condition:** ${msg.stop_condition}`);
+                                lines.push('');
+                            });
+                            result = lines.join('\n');
+                        }
+                        break;
+                    }
+                    case 'get': {
+                        if (!message_id) {
+                            return {
+                                content: [
+                                    { type: 'text', text: 'Error: "message_id" is required for the "get" action.' },
+                                ],
+                                isError: true,
+                            };
+                        }
+                        const msg = await client.getEnqueuedMessage(session_id, message_id);
+                        result = [
+                            `## Enqueued Message #${msg.id}`,
+                            '',
+                            `- **Session ID:** ${msg.session_id}`,
+                            `- **Position:** ${msg.position}`,
+                            `- **Status:** ${msg.status}`,
+                            `- **Content:** ${msg.content}`,
+                            msg.stop_condition ? `- **Stop Condition:** ${msg.stop_condition}` : '',
+                            `- **Created:** ${msg.created_at}`,
+                        ]
+                            .filter(Boolean)
+                            .join('\n');
+                        break;
+                    }
+                    case 'create': {
+                        if (!content) {
+                            return {
+                                content: [
+                                    { type: 'text', text: 'Error: "content" is required for the "create" action.' },
+                                ],
+                                isError: true,
+                            };
+                        }
+                        const msg = await client.createEnqueuedMessage(session_id, {
+                            content,
+                            stop_condition: stop_condition || undefined,
+                        });
+                        result = [
+                            '## Message Enqueued',
+                            '',
+                            `- **ID:** ${msg.id}`,
+                            `- **Position:** ${msg.position}`,
+                            `- **Status:** ${msg.status}`,
+                            `- **Content:** ${msg.content.substring(0, 200)}${msg.content.length > 200 ? '...' : ''}`,
+                        ].join('\n');
+                        break;
+                    }
+                    case 'update': {
+                        if (!message_id) {
+                            return {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: 'Error: "message_id" is required for the "update" action.',
+                                    },
+                                ],
+                                isError: true,
+                            };
+                        }
+                        const msg = await client.updateEnqueuedMessage(session_id, message_id, {
+                            content: content || undefined,
+                            stop_condition: stop_condition || undefined,
+                        });
+                        result = [
+                            '## Message Updated',
+                            '',
+                            `- **ID:** ${msg.id}`,
+                            `- **Position:** ${msg.position}`,
+                            `- **Content:** ${msg.content.substring(0, 200)}${msg.content.length > 200 ? '...' : ''}`,
+                        ].join('\n');
+                        break;
+                    }
+                    case 'delete': {
+                        if (!message_id) {
+                            return {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: 'Error: "message_id" is required for the "delete" action.',
+                                    },
+                                ],
+                                isError: true,
+                            };
+                        }
+                        await client.deleteEnqueuedMessage(session_id, message_id);
+                        result = `## Message Deleted\n\nEnqueued message ${message_id} has been removed from the queue.`;
+                        break;
+                    }
+                    case 'reorder': {
+                        if (!message_id) {
+                            return {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: 'Error: "message_id" is required for the "reorder" action.',
+                                    },
+                                ],
+                                isError: true,
+                            };
+                        }
+                        if (!position) {
+                            return {
+                                content: [
+                                    { type: 'text', text: 'Error: "position" is required for the "reorder" action.' },
+                                ],
+                                isError: true,
+                            };
+                        }
+                        const msg = await client.reorderEnqueuedMessage(session_id, message_id, position);
+                        result = [
+                            '## Message Reordered',
+                            '',
+                            `- **ID:** ${msg.id}`,
+                            `- **New Position:** ${msg.position}`,
+                        ].join('\n');
+                        break;
+                    }
+                    case 'interrupt': {
+                        if (!message_id) {
+                            return {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: 'Error: "message_id" is required for the "interrupt" action.',
+                                    },
+                                ],
+                                isError: true,
+                            };
+                        }
+                        const response = await client.interruptEnqueuedMessage(session_id, message_id);
+                        result = [
+                            '## Message Sent as Interrupt',
+                            '',
+                            `- **Session ID:** ${response.session.id}`,
+                            `- **Session Status:** ${response.session.status}`,
+                            `- **Message:** ${response.message}`,
+                        ].join('\n');
+                        break;
+                    }
+                    default: {
+                        const _exhaustiveCheck = action;
+                        return {
+                            content: [{ type: 'text', text: `Error: Unknown action "${_exhaustiveCheck}"` }],
+                            isError: true,
+                        };
+                    }
+                }
+                return { content: [{ type: 'text', text: result }] };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error managing enqueued messages: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/shared/tools/search-triggers.d.ts

@@ -0,0 +1,78 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+import type { IAgentOrchestratorClient } from '../orchestrator-client/orchestrator-client.js';
+export declare const SearchTriggersSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNumber>;
+    trigger_type: z.ZodOptional<z.ZodEnum<["slack", "schedule"]>>;
+    status: z.ZodOptional<z.ZodEnum<["enabled", "disabled"]>>;
+    include_channels: z.ZodOptional<z.ZodBoolean>;
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    per_page?: number | undefined;
+    status?: "enabled" | "disabled" | undefined;
+    page?: number | undefined;
+    trigger_type?: "slack" | "schedule" | undefined;
+    id?: number | undefined;
+    include_channels?: boolean | undefined;
+}, {
+    per_page?: number | undefined;
+    status?: "enabled" | "disabled" | undefined;
+    page?: number | undefined;
+    trigger_type?: "slack" | "schedule" | undefined;
+    id?: number | undefined;
+    include_channels?: boolean | undefined;
+}>;
+export declare function searchTriggersTool(_server: Server, clientFactory: () => IAgentOrchestratorClient): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            id: {
+                type: string;
+                description: string;
+            };
+            trigger_type: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            status: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            include_channels: {
+                type: string;
+                description: string;
+            };
+            page: {
+                type: string;
+                minimum: number;
+                description: string;
+            };
+            per_page: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+        };
+        required: never[];
+    };
+    handler: (args: unknown) => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};
+//# sourceMappingURL=search-triggers.d.ts.map

package/shared/tools/search-triggers.js

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+export const SearchTriggersSchema = z.object({
+    id: z.number().optional(),
+    trigger_type: z.enum(['slack', 'schedule']).optional(),
+    status: z.enum(['enabled', 'disabled']).optional(),
+    include_channels: z.boolean().optional(),
+    page: z.number().min(1).optional(),
+    per_page: z.number().min(1).max(100).optional(),
+});
+const TOOL_DESCRIPTION = `Search and list automation triggers.
+
+**Modes:**
+- **Get by ID**: Provide an id to get trigger details with recent sessions
+- **List**: List triggers with optional filters (trigger_type, status, pagination)
+- **Include channels**: Set include_channels=true to also list available Slack channels (useful when creating Slack triggers)
+
+**Use cases:**
+- View configured automations (scheduled tasks, Slack integrations)
+- Check trigger status and execution history
+- Discover available Slack channels for new triggers`;
+export function searchTriggersTool(_server, clientFactory) {
+    return {
+        name: 'search_triggers',
+        description: TOOL_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'number',
+                    description: 'Get a specific trigger by ID. Returns trigger details with recent sessions.',
+                },
+                trigger_type: {
+                    type: 'string',
+                    enum: ['slack', 'schedule'],
+                    description: 'Filter by trigger type.',
+                },
+                status: {
+                    type: 'string',
+                    enum: ['enabled', 'disabled'],
+                    description: 'Filter by status.',
+                },
+                include_channels: {
+                    type: 'boolean',
+                    description: 'Include available Slack channels. Default: false',
+                },
+                page: { type: 'number', minimum: 1, description: 'Page number. Default: 1' },
+                per_page: {
+                    type: 'number',
+                    minimum: 1,
+                    maximum: 100,
+                    description: 'Results per page. Default: 25',
+                },
+            },
+            required: [],
+        },
+        handler: async (args) => {
+            try {
+                const validated = SearchTriggersSchema.parse(args);
+                const client = clientFactory();
+                if (validated.id) {
+                    const response = await client.getTrigger(validated.id);
+                    const t = response.trigger;
+                    const lines = [
+                        `## Trigger: ${t.name}`,
+                        '',
+                        `- **ID:** ${t.id}`,
+                        `- **Type:** ${t.trigger_type}`,
+                        `- **Status:** ${t.status}`,
+                        `- **Agent Root:** ${t.agent_root_name}`,
+                        `- **Reuse Session:** ${t.reuse_session ? 'Yes' : 'No'}`,
+                        `- **MCP Servers:** ${t.mcp_servers.length > 0 ? t.mcp_servers.join(', ') : '(none)'}`,
+                    ];
+                    if (t.stop_condition)
+                        lines.push(`- **Stop Condition:** ${t.stop_condition}`);
+                    if (t.schedule_description)
+                        lines.push(`- **Schedule:** ${t.schedule_description}`);
+                    lines.push(`- **Sessions Created:** ${t.sessions_created_count}`);
+                    if (t.last_triggered_at)
+                        lines.push(`- **Last Triggered:** ${t.last_triggered_at}`);
+                    lines.push('', '### Prompt Template', '```', t.prompt_template, '```');
+                    if (t.configuration && Object.keys(t.configuration).length > 0) {
+                        lines.push('', '### Configuration', '```json', JSON.stringify(t.configuration, null, 2), '```');
+                    }
+                    if (response.recent_sessions && response.recent_sessions.length > 0) {
+                        lines.push('', '### Recent Sessions');
+                        response.recent_sessions.forEach((s) => {
+                            lines.push(`- **#${s.id}** ${s.title} (${s.status})`);
+                        });
+                    }
+                    return { content: [{ type: 'text', text: lines.join('\n') }] };
+                }
+                // List triggers
+                const response = await client.listTriggers({
+                    trigger_type: validated.trigger_type,
+                    status: validated.status,
+                    page: validated.page,
+                    per_page: validated.per_page,
+                });
+                const lines = [];
+                if (response.triggers.length === 0) {
+                    lines.push('## Triggers\n\nNo triggers found.');
+                }
+                else {
+                    lines.push(`## Triggers (${response.pagination.total_count} total, page ${response.pagination.page} of ${response.pagination.total_pages})`, '');
+                    response.triggers.forEach((t) => {
+                        lines.push(`### ${t.name} (ID: ${t.id})`);
+                        lines.push(`- **Type:** ${t.trigger_type} | **Status:** ${t.status} | **Sessions:** ${t.sessions_created_count}`);
+                        if (t.schedule_description)
+                            lines.push(`- **Schedule:** ${t.schedule_description}`);
+                        lines.push('');
+                    });
+                }
+                if (validated.include_channels) {
+                    try {
+                        const channels = await client.getTriggerChannels();
+                        lines.push('', '## Available Slack Channels', '');
+                        if (channels.channels.length === 0) {
+                            lines.push('No Slack channels available.');
+                        }
+                        else {
+                            channels.channels.forEach((ch) => {
+                                lines.push(`- **#${ch.name}** (${ch.id}) - ${ch.num_members} members${ch.is_private ? ' [private]' : ''}`);
+                            });
+                        }
+                    }
+                    catch (error) {
+                        lines.push('', `*Could not fetch Slack channels: ${error instanceof Error ? error.message : 'Unknown error'}*`);
+                    }
+                }
+                return { content: [{ type: 'text', text: lines.join('\n') }] };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error searching triggers: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/shared/tools.d.ts

@@ -1,15 +1,13 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { ClientFactory } from './server.js';
 /**
- * Available tool groups for agent-orchestrator:
- * - 'readonly': Read-only operations (search_sessions, get_session)
- * - 'write': Write operations (start_session, action_session)
- * - 'admin': Administrative operations (reserved for future use)
+ * Available tool groups for agent-orchestrator.
+ * Each domain has a base group (full access) and a _readonly variant (read-only).
  */
-export type ToolGroup = 'readonly' | 'write' | 'admin';
+export type ToolGroup = 'sessions' | 'sessions_readonly' | 'notifications' | 'notifications_readonly' | 'triggers' | 'triggers_readonly' | 'health' | 'health_readonly';
 /**
- * Parse enabled tool groups from environment variable.
- * @param enabledGroupsParam - Comma-separated list of groups (e.g., "readonly,write")
+ * Parse enabled tool groups from environment variable or parameter.
+ * @param enabledGroupsParam - Comma-separated list of groups (e.g., "sessions,notifications")
  * @returns Array of enabled tool groups
  */
 export declare function parseEnabledToolGroups(enabledGroupsParam?: string): ToolGroup[];
@@ -21,9 +19,9 @@ export declare function parseEnabledToolGroups(enabledGroupsParam?: string): Too
  * a factory pattern that accepts the server and clientFactory as parameters.
  *
  * @param clientFactory - Factory function that creates client instances
- * @param enabledGroups - Optional array of enabled tool groups (defaults to all)
+ * @param enabledGroups - Optional string of enabled tool groups (defaults to all)
  * @returns Function that registers all tools with a server
  */
-export declare function createRegisterTools(clientFactory: ClientFactory, enabledGroups?: ToolGroup[]): (server: Server) => void;
+export declare function createRegisterTools(clientFactory: ClientFactory, enabledGroups?: string): (server: Server) => void;
 export declare function registerTools(server: Server): void;
 //# sourceMappingURL=tools.d.ts.map