@desplega.ai/agent-swarm 1.171.0 → 1.172.0

package/dist/cli-bf7485pm.js

@@ -0,0 +1,514 @@
+import {
+  summarizeSession
+} from "./cli-cf69s3ew.js";
+import {
+  checkToolLoop,
+  clearToolHistory
+} from "./cli-hp1n6zq3.js";
+import {
+  buildRatingsFromLlm,
+  fetchRetrievalsForTask,
+  getMemoryRaterNames,
+  postRatings
+} from "./cli-104zsxba.js";
+import {
+  init_resolver,
+  init_session_templates,
+  resolveTemplateAsync,
+  resolveTemplateFromCode
+} from "./cli-fdvbjtbw.js";
+import {
+  getOpenRouterAttributionHeaders,
+  init_openrouter_base_url
+} from "./cli-a35hzdve.js";
+import {
+  init_secret_scrubber,
+  scrubSecrets
+} from "./cli-d161g69q.js";
+
+// src/prompts/goal-reminder.ts
+init_session_templates();
+init_resolver();
+var GOAL_REMINDER_TEMPLATE = "system.agent.compaction.goal_reminder";
+async function renderGoalReminder(task) {
+  const variables = {
+    taskId: task.id,
+    task: task.task,
+    progressLine: task.progress ? `
+Current Progress: ${task.progress}` : ""
+  };
+  try {
+    const result = await resolveTemplateAsync(GOAL_REMINDER_TEMPLATE, variables);
+    return result.skipped ? "" : result.text;
+  } catch {
+    return resolveTemplateFromCode(GOAL_REMINDER_TEMPLATE, variables).text;
+  }
+}
+
+// src/providers/pi-mono-extension.ts
+init_openrouter_base_url();
+init_secret_scrubber();
+function apiHeaders(config) {
+  return {
+    "Content-Type": "application/json",
+    ...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {},
+    "X-Agent-ID": config.agentId
+  };
+}
+function fireAndForget(url, init) {
+  fetch(url, init).catch(() => {});
+}
+async function isTaskCancelled(config) {
+  try {
+    const resp = await fetch(`${config.apiUrl}/cancelled-tasks?taskId=${encodeURIComponent(config.taskId)}`, { method: "GET", headers: apiHeaders(config) });
+    if (!resp.ok)
+      return { cancelled: false };
+    const data = await resp.json();
+    const match = data.cancelled?.find((t) => t.id === config.taskId);
+    return match ? { cancelled: true, reason: match.failureReason } : { cancelled: false };
+  } catch {
+    return { cancelled: false };
+  }
+}
+async function checkShouldBlockPolling(config) {
+  try {
+    const resp = await fetch(`${config.apiUrl}/me`, {
+      method: "GET",
+      headers: apiHeaders(config)
+    });
+    if (!resp.ok)
+      return false;
+    const data = await resp.json();
+    return data.shouldBlockPolling === true;
+  } catch {
+    return false;
+  }
+}
+async function fetchTaskDetails(config) {
+  try {
+    const resp = await fetch(`${config.apiUrl}/api/tasks/${config.taskId}`, {
+      method: "GET",
+      headers: apiHeaders(config)
+    });
+    if (!resp.ok)
+      return null;
+    return await resp.json();
+  } catch {
+    return null;
+  }
+}
+async function syncIdentityFilesToServer(config, changeSource = "session_sync", signal) {
+  const updates = {};
+  const paths = {
+    soulMd: "/workspace/SOUL.md",
+    identityMd: "/workspace/IDENTITY.md",
+    toolsMd: "/workspace/TOOLS.md"
+  };
+  for (const [key, path] of Object.entries(paths)) {
+    try {
+      const file = Bun.file(path);
+      if (await file.exists()) {
+        const content = await file.text();
+        if (content.trim() && content.length <= 65536) {
+          updates[key] = content;
+        }
+      }
+    } catch {}
+  }
+  if (Object.keys(updates).length === 0)
+    return;
+  try {
+    await fetch(`${config.apiUrl}/api/agents/${config.agentId}/profile`, {
+      method: "PUT",
+      headers: apiHeaders(config),
+      body: JSON.stringify({ ...updates, changeSource }),
+      signal
+    });
+  } catch {}
+}
+async function syncSetupScriptToServer(config, changeSource = "session_sync") {
+  try {
+    const file = Bun.file("/workspace/start-up.sh");
+    if (!await file.exists())
+      return;
+    const raw = await file.text();
+    if (!raw.trim())
+      return;
+    const markerStart = "# === Agent-managed setup (from DB) ===";
+    const markerEnd = "# === End agent-managed setup ===";
+    const startIdx = raw.indexOf(markerStart);
+    const endIdx = raw.indexOf(markerEnd);
+    let content;
+    if (startIdx !== -1 && endIdx !== -1) {
+      content = raw.substring(startIdx + markerStart.length, endIdx).trim();
+    } else {
+      content = raw.replace(/^#!\/bin\/bash\n/, "").trim();
+    }
+    if (!content || content.length > 65536)
+      return;
+    await fetch(`${config.apiUrl}/api/agents/${config.agentId}/profile`, {
+      method: "PUT",
+      headers: apiHeaders(config),
+      body: JSON.stringify({ setupScript: content, changeSource })
+    });
+  } catch {}
+}
+async function autoIndexMemoryFile(config, editedPath) {
+  try {
+    const fileContent = await Bun.file(editedPath).text();
+    const isShared = editedPath.startsWith("/workspace/shared/");
+    const fileName = editedPath.split("/").pop() ?? "unnamed";
+    await fetch(`${config.apiUrl}/api/memory/index`, {
+      method: "POST",
+      headers: apiHeaders(config),
+      body: JSON.stringify({
+        agentId: config.agentId,
+        content: fileContent,
+        name: fileName.replace(/\.\w+$/, ""),
+        scope: isShared ? "swarm" : "agent",
+        source: "file_index",
+        sourcePath: editedPath
+      })
+    });
+  } catch {}
+}
+async function fetchConcurrentContext(config) {
+  try {
+    const resp = await fetch(`${config.apiUrl}/api/concurrent-context`, {
+      method: "GET",
+      headers: apiHeaders(config)
+    });
+    if (!resp.ok)
+      return null;
+    const data = await resp.json();
+    const lines = [];
+    if (data.processingInboxMessages.length > 0) {
+      lines.push("=== CONCURRENT SESSION AWARENESS ===");
+      lines.push("");
+      lines.push("**Other sessions are currently processing these inbox messages:**");
+      for (const msg of data.processingInboxMessages) {
+        const preview = msg.content.length > 120 ? `${msg.content.slice(0, 120)}...` : msg.content;
+        lines.push(`- [${msg.source}] "${preview}" (received ${msg.createdAt})`);
+      }
+    }
+    if (data.recentTaskDelegations.length > 0) {
+      if (lines.length === 0)
+        lines.push("=== CONCURRENT SESSION AWARENESS ===");
+      lines.push("");
+      lines.push("**Recent task delegations (last 5 min):**");
+      for (const task of data.recentTaskDelegations) {
+        const preview = task.task.length > 120 ? `${task.task.slice(0, 120)}...` : task.task;
+        lines.push(`- "${preview}" → ${task.agentName ?? "unassigned"} [${task.status}]`);
+      }
+    }
+    if (data.activeSwarmTasks.length > 0) {
+      if (lines.length === 0)
+        lines.push("=== CONCURRENT SESSION AWARENESS ===");
+      lines.push("");
+      lines.push("**Currently active tasks across the swarm:**");
+      for (const task of data.activeSwarmTasks) {
+        const preview = task.task.length > 100 ? `${task.task.slice(0, 100)}...` : task.task;
+        lines.push(`- ${task.agentName ?? "unassigned"}: "${preview}" [${task.status}]`);
+      }
+    }
+    if (lines.length > 0) {
+      lines.push("");
+      lines.push("IMPORTANT: Avoid duplicating work that is already being handled by other sessions or agents.");
+      lines.push("=== END CONCURRENT SESSION AWARENESS ===");
+      return lines.join(`
+`);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function summarizeSessionForPi(config, sessionFile, deps = {}) {
+  if (!sessionFile) {
+    console.warn("session_summary skipped (pi): session transcript file unavailable");
+    return;
+  }
+  let transcript = "";
+  try {
+    const fullTranscript = await Bun.file(sessionFile).text();
+    transcript = fullTranscript.length > 20000 ? fullTranscript.slice(-20000) : fullTranscript;
+  } catch (err) {
+    console.warn(scrubSecrets(`session_summary skipped (pi): cannot read ${sessionFile}: ${String(err)}`));
+    return;
+  }
+  await summarizeTranscript(config, "pi", transcript, deps);
+}
+async function summarizeTranscript(config, harness, transcript, deps = {}) {
+  const _runSummarize = deps.runSummarize ?? summarizeSession;
+  const _fetchRetrievals = deps.fetchRetrievalsForTask ?? fetchRetrievalsForTask;
+  const _postRatings = deps.postRatings ?? postRatings;
+  const _buildRatings = deps.buildRatingsFromLlm ?? buildRatingsFromLlm;
+  try {
+    if (transcript.length <= 100) {
+      console.warn(`session_summary skipped (${harness}): transcript too short (${transcript.length} chars)`);
+      return;
+    }
+    const sourceTaskId = config.taskId;
+    const agentId = config.agentId;
+    if (!sourceTaskId || !agentId) {
+      console.warn(`session_summary skipped (${harness}): ${!sourceTaskId ? "task id unavailable" : "agent id unavailable"}`);
+      return;
+    }
+    const taskDetails = await fetchTaskDetails(config).catch(() => null);
+    const wantRatings = getMemoryRaterNames().includes("llm");
+    const retrievals = wantRatings ? await _fetchRetrievals({
+      apiUrl: config.apiUrl,
+      apiKey: config.apiKey,
+      agentId,
+      taskId: sourceTaskId
+    }).catch(() => []) : [];
+    const result = await _runSummarize({
+      harness,
+      transcript,
+      retrievals,
+      taskContext: {
+        sourceTaskId,
+        agentId,
+        prompt: taskDetails?.task
+      },
+      apiUrl: config.apiUrl,
+      apiKey: config.apiKey,
+      env: config.env
+    });
+    if (!result) {
+      console.warn(`session_summary skipped (${harness}): summarizer returned no result`);
+      return;
+    }
+    const summary = result.summary.trim();
+    if (summary.length <= 20 || summary.toLowerCase().includes("no significant learnings")) {
+      console.debug(`session_summary skipped (${harness}): summary failed quality gate (${summary.length} chars)`);
+      return;
+    }
+    const indexResp = await fetch(`${config.apiUrl}/api/memory/index`, {
+      method: "POST",
+      headers: apiHeaders(config),
+      body: JSON.stringify({
+        scope: "agent",
+        source: "session_summary",
+        sourceTaskId,
+        content: summary,
+        name: "session-summary",
+        agentId
+      })
+    });
+    if (!indexResp.ok) {
+      const text = await indexResp.text().catch(() => "");
+      console.error(`session_summary: /api/memory/index POST failed (${harness}):`, indexResp.status, scrubSecrets(text));
+      return;
+    }
+    if (wantRatings && result.ratings && result.ratings.length > 0) {
+      const ratingEvents = _buildRatings(result.ratings, retrievals, result.model);
+      if (ratingEvents.length > 0) {
+        await _postRatings({
+          apiUrl: config.apiUrl,
+          apiKey: config.apiKey,
+          agentId,
+          taskId: sourceTaskId,
+          events: ratingEvents
+        }).catch((err) => console.error(`session_summary: postRatings failed (${harness}):`, scrubError(err)));
+      }
+    }
+  } catch (err) {
+    console.error(`session_summary failed (${harness}):`, scrubError(err));
+  }
+}
+function scrubError(err) {
+  return scrubSecrets(err instanceof Error ? err.stack ?? err.message : String(err));
+}
+var SWARM_NUDGE_CUSTOM_TYPE = "swarm-nudge";
+function sendNudge(pi, text) {
+  pi.sendMessage({
+    customType: SWARM_NUDGE_CUSTOM_TYPE,
+    content: [{ type: "text", text }],
+    display: false
+  });
+}
+function createSwarmHooksExtension(config) {
+  return (pi) => {
+    let lastContextPostTime = 0;
+    pi.on("before_provider_headers", (event, ctx) => {
+      Object.assign(event.headers, getOpenRouterAttributionHeaders(ctx.model?.baseUrl ?? "", config.env));
+    });
+    pi.on("session_start", async (_event, _ctx) => {
+      for (const [name, server] of Object.entries(config.mcpServers ?? {})) {
+        try {
+          pi.registerMcpServer(name, server);
+        } catch (err) {
+          console.warn(`[pi] Failed to register MCP server "${name}": ${err}`);
+        }
+      }
+      fireAndForget(`${config.apiUrl}/ping`, {
+        method: "POST",
+        headers: apiHeaders(config)
+      });
+      if (config.taskId) {
+        await clearToolHistory(config.taskId);
+      }
+      if (config.isLead) {
+        const ctx = await fetchConcurrentContext(config);
+        if (ctx) {
+          sendNudge(pi, ctx);
+        }
+      }
+    });
+    pi.on("tool_call", async (event, _ctx) => {
+      if (!config.isLead && config.taskId) {
+        const { cancelled, reason } = await isTaskCancelled(config);
+        if (cancelled) {
+          const cancelReason = reason || "Task cancelled by lead or creator";
+          return {
+            block: true,
+            reason: `\uD83D\uDED1 TASK CANCELLED: Your current task (${config.taskId.slice(0, 8)}) has been cancelled. Reason: "${cancelReason}". ` + `Stop working on this task immediately. Do NOT continue making tool calls. ` + `Use store-progress to acknowledge the cancellation and mark the task as failed, then wait for new tasks.`
+          };
+        }
+      }
+      if (!config.isLead && config.taskId) {
+        const toolName = event.toolName;
+        const toolInput = "input" in event ? event.input : {};
+        const loopResult = await checkToolLoop(config.taskId, toolName, toolInput);
+        if (loopResult.blocked) {
+          return {
+            block: true,
+            reason: `LOOP DETECTED: ${loopResult.reason} ` + "Stop repeating this action and try a fundamentally different approach. " + "If you're truly stuck, use store-progress to report the blocker."
+          };
+        }
+        if (loopResult.severity === "warning" && loopResult.reason) {
+          sendNudge(pi, `Warning: ${loopResult.reason}`);
+        }
+      }
+      if (event.toolName?.endsWith("poll-task")) {
+        const shouldBlock = await checkShouldBlockPolling(config);
+        if (shouldBlock) {
+          return {
+            block: true,
+            reason: "\uD83D\uDED1 POLLING LIMIT REACHED: You have exceeded the maximum empty poll attempts. " + "EXIT NOW - do not make any more tool calls."
+          };
+        }
+      }
+      return;
+    });
+    pi.on("tool_result", async (event, ctx) => {
+      if (!config.isLead && config.taskId) {
+        fireAndForget(`${config.apiUrl}/api/active-sessions/heartbeat/${config.taskId}`, {
+          method: "PUT",
+          headers: apiHeaders(config)
+        });
+      }
+      fireAndForget(`${config.apiUrl}/api/agents/${config.agentId}/activity`, {
+        method: "PUT",
+        headers: apiHeaders(config)
+      });
+      const usage = ctx.getContextUsage?.();
+      if (config.taskId && usage?.tokens != null) {
+        const now = Date.now();
+        if (now - lastContextPostTime >= 30000) {
+          lastContextPostTime = now;
+          fireAndForget(`${config.apiUrl}/api/tasks/${config.taskId}/context`, {
+            method: "POST",
+            headers: apiHeaders(config),
+            body: JSON.stringify({
+              eventType: "progress",
+              sessionId: `pi-${config.taskId}`,
+              contextUsedTokens: usage.tokens,
+              contextTotalTokens: usage.contextWindow,
+              contextPercent: usage.percent
+            })
+          });
+        }
+      }
+      const toolName = event.toolName;
+      const input = event.input;
+      const editedPath = input?.file_path || input?.path;
+      if ((toolName === "write" || toolName === "edit") && editedPath) {
+        if (editedPath === "/workspace/SOUL.md" || editedPath === "/workspace/IDENTITY.md" || editedPath === "/workspace/TOOLS.md") {
+          syncIdentityFilesToServer(config, "self_edit");
+        }
+        if (editedPath.startsWith("/workspace/start-up")) {
+          syncSetupScriptToServer(config, "self_edit");
+        }
+        if (editedPath.startsWith("/workspace/personal/memory/") || editedPath.startsWith("/workspace/shared/memory/")) {
+          autoIndexMemoryFile(config, editedPath);
+        }
+      }
+      if (config.isLead && event.toolName?.endsWith("send-task")) {
+        sendNudge(pi, "Task sent successfully. Monitor progress using the get-task-details tool periodically.");
+      }
+      return;
+    });
+    pi.on("session_compact", async () => {
+      if (!config.taskId)
+        return;
+      const taskDetails = await fetchTaskDetails(config);
+      if (taskDetails) {
+        const reminder = await renderGoalReminder(taskDetails);
+        if (reminder)
+          sendNudge(pi, reminder);
+      }
+    });
+    pi.on("context", async (_event, ctx) => {
+      if (!config.taskId)
+        return;
+      const usage = ctx.getContextUsage?.();
+      if (usage) {
+        fireAndForget(`${config.apiUrl}/api/tasks/${config.taskId}/context`, {
+          method: "POST",
+          headers: apiHeaders(config),
+          body: JSON.stringify({
+            eventType: "compaction",
+            sessionId: `pi-${config.taskId}`,
+            contextUsedTokens: usage.tokens ?? undefined,
+            contextTotalTokens: usage.contextWindow,
+            contextPercent: usage.percent ?? undefined
+          })
+        });
+      }
+      return;
+    });
+    pi.on("input", async (_event, _ctx) => {
+      if (!config.isLead && config.taskId) {
+        const { cancelled, reason } = await isTaskCancelled(config);
+        if (cancelled) {
+          const cancelReason = reason || "Task cancelled by lead or creator";
+          sendNudge(pi, `\uD83D\uDED1 TASK CANCELLED: ${cancelReason}. Stop working and use store-progress to acknowledge.`);
+          return { action: "handled" };
+        }
+      }
+      return;
+    });
+    pi.on("session_shutdown", async (_event, ctx) => {
+      const usage = ctx.getContextUsage?.();
+      if (config.taskId && usage) {
+        await fetch(`${config.apiUrl}/api/tasks/${config.taskId}/context`, {
+          method: "POST",
+          headers: apiHeaders(config),
+          body: JSON.stringify({
+            eventType: "completion",
+            sessionId: `pi-${config.taskId}`,
+            contextTotalTokens: usage.contextWindow,
+            contextPercent: usage.percent ?? undefined,
+            contextUsedTokens: usage.tokens ?? undefined
+          })
+        }).catch(() => {});
+      }
+      await syncIdentityFilesToServer(config);
+      await syncSetupScriptToServer(config);
+      const sessionFile = ctx.sessionManager.getSessionFile?.();
+      if (!process.env.SKIP_SESSION_SUMMARY) {
+        await summarizeSessionForPi(config, sessionFile);
+      } else {
+        console.debug("session_summary skipped (pi): SKIP_SESSION_SUMMARY is set");
+      }
+      fireAndForget(`${config.apiUrl}/close`, {
+        method: "POST",
+        headers: apiHeaders(config)
+      });
+    });
+  };
+}
+
+export { renderGoalReminder, apiHeaders, fireAndForget, isTaskCancelled, checkShouldBlockPolling, fetchTaskDetails, syncIdentityFilesToServer, autoIndexMemoryFile, fetchConcurrentContext, summarizeTranscript, createSwarmHooksExtension };