@syengup/friday-channel-next 0.0.34 → 0.0.37

package/src/agent/subagent-registry.ts

@@ -0,0 +1,195 @@
+export type SubagentStatus = "spawning" | "running" | "ended";
+
+export type SubagentOutcome = "ok" | "error" | "timeout" | "killed" | "reset" | "deleted";
+
+export type SubagentEntry = {
+  childSessionKey: string;
+  runId?: string;
+  parentRunId?: string;
+  deviceId: string;
+  label?: string;
+  depth: number;
+  status: SubagentStatus;
+  outcome?: SubagentOutcome;
+  error?: string;
+};
+
+export type SubagentMeta = {
+  label?: string;
+  parentRunId?: string;
+  depth: number;
+};
+
+type SpawnIntent = {
+  label?: string;
+  parentRunId: string;
+  deviceId: string;
+  depth: number;
+  requesterSessionKey?: string;
+};
+
+const byChildSessionKey = new Map<string, SubagentEntry>();
+const byRunId = new Map<string, SubagentEntry>();
+const byToolCallId = new Map<string, SpawnIntent>();
+const sessionKeyToRunId = new Map<string, string>();
+
+/** Called by forwardAgentEventRaw on lifecycle start so we can resolve parentRunId. */
+export function registerSessionKeyForRun(sessionKey: string, runId: string): void {
+  if (!sessionKey || !runId) return;
+  sessionKeyToRunId.set(sessionKey, runId);
+}
+
+function resolveRunIdForSessionKey(sessionKey: string): string | undefined {
+  return sessionKeyToRunId.get(sessionKey);
+}
+
+/**
+ * Parse OpenClaw announce compound runId:
+ *   announce:v<version>:<sessionKey>:<bareRunId>
+ * Example:
+ *   announce:v1:agent:main:subagent:uuid:runId
+ *   → { childSessionKey: "agent:main:subagent:uuid", bareRunId: "runId" }
+ */
+const ANNOUNCE_RUN_ID_RE = /^announce:v\d+:(agent:.+?):([^:]+)$/;
+
+function parseAnnounceRunId(runId: string): { childSessionKey: string; bareRunId: string } | null {
+  const m = runId.match(ANNOUNCE_RUN_ID_RE);
+  if (!m) return null;
+  return { childSessionKey: m[1] ?? "", bareRunId: m[2] ?? "" };
+}
+
+/** Look up subagent entry by any runId form (announce compound or bare). */
+export function lookupByRunId(runId: string): SubagentEntry | undefined {
+  const direct = byRunId.get(runId);
+  if (direct) return direct;
+  const parsed = parseAnnounceRunId(runId);
+  if (parsed) {
+    const byChild = byChildSessionKey.get(parsed.childSessionKey);
+    if (byChild) {
+      // Also register the compound runId for future fast lookup
+      byRunId.set(runId, byChild);
+      return byChild;
+    }
+    return byRunId.get(parsed.bareRunId);
+  }
+  return undefined;
+}
+
+/** Look up subagent entry by childSessionKey. */
+export function lookupByChildSessionKey(key: string): SubagentEntry | undefined {
+  return byChildSessionKey.get(key);
+}
+
+/**
+ * Called on sessions_spawn item.start (before tool execution).
+ * Stores the spawn intent so spawning SSE can be emitted immediately.
+ */
+export function registerSpawnIntent(params: {
+  toolCallId: string;
+  label?: string;
+  deviceId: string;
+  parentRunId: string;
+  requesterSessionKey?: string;
+}): SpawnIntent {
+  let depth = 1;
+  if (params.requesterSessionKey) {
+    const parent = byChildSessionKey.get(params.requesterSessionKey);
+    if (parent) depth = parent.depth + 1;
+  }
+  const intent: SpawnIntent = {
+    label: params.label,
+    parentRunId: params.parentRunId,
+    deviceId: params.deviceId.toUpperCase(),
+    depth,
+    requesterSessionKey: params.requesterSessionKey,
+  };
+  byToolCallId.set(params.toolCallId, intent);
+  return intent;
+}
+
+/** Consume a previously registered spawn intent. Returns undefined if none. */
+export function consumeSpawnIntent(toolCallId: string): SpawnIntent | undefined {
+  const intent = byToolCallId.get(toolCallId);
+  byToolCallId.delete(toolCallId);
+  return intent;
+}
+
+/**
+ * Called when forwardAgentEventRaw sees a sessions_spawn tool result.
+ * Extracts childSessionKey, runId, taskName and registers the subagent.
+ */
+export function ensureSubagentFromSpawnTool(params: {
+  childSessionKey: string;
+  bareRunId?: string;
+  label?: string;
+  deviceId: string;
+  parentRunId: string;
+  requesterSessionKey?: string;
+  depth?: number;
+}): SubagentEntry {
+  const existing = byChildSessionKey.get(params.childSessionKey);
+  if (existing) {
+    if (params.bareRunId && !existing.runId) {
+      existing.runId = params.bareRunId;
+      byRunId.set(params.bareRunId, existing);
+      sessionKeyToRunId.set(params.childSessionKey, params.bareRunId);
+    }
+    existing.status = "running";
+    return existing;
+  }
+
+  let depth = params.depth ?? 1;
+  if (depth <= 1 && params.requesterSessionKey) {
+    const parent = byChildSessionKey.get(params.requesterSessionKey);
+    if (parent) depth = parent.depth + 1;
+  }
+
+  const entry: SubagentEntry = {
+    childSessionKey: params.childSessionKey,
+    runId: params.bareRunId,
+    parentRunId: params.parentRunId,
+    deviceId: params.deviceId.toUpperCase(),
+    label: params.label || undefined,
+    depth,
+    status: "running",
+  };
+  byChildSessionKey.set(params.childSessionKey, entry);
+  if (params.bareRunId) {
+    byRunId.set(params.bareRunId, entry);
+    sessionKeyToRunId.set(params.childSessionKey, params.bareRunId);
+  }
+  return entry;
+}
+
+/** Mark subagent as ended. Resolves by bare/compound runId or childSessionKey. */
+export function registerEnded(params: {
+  runId?: string;
+  childSessionKey?: string;
+  outcome?: SubagentOutcome;
+  error?: string;
+}): SubagentEntry | undefined {
+  let entry: SubagentEntry | undefined;
+  if (params.runId) entry = lookupByRunId(params.runId);
+  if (!entry && params.childSessionKey) entry = byChildSessionKey.get(params.childSessionKey);
+  if (!entry) return undefined;
+  entry.status = "ended";
+  if (params.outcome) entry.outcome = params.outcome;
+  if (params.error) entry.error = params.error;
+  return entry;
+}
+
+/** Extract subagent metadata for SSE annotation. */
+export function subagentMeta(entry: SubagentEntry): SubagentMeta {
+  return {
+    label: entry.label,
+    parentRunId: entry.parentRunId,
+    depth: entry.depth,
+  };
+}
+
+export function resetForTest(): void {
+  byChildSessionKey.clear();
+  byRunId.clear();
+  byToolCallId.clear();
+  sessionKeyToRunId.clear();
+}

package/src/channel.ts

@@ -8,6 +8,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
+import { createFridayNextLogger } from "./logging.js";
 import type { ChannelAccountSnapshot } from "openclaw/plugin-sdk/status-helpers";
 import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { sseEmitter } from "./sse/emitter.js";
@@ -19,6 +20,7 @@ import {
 } from "./friday-session.js";
 import { getLastFridayInboundAt } from "./friday-inbound-stats.js";
 
+const logger = createFridayNextLogger("channel");
 const CHANNEL_ID = "friday-next" as const;
 
 function pickFirstString(source: Record<string, unknown>, keys: string[]): string | undefined {
@@ -156,8 +158,8 @@ export const fridayNextChannelPlugin = createChatChannelPlugin({
 
         const conn = sseEmitter.getConnection(deviceId);
         const ts = new Date().toISOString();
-        console.error(
-          `[Friday-OUT] [${ts}] [SEND_TEXT] to=${deviceId} runId=${runId ?? "(none)"} sessionKey=${sessionKey ?? "(none)"} textLen=${text.length} online=${!!conn}`,
+        logger.info(
+          `[SEND_TEXT] to=${deviceId} runId=${runId ?? "(none)"} sessionKey=${sessionKey ?? "(none)"} textLen=${text.length} online=${!!conn}`,
         );
 
         if (conn) {
@@ -243,8 +245,8 @@ export const fridayNextChannelPlugin = createChatChannelPlugin({
 
             const conn = sseEmitter.getConnection(deviceId);
             const ts = new Date().toISOString();
-            console.error(
-              `[Friday-OUT] [${ts}] [SEND_MEDIA] to=${deviceId} runId=${runId ?? "(none)"} sessionKey=${sessionKey ?? "(none)"} audioAsVoice=${audioAsVoice} url=${publicUrl} online=${!!conn}`,
+            logger.info(
+              `[SEND_MEDIA] to=${deviceId} runId=${runId ?? "(none)"} sessionKey=${sessionKey ?? "(none)"} audioAsVoice=${audioAsVoice} url=${publicUrl} online=${!!conn}`,
             );
 
             if (conn) {

package/src/e2e/subagent-smoke.e2e.test.ts

@@ -0,0 +1,223 @@
+/**
+ * Subagent SSE smoke test — simulates the Friday iOS app connecting and
+ * receiving a complete subagent lifecycle via sessions_spawn tool events.
+ *
+ * Run with:
+ *   pnpm vitest run --config vitest.e2e.config.ts src/e2e/subagent-smoke.e2e.test.ts --reporter verbose
+ */
+import { beforeEach, describe, expect, it } from "vitest";
+import { createAppSimulator } from "../test-support/app-simulator.js";
+import { createTempHistoryDir, setMockRuntime } from "../test-support/mock-runtime.js";
+import {
+  ensureSubagentFromSpawnTool,
+  resetForTest as resetSubagentRegistry,
+} from "../agent/subagent-registry.js";
+import {
+  forwardAgentEventRaw,
+  registerFridaySessionDeviceMapping,
+} from "../friday-session.js";
+import { sseEmitter } from "../sse/emitter.js";
+
+const deviceId = "IOS-DEVICE-AAAA-BBBB-CCCC-DDDD";
+const mainSessionKey = "agent:main:main";
+const mainRunId = "main-run-001";
+
+function spawnResult(childSessionKey: string, runId: string, taskName: string) {
+  return {
+    childSessionKey,
+    runId,
+    taskName,
+  };
+}
+
+function describeFrame(frame: { event?: string; data?: Record<string, unknown> }) {
+  const event = frame.event ?? "?";
+  const data = frame.data ?? {};
+  switch (event) {
+    case "connected":
+      return `connected  deviceId=${data.deviceId} lastSeq=${data.lastSeq}`;
+    case "subagent": {
+      const extra = data.phase === "ended" ? ` outcome=${data.outcome} error=${data.error ?? "-"}` : "";
+      return `subagent   phase=${data.phase} runId=${data.runId ?? "(pending)"} label=${data.label ?? "-"} parentRunId=${data.parentRunId ?? "-"} depth=${data.depth}${extra}`;
+    }
+    case "agent": {
+      const sub = data.subagent as Record<string, unknown> | undefined;
+      const subTag = sub ? ` SUB="agent:${sub.label ?? "?"}" depth=${sub.depth} parent=${sub.parentRunId ?? "-"}` : " (main)";
+      const inner = (data.data ?? {}) as Record<string, unknown>;
+      let detail = "";
+      if (data.stream === "thinking") detail = ` thinking: "${String(inner.text ?? "").slice(0, 50)}"`;
+      else if (data.stream === "tool") detail = ` tool=${inner.name ?? "?"} phase=${inner.phase}`;
+      else if (data.stream === "assistant") detail = ` text="${String(inner.text ?? inner.phase ?? "")}"`;
+      else if (data.stream === "lifecycle") detail = ` phase=${inner.phase}`;
+      return `agent      stream=${data.stream} runId=${String(data.runId).slice(0, 30)}…${subTag}${detail}`;
+    }
+    default:
+      return `${event}`;
+  }
+}
+
+describe("subagent smoke", () => {
+  let historyDir = "";
+
+  beforeEach(() => {
+    historyDir = createTempHistoryDir();
+    setMockRuntime({ historyDir, authToken: "smoke-token" });
+    resetSubagentRegistry();
+  });
+
+  it("full nested subagent lifecycle via sessions_spawn tool events", async () => {
+    const app = createAppSimulator({ token: "smoke-token", deviceId });
+    await app.connectSSE();
+    registerFridaySessionDeviceMapping(mainSessionKey, deviceId);
+
+    // ── Main run lifecycle start ──────────────────────────
+    forwardAgentEventRaw({
+      runId: mainRunId, seq: 1, stream: "lifecycle",
+      sessionKey: mainSessionKey, data: { phase: "start" },
+    });
+
+    // ── Subagent A: tool.start (spawning) ─────────────────
+    const childKeyA = "agent:main:subagent:code-reviewer";
+    const bareA = "bare-run-reviewer";
+    const compoundA = `announce:v1:${childKeyA}:${bareA}`;
+
+    forwardAgentEventRaw({
+      runId: mainRunId, seq: 2, stream: "tool",
+      sessionKey: mainSessionKey,
+      data: {
+        phase: "start", name: "sessions_spawn",
+        toolCallId: "call_a",
+        args: { taskName: "code-reviewer" },
+      },
+    });
+
+    // ── Subagent A: tool.result (spawned) ─────────────────
+    forwardAgentEventRaw({
+      runId: mainRunId, seq: 3, stream: "tool",
+      sessionKey: mainSessionKey,
+      data: {
+        phase: "result", name: "sessions_spawn", toolCallId: "call_1",
+        meta: "code-reviewer",
+        result: { details: spawnResult(childKeyA, bareA, "code-reviewer") },
+      },
+    });
+    sseEmitter.trackDeviceForRun(deviceId, compoundA);
+
+    // ── Subagent A: agent events (subagent's own sessionKey) ─
+    forwardAgentEventRaw({
+      runId: compoundA, seq: 1, stream: "lifecycle",
+      data: { phase: "start" }, sessionKey: childKeyA,
+    });
+    forwardAgentEventRaw({
+      runId: compoundA, seq: 2, stream: "thinking",
+      data: { text: "Let me review the code for issues…", delta: "Let me review the code for issues…", reasoningPrefixChars: 0 },
+      sessionKey: childKeyA,
+    });
+    forwardAgentEventRaw({
+      runId: compoundA, seq: 3, stream: "tool",
+      data: { phase: "start", name: "read", args: { path: "src/app.ts" } },
+      sessionKey: childKeyA,
+    });
+    forwardAgentEventRaw({
+      runId: compoundA, seq: 4, stream: "tool",
+      data: { phase: "result", name: "read", result: "file contents…" },
+      sessionKey: childKeyA,
+    });
+    forwardAgentEventRaw({
+      runId: compoundA, seq: 5, stream: "assistant",
+      data: { phase: "delta", text: "Found 3 issues in the code." },
+      sessionKey: childKeyA,
+    });
+
+    // ── Nested: Subagent B spawning + spawned ────────────
+    const childKeyB = "agent:main:subagent:lint";
+    const bareB = "bare-run-lint";
+    const compoundB = `announce:v1:${childKeyB}:${bareB}`;
+
+    forwardAgentEventRaw({
+      runId: compoundA, seq: 7, stream: "tool",
+      sessionKey: mainSessionKey,
+      data: {
+        phase: "start", name: "sessions_spawn",
+        toolCallId: "call_b",
+        args: { taskName: "lint" },
+      },
+    });
+
+    forwardAgentEventRaw({
+      runId: compoundA, seq: 8, stream: "tool",
+      sessionKey: mainSessionKey,
+      data: {
+        phase: "result", name: "sessions_spawn", toolCallId: "call_2",
+        meta: "lint",
+        result: { details: spawnResult(childKeyB, bareB, "lint") },
+      },
+    });
+    sseEmitter.trackDeviceForRun(deviceId, compoundB);
+
+    // ── Subagent B: agent event (subagent's own sessionKey) ─
+    forwardAgentEventRaw({
+      runId: compoundB, seq: 1, stream: "assistant",
+      data: { phase: "delta", text: "No lint errors found." },
+      sessionKey: childKeyB,
+    });
+
+    // ── Subagent B ended (subagent's own sessionKey) ──────
+    forwardAgentEventRaw({
+      runId: compoundB, seq: 2, stream: "lifecycle",
+      data: { phase: "end" },
+      sessionKey: childKeyB,
+    });
+
+    // ── Subagent A ended (subagent's own sessionKey) ──────
+    forwardAgentEventRaw({
+      runId: compoundA, seq: 7, stream: "lifecycle",
+      data: { phase: "end" },
+      sessionKey: childKeyA,
+    });
+
+    // Wait for SSE flush
+    await new Promise((r) => setTimeout(r, 50));
+    const frames = app.getSseFrames();
+
+    // ── Verbose output ──────────────────────────────────
+    console.log("\n══════════════════════════════════════════════════════");
+    console.log("  SSE Frames (as received by the iOS app)");
+    console.log("══════════════════════════════════════════════════════\n");
+    for (const frame of frames) {
+      console.log(`[${String(frame.id ?? "-").padStart(3)}] ${describeFrame(frame)}`);
+    }
+    console.log("\n══════════════════════════════════════════════════════");
+    const subagentCount = frames.filter((f) => f.event === "subagent").length;
+    const annotatedCount = frames.filter(
+      (f) => f.event === "agent" && f.data?.subagent != null,
+    ).length;
+    console.log(`  Totals: ${frames.length} frames`);
+    console.log(`    subagent lifecycle events: ${subagentCount}`);
+    console.log(`    agent events with subagent annotation: ${annotatedCount}`);
+    console.log("══════════════════════════════════════════════════════\n");
+
+    // ── Assertions ──────────────────────────────────────
+    expect(subagentCount).toBeGreaterThanOrEqual(6); // 2 spawning + 2 spawned + 2 ended
+    expect(annotatedCount).toBeGreaterThanOrEqual(5);
+
+    // Verify subagent phases
+    const subagentFrames = frames.filter((f) => f.event === "subagent");
+    const phases = subagentFrames.map((f) => f.data?.phase);
+    expect(phases.filter((p) => p === "spawning")).toHaveLength(2);
+    expect(phases.filter((p) => p === "spawned")).toHaveLength(2);
+    expect(phases.filter((p) => p === "ended")).toHaveLength(2);
+
+    // Verify annotation only on subagent events
+    for (const f of frames) {
+      if (f.event !== "agent") continue;
+      const hasSub = f.data?.subagent != null;
+      const runId = f.data?.runId as string | undefined;
+      if (runId === mainRunId) {
+        expect(hasSub, `main agent annotated: ${describeFrame(f)}`).toBe(false);
+      }
+    }
+
+    app.disconnectSSE();
+  });
+});