instar 0.28.1 → 0.28.2

package/dist/server/routes.js

@@ -7124,6 +7124,28 @@ export function createRoutes(ctx) {
             }
             const accepted = await ctx.messageRouter.relay(envelope, 'agent');
             if (accepted) {
+                const senderAgent = envelope.message?.from?.agent;
+                console.log(`[relay-agent] Accepted message from ${senderAgent ?? 'unknown'} (thread: ${envelope.message?.threadId ?? 'none'}, id: ${envelope.message?.id ?? 'none'})`);
+                // Check if this message resolves a pending waitForReply request.
+                // Local delivery bypasses the relay client's gate-passed event, so we
+                // must check reply waiters here directly.
+                if (senderAgent && ctx.threadlineReplyWaiters.size > 0) {
+                    let textContent;
+                    const body = envelope.message?.body;
+                    if (typeof body === 'string')
+                        textContent = body;
+                    else if (typeof body === 'object' && body !== null) {
+                        textContent = String(body.content ?? body.text ?? JSON.stringify(body));
+                    }
+                    if (textContent) {
+                        const isAutoAck = textContent.startsWith('Message received.') || textContent.startsWith('Message received,');
+                        const waiter = ctx.threadlineReplyWaiters.get(senderAgent);
+                        if (waiter && !isAutoAck) {
+                            console.log(`[relay-agent] Resolved reply waiter for ${senderAgent}`);
+                            waiter.resolve(textContent);
+                        }
+                    }
+                }
                 // If the message has a threadId and we have a ThreadlineRouter,
                 // route it through the threadline pipeline for session resume/spawn.
                 if (ctx.threadlineRouter && envelope.message?.threadId) {
@@ -7584,6 +7606,27 @@ export function createRoutes(ctx) {
             },
         });
     });
+    // ── Threadline Reply Waiter ─────────────────────────────────────────
+    // Waits for an incoming reply from a specific agent on a specific thread.
+    // Used by the relay-send endpoint when waitForReply is true.
+    function waitForThreadlineReply(routeCtx, senderAgent, _threadId, timeoutSec) {
+        const timeout = Math.min(Math.max(timeoutSec ?? 120, 5), 300) * 1000; // 5s–300s, default 120s
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                routeCtx.threadlineReplyWaiters.delete(senderAgent);
+                resolve(null);
+            }, timeout);
+            routeCtx.threadlineReplyWaiters.set(senderAgent, {
+                resolve: (reply) => {
+                    clearTimeout(timer);
+                    routeCtx.threadlineReplyWaiters.delete(senderAgent);
+                    resolve(reply);
+                },
+                threadId: _threadId,
+                timer,
+            });
+        });
+    }
     // ── Threadline Relay Send ────────────────────────────────────────────
     // Used by the MCP server's threadline_send tool to route messages through
     // the relay WebSocket. Tries local delivery first for co-located agents,
@@ -7592,7 +7635,7 @@ export function createRoutes(ctx) {
     // HTTP endpoint.
     router.post('/threadline/relay-send', async (req, res) => {
         const relayClient = ctx.threadlineRelayClient;
-        const { targetAgent, message, threadId } = req.body;
+        const { targetAgent, message, threadId, waitForReply, timeoutSeconds } = req.body;
         if (!targetAgent || !message) {
             res.status(400).json({ success: false, error: 'Missing required fields: targetAgent, message' });
             return;
@@ -7673,13 +7716,26 @@ export function createRoutes(ctx) {
                                 });
                                 if (localResp.ok) {
                                     console.log(`[relay-send] Local delivery to ${localTarget.name}:${localTarget.port} (thread: ${effectiveThreadId})`);
-                                    res.json({
-                                        success: true,
-                                        messageId: msgId,
-                                        threadId: effectiveThreadId,
-                                        resolvedAgent: localTarget.name,
-                                        deliveryPath: 'local',
-                                    });
+                                    if (waitForReply) {
+                                        const reply = await waitForThreadlineReply(ctx, localTarget.name, effectiveThreadId, timeoutSeconds);
+                                        res.json({
+                                            success: true,
+                                            messageId: msgId,
+                                            threadId: effectiveThreadId,
+                                            resolvedAgent: localTarget.name,
+                                            deliveryPath: 'local',
+                                            reply,
+                                        });
+                                    }
+                                    else {
+                                        res.json({
+                                            success: true,
+                                            messageId: msgId,
+                                            threadId: effectiveThreadId,
+                                            resolvedAgent: localTarget.name,
+                                            deliveryPath: 'local',
+                                        });
+                                    }
                                     return;
                                 }
                                 // Local delivery failed — fall through to relay
@@ -7712,13 +7768,27 @@ export function createRoutes(ctx) {
                 return;
             }
             const relayMsgId = relayClient.sendAuto(resolvedId, message, threadId);
-            res.json({
-                success: true,
-                messageId: relayMsgId,
-                threadId: threadId ?? relayMsgId,
-                resolvedAgent: resolvedId,
-                deliveryPath: 'relay',
-            });
+            const effectiveRelayThreadId = threadId ?? relayMsgId;
+            if (waitForReply) {
+                const reply = await waitForThreadlineReply(ctx, resolvedId, effectiveRelayThreadId, timeoutSeconds);
+                res.json({
+                    success: true,
+                    messageId: relayMsgId,
+                    threadId: effectiveRelayThreadId,
+                    resolvedAgent: resolvedId,
+                    deliveryPath: 'relay',
+                    reply,
+                });
+            }
+            else {
+                res.json({
+                    success: true,
+                    messageId: relayMsgId,
+                    threadId: effectiveRelayThreadId,
+                    resolvedAgent: resolvedId,
+                    deliveryPath: 'relay',
+                });
+            }
         }
         catch (err) {
             res.status(500).json({