agent-orchestrator-mcp-server 0.7.6 → 0.7.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-orchestrator-mcp-server",
-  "version": "0.7.6",
+  "version": "0.7.10",
   "description": "Local implementation of agent-orchestrator MCP server",
   "main": "build/index.js",
   "type": "module",
@@ -29,7 +29,7 @@
     "stage-publish": "npm version"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^3.24.1"
   },
   "devDependencies": {

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

@@ -241,8 +241,8 @@ export function createIntegrationMockOrchestratorClient(initialMockData) {
             if (!session) {
                 throw new Error(`API Error (404): Session not found`);
             }
-            if (session.status !== 'needs_input') {
-                throw new Error(`API Error (422): Session must be in needs_input state to sleep`);
+            if (session.status !== 'needs_input' && session.status !== 'running') {
+                throw new Error(`API Error (422): Session must be in needs_input or running state to sleep (current: ${session.status})`);
             }
             session.status = 'waiting';
             session.updated_at = new Date().toISOString();
@@ -633,7 +633,7 @@ export function createIntegrationMockOrchestratorClient(initialMockData) {
             return {
                 id: 1,
                 name: data.name,
-                trigger_type: data.trigger_type,
+                trigger_type: data.trigger_type || 'schedule',
                 status: data.status || 'enabled',
                 agent_root_name: data.agent_root_name,
                 prompt_template: data.prompt_template,
@@ -642,7 +642,7 @@ export function createIntegrationMockOrchestratorClient(initialMockData) {
                 mcp_servers: data.mcp_servers || [],
                 configuration: data.configuration || {},
                 schedule_description: null,
-                last_session_id: null,
+                last_session_id: data.last_session_id ?? null,
                 last_triggered_at: null,
                 last_polled_at: null,
                 sessions_created_count: 0,

package/shared/tools/wake-me-up-later.d.ts

@@ -17,6 +17,7 @@ export declare const WakeMeUpLaterSchema: z.ZodObject<{
     wake_at: string;
     timezone?: string | undefined;
 }>;
+export declare function parseWakeAtToUtcMs(wakeAt: string, timezone: string): number;
 export declare function wakeMeUpLaterTool(_server: Server, clientFactory: () => IAgentOrchestratorClient): {
     name: string;
     description: string;

package/shared/tools/wake-me-up-later.js

@@ -6,6 +6,70 @@ export const WakeMeUpLaterSchema = z.object({
     timezone: z.string().optional(),
     prompt: z.string(),
 });
+// Reject wake-ups that resolve to ≤30 seconds in the future. Anything inside
+// this window is effectively "now" given network latency between this tool
+// call and the trigger being scheduled — and the past-dated case (the bug
+// this guards against) silently fires-and-drops, leaving the session
+// permanently asleep.
+const WAKE_AT_GRACE_WINDOW_MS = 30 * 1000;
+function getTimezoneOffsetMs(date, timeZone) {
+    const parts = new Intl.DateTimeFormat('en-US', {
+        timeZone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+    }).formatToParts(date);
+    const filled = {};
+    for (const part of parts) {
+        if (part.type !== 'literal')
+            filled[part.type] = part.value;
+    }
+    // hour12: false can emit "24" at midnight in some locales — normalize.
+    const hour = parseInt(filled.hour, 10) % 24;
+    const asIfUtc = Date.UTC(parseInt(filled.year, 10), parseInt(filled.month, 10) - 1, parseInt(filled.day, 10), hour, parseInt(filled.minute, 10), parseInt(filled.second, 10));
+    // Sub-second precision is dropped by Date.UTC, so the offset can be off by
+    // up to ~1s when the input has fractional seconds. That's well inside the
+    // 30s grace window, so it doesn't affect validation.
+    return asIfUtc - date.getTime();
+}
+// Reject inputs that don't look like a calendar+time: bare dates ("2026-04-15"),
+// trailing offsets ("...+05:00"), and `Z` paired with a non-UTC IANA timezone
+// (ambiguous — we'd have to pick one to honor and the other to ignore).
+const NAIVE_DATETIME_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?Z?$/;
+const EXPLICIT_OFFSET_REGEX = /[+-]\d{2}:?\d{2}$/;
+// Convert a naive ISO-8601 wall-clock string in `timezone` to a UTC epoch ms.
+// Iterates twice so DST-boundary inputs converge on the correct offset.
+export function parseWakeAtToUtcMs(wakeAt, timezone) {
+    if (EXPLICIT_OFFSET_REGEX.test(wakeAt)) {
+        throw new Error(`wake_at must not include a UTC offset (e.g., "+05:00"); pass the wall-clock time and an IANA timezone name (e.g., "America/New_York")`);
+    }
+    if (!NAIVE_DATETIME_REGEX.test(wakeAt)) {
+        throw new Error(`wake_at must be an ISO-8601 datetime like "2026-04-15T14:30:00" (date-only and other formats are not accepted)`);
+    }
+    const hasZ = wakeAt.endsWith('Z');
+    const isUtc = timezone === 'UTC' || timezone === 'Etc/UTC';
+    if (hasZ && !isUtc) {
+        throw new Error(`wake_at ends with "Z" (UTC) but timezone is "${timezone}". Either drop the trailing "Z" or set timezone to "UTC"`);
+    }
+    const naive = hasZ ? wakeAt.slice(0, -1) : wakeAt;
+    const naiveAsUtc = new Date(naive + 'Z').getTime();
+    if (Number.isNaN(naiveAsUtc)) {
+        throw new Error(`Invalid wake_at value: "${wakeAt}"`);
+    }
+    if (isUtc) {
+        return naiveAsUtc;
+    }
+    let utcGuess = naiveAsUtc - getTimezoneOffsetMs(new Date(naiveAsUtc), timezone);
+    utcGuess = naiveAsUtc - getTimezoneOffsetMs(new Date(utcGuess), timezone);
+    return utcGuess;
+}
+function formatUtcInstant(ms) {
+    return new Date(ms).toISOString().replace(/\.\d{3}Z$/, 'Z');
+}
 function buildToolDescription() {
     const now = new Date();
     const utcNow = now.toISOString().replace(/\.\d{3}Z$/, 'Z');
@@ -16,7 +80,7 @@ function buildToolDescription() {
 - **Claude Code \`ScheduleWakeup\` tool**: Does not integrate with AO's session lifecycle — it won't transition the session to sleeping/waiting state or create an AO trigger, so AO cannot track or manage the wake-up.
 - **Claude Code \`Monitor\` tool**: Same problem — it operates outside AO's session state management.
 
-This tool does both: it properly transitions the session to sleeping (waiting) state so AO can reclaim resources, AND creates a one-time AO trigger to resume the session at the specified time.
+This tool creates a one-time AO wake-up trigger bound to the target session. The AO API atomically transitions the session to sleeping (waiting) state as part of creating the trigger, so AO can reclaim resources and the trigger is guaranteed to resume the correct session at the specified time.
 
 **Current server time:** ${utcNow} (UTC). Use this as your reference point when calculating wake-up times.
 
@@ -28,16 +92,15 @@ This tool does both: it properly transitions the session to sleeping (waiting) s
 - If you omit timezone, wake_at is treated as UTC.
 
 **Parameters:**
-- **session_id**: The session to wake up (must be in needs_input state)
+- **session_id**: The session to wake up. Works from either \`needs_input\` or \`running\` state — if you call this tool from within your own currently-running session, the sleep transition is recorded and takes effect after the current turn ends.
 - **wake_at**: ISO 8601 datetime without offset for when to wake up (e.g., "2026-04-15T14:30:00")
 - **timezone**: IANA timezone for interpreting wake_at (default: "UTC", e.g., "America/New_York")
 - **prompt**: The prompt to send when waking up the session
 
 **What happens:**
-1. Validates the session is in needs_input state
-2. Puts the session to sleep (waiting status)
-3. Creates a one-time schedule trigger that fires at the specified time
-4. The trigger resumes the session with the provided prompt`;
+1. Creates a one-time schedule trigger bound to this session that fires at the specified time.
+2. As a side effect of creating the trigger, the AO API transitions the session to sleeping (waiting) status — immediately if currently \`needs_input\`, or after the current turn ends if currently \`running\`.
+3. At the scheduled time, the trigger resumes the session with the provided prompt.`;
 }
 export function wakeMeUpLaterTool(_server, clientFactory) {
     return {
@@ -48,7 +111,7 @@ export function wakeMeUpLaterTool(_server, clientFactory) {
             properties: {
                 session_id: {
                     oneOf: [{ type: 'string' }, { type: 'number' }],
-                    description: 'Session ID (numeric) or slug (string). Must be in needs_input state.',
+                    description: 'Session ID (numeric) or slug (string). Accepts sessions in needs_input or running state — from a running session, the sleep takes effect after the current turn ends.',
                 },
                 wake_at: {
                     type: 'string',
@@ -68,9 +131,42 @@ export function wakeMeUpLaterTool(_server, clientFactory) {
         handler: async (args) => {
             try {
                 const validated = WakeMeUpLaterSchema.parse(args);
-                const client = clientFactory();
                 const { session_id, wake_at, prompt } = validated;
                 const timezone = validated.timezone || 'UTC';
+                // Cheapest validation runs first (no DB/API calls). Past-dated
+                // wake_at values silently fire-and-drop in the scheduler and leave
+                // the session permanently asleep, so reject up front before any
+                // state change.
+                let wakeAtUtcMs;
+                try {
+                    wakeAtUtcMs = parseWakeAtToUtcMs(wake_at, timezone);
+                }
+                catch (parseError) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Error: Could not parse wake_at "${wake_at}" with timezone "${timezone}": ${parseError instanceof Error ? parseError.message : 'Unknown error'}. No trigger was created and no session state was changed.`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const nowMs = Date.now();
+                if (wakeAtUtcMs - nowMs <= WAKE_AT_GRACE_WINDOW_MS) {
+                    const wakeAtUtcStr = formatUtcInstant(wakeAtUtcMs);
+                    const nowUtcStr = formatUtcInstant(nowMs);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Error: wake_at "${wake_at}" (timezone: ${timezone}) resolves to ${wakeAtUtcStr} UTC, which is in the past or within 30 seconds of the current server time (${nowUtcStr} UTC). No trigger was created and no session state was changed. Recompute relative to the current server time shown in the tool description and call again — wake_at must be more than 30 seconds in the future.`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const client = clientFactory();
                 if (parseAllowedAgentRoots() !== null) {
                     return {
                         content: [
@@ -83,30 +179,49 @@ export function wakeMeUpLaterTool(_server, clientFactory) {
                     };
                 }
                 const session = await client.getSession(session_id);
-                if (session.status !== 'needs_input') {
+                // Reject states the Rails API can't auto-sleep from. `needs_input` →
+                // immediate sleep; `running` → deferred sleep via pending_sleep metadata;
+                // `waiting` → already dormant, trigger fires normally. Anything else
+                // (failed, archived) would silently no-op the auto-sleep and leave the
+                // caller with a trigger targeting a session that can't be woken.
+                const WAKEABLE_STATUSES = ['needs_input', 'running', 'waiting'];
+                if (!WAKEABLE_STATUSES.includes(session.status)) {
                     return {
                         content: [
                             {
                                 type: 'text',
-                                text: `Error: Session must be in "needs_input" state to sleep (current: "${session.status}"). Only idle sessions can be scheduled for a delayed wake-up.`,
+                                text: `Error: Session ${session.id} is in "${session.status}" state and cannot be scheduled for wake-up. Only sessions in ${WAKEABLE_STATUSES.join(', ')} can be woken up.`,
                             },
                         ],
                         isError: true,
                     };
                 }
-                const sleepingSession = await client.sleepSession(session_id);
+                // The Rails Trigger model requires agent_root_name, but for per-session
+                // wake-up triggers (reuse_session + last_session_id + one-time schedule)
+                // the value is never used to spawn a session — the target session is
+                // always reused. Prefer the canonical metadata value. The agent_type
+                // fallback is a best-effort for pre-migration sessions without an
+                // agent_root_key; if agent_type isn't a registered agent root, the
+                // createTrigger call will fail loudly with a 422 rather than proceed
+                // with a bad value — which is what we want.
+                const agentRootName = session.metadata?.agent_root_key || session.agent_type;
                 let trigger;
                 try {
                     trigger = await client.createTrigger({
-                        name: `Wake session #${sleepingSession.id} at ${wake_at}`,
-                        trigger_type: 'schedule',
-                        agent_root_name: session.agent_type,
+                        name: `Wake session #${session.id} at ${wake_at}`,
+                        agent_root_name: agentRootName,
                         prompt_template: prompt,
                         reuse_session: true,
-                        configuration: {
-                            scheduled_at: wake_at,
-                            timezone,
-                        },
+                        last_session_id: session.id,
+                        trigger_conditions_attributes: [
+                            {
+                                condition_type: 'schedule',
+                                configuration: {
+                                    scheduled_at: wake_at,
+                                    timezone,
+                                },
+                            },
+                        ],
                     });
                 }
                 catch (triggerError) {
@@ -114,28 +229,21 @@ export function wakeMeUpLaterTool(_server, clientFactory) {
                         content: [
                             {
                                 type: 'text',
-                                text: `Error: Session ${sleepingSession.id} was put to sleep (waiting status) but trigger creation failed: ${triggerError instanceof Error ? triggerError.message : 'Unknown error'}. The session is now in "waiting" state and needs manual intervention (use action_session with "restart" or "follow_up" to recover).`,
+                                text: `Error: Trigger creation failed: ${triggerError instanceof Error ? triggerError.message : 'Unknown error'}. The session is still in its original state — no changes were made.`,
                             },
                         ],
                         isError: true,
                     };
                 }
-                await client.updateSession(session_id, {
-                    custom_metadata: {
-                        ...session.custom_metadata,
-                        wake_trigger_id: trigger.id,
-                    },
-                });
                 const lines = [
                     '## Wake-Up Scheduled Successfully',
                     '',
-                    `- **Session ID:** ${sleepingSession.id}`,
-                    `- **Session Status:** ${sleepingSession.status}`,
+                    `- **Session ID:** ${session.id}`,
                     `- **Wake At:** ${wake_at} (${timezone})`,
                     `- **Trigger ID:** ${trigger.id}`,
                     `- **Trigger Name:** ${trigger.name}`,
                     '',
-                    '**You must end your conversation turn now.** The session is sleeping and will be automatically resumed at the scheduled time with the provided prompt.',
+                    '**You must end your conversation turn now.** The session will be automatically transitioned to waiting (immediately if currently needs_input; after the current turn ends if currently running) and resumed at the scheduled time with the provided prompt.',
                     '',
                     '⚠️ **Warning:** If you do not end your conversation turn, the session may still be running when the scheduled wake-up fires. A wake-up cannot be delivered to a session that is not in a wakeable (sleeping/waiting) state — it will be silently dropped, and you will never receive it.',
                 ];

package/shared/types.d.ts

@@ -251,9 +251,13 @@ export interface TriggerChannelsResponse {
         num_members: number;
     }>;
 }
+export interface TriggerConditionAttributes {
+    condition_type: 'slack' | 'schedule' | 'ao_event';
+    configuration: Record<string, unknown>;
+}
 export interface CreateTriggerRequest {
     name: string;
-    trigger_type: TriggerType;
+    trigger_type?: TriggerType;
     agent_root_name: string;
     prompt_template: string;
     status?: TriggerStatus;
@@ -261,6 +265,8 @@ export interface CreateTriggerRequest {
     reuse_session?: boolean;
     mcp_servers?: string[];
     configuration?: Record<string, unknown>;
+    last_session_id?: number;
+    trigger_conditions_attributes?: TriggerConditionAttributes[];
 }
 export interface UpdateTriggerRequest {
     name?: string;