feat: add sessions_spawn sub-agent tool

src/agents/tools/sessions-send-tool.ts

@@ -4,8 +4,10 @@ import { Type } from "@sinclair/typebox";
 
 import { loadConfig } from "../../config/config.js";
 import { callGateway } from "../../gateway/call.js";
+import { readLatestAssistantReply, runAgentStep } from "./agent-step.js";
 import type { AnyAgentTool } from "./common.js";
 import { jsonResult, readStringParam } from "./common.js";
+import { resolveAnnounceTarget } from "./sessions-announce-target.js";
 import {
   extractAssistantText,
   resolveDisplaySessionKey,
@@ -14,13 +16,11 @@ import {
   stripToolMessages,
 } from "./sessions-helpers.js";
 import {
-  type AnnounceTarget,
   buildAgentToAgentAnnounceContext,
   buildAgentToAgentMessageContext,
   buildAgentToAgentReplyContext,
   isAnnounceSkip,
   isReplySkip,
-  resolveAnnounceTargetFromKey,
   resolvePingPongTurns,
 } from "./sessions-send-helpers.js";
 
@@ -83,87 +83,6 @@ export function createSessionsSendTool(opts?: {
       const requesterSurface = opts?.agentSurface;
       const maxPingPongTurns = resolvePingPongTurns(cfg);
 
-      const resolveAnnounceTarget =
-        async (): Promise<AnnounceTarget | null> => {
-          const parsed = resolveAnnounceTargetFromKey(resolvedKey);
-          if (parsed) return parsed;
-          try {
-            const list = (await callGateway({
-              method: "sessions.list",
-              params: {
-                includeGlobal: true,
-                includeUnknown: true,
-                limit: 200,
-              },
-            })) as { sessions?: Array<Record<string, unknown>> };
-            const sessions = Array.isArray(list?.sessions) ? list.sessions : [];
-            const match =
-              sessions.find((entry) => entry?.key === resolvedKey) ??
-              sessions.find((entry) => entry?.key === displayKey);
-            const channel =
-              typeof match?.lastChannel === "string"
-                ? match.lastChannel
-                : undefined;
-            const to =
-              typeof match?.lastTo === "string" ? match.lastTo : undefined;
-            if (channel && to) return { channel, to };
-          } catch {
-            // ignore; fall through to null
-          }
-          return null;
-        };
-
-      const readLatestAssistantReply = async (
-        sessionKeyToRead: string,
-      ): Promise<string | undefined> => {
-        const history = (await callGateway({
-          method: "chat.history",
-          params: { sessionKey: sessionKeyToRead, limit: 50 },
-        })) as { messages?: unknown[] };
-        const filtered = stripToolMessages(
-          Array.isArray(history?.messages) ? history.messages : [],
-        );
-        const last =
-          filtered.length > 0 ? filtered[filtered.length - 1] : undefined;
-        return last ? extractAssistantText(last) : undefined;
-      };
-
-      const runAgentStep = async (step: {
-        sessionKey: string;
-        message: string;
-        extraSystemPrompt: string;
-        timeoutMs: number;
-      }): Promise<string | undefined> => {
-        const stepIdem = crypto.randomUUID();
-        const response = (await callGateway({
-          method: "agent",
-          params: {
-            message: step.message,
-            sessionKey: step.sessionKey,
-            idempotencyKey: stepIdem,
-            deliver: false,
-            lane: "nested",
-            extraSystemPrompt: step.extraSystemPrompt,
-          },
-          timeoutMs: 10_000,
-        })) as { runId?: string; acceptedAt?: number };
-        const stepRunId =
-          typeof response?.runId === "string" && response.runId
-            ? response.runId
-            : stepIdem;
-        const stepWaitMs = Math.min(step.timeoutMs, 60_000);
-        const wait = (await callGateway({
-          method: "agent.wait",
-          params: {
-            runId: stepRunId,
-            timeoutMs: stepWaitMs,
-          },
-          timeoutMs: stepWaitMs + 2000,
-        })) as { status?: string };
-        if (wait?.status !== "ok") return undefined;
-        return readLatestAssistantReply(step.sessionKey);
-      };
-
       const runAgentToAgentFlow = async (
         roundOneReply?: string,
         runInfo?: { runId: string },
@@ -182,12 +101,17 @@ export function createSessionsSendTool(opts?: {
               timeoutMs: waitMs + 2000,
             })) as { status?: string };
             if (wait?.status === "ok") {
-              primaryReply = await readLatestAssistantReply(resolvedKey);
+              primaryReply = await readLatestAssistantReply({
+                sessionKey: resolvedKey,
+              });
               latestReply = primaryReply;
             }
           }
           if (!latestReply) return;
-          const announceTarget = await resolveAnnounceTarget();
+          const announceTarget = await resolveAnnounceTarget({
+            sessionKey: resolvedKey,
+            displayKey,
+          });
           const targetChannel = announceTarget?.channel ?? "unknown";
           if (
             maxPingPongTurns > 0 &&
@@ -216,6 +140,7 @@ export function createSessionsSendTool(opts?: {
                 message: incomingMessage,
                 extraSystemPrompt: replyPrompt,
                 timeoutMs: announceTimeoutMs,
+                lane: "nested",
               });
               if (!replyText || isReplySkip(replyText)) {
                 break;
@@ -241,6 +166,7 @@ export function createSessionsSendTool(opts?: {
             message: "Agent-to-agent announce step.",
             extraSystemPrompt: announcePrompt,
             timeoutMs: announceTimeoutMs,
+            lane: "nested",
           });
           if (
             announceTarget &&