@desplega.ai/agent-swarm 1.93.0 → 1.95.0

package/src/slack/watcher.ts

@@ -5,6 +5,7 @@ import {
   getInProgressSlackTasks,
   getTaskAttachments,
   getTaskById,
+  setSlackMessageTracking,
 } from "../be/db";
 import type { AgentTask } from "../types";
 import { getSlackApp } from "./app";
@@ -76,6 +77,15 @@ export function registerTreeMessage(
   // Also register in legacy flat map so existing watcher processing still works
   taskMessages.set(taskId, { channelId, threadTs, messageTs });
 
+  try {
+    setSlackMessageTracking(taskId, {
+      slackProgressMessageTs: messageTs,
+      slackTreeRootMessageTs: messageTs,
+    });
+  } catch (error) {
+    console.error(`[Slack] Failed to persist message tracking for task ${taskId}:`, error);
+  }
+
   console.log(`[Slack] Registered task ${taskId.slice(0, 8)} in tree message ${messageTs}`);
 }
 
@@ -193,6 +203,12 @@ export function _getTreeMessages(): Map<string, TreeMessageState> {
 export function _getTaskToTree(): Map<string, string> {
   return taskToTree;
 }
+export function _getTaskMessages(): Map<
+  string,
+  { channelId: string; threadTs: string; messageTs: string }
+> {
+  return taskMessages;
+}
 export function _getLastRenderedTree(): Map<string, string> {
   return lastRenderedTree;
 }
@@ -306,13 +322,35 @@ export async function processTreeMessages(): Promise<void> {
       : `Tasks in progress: ${rootNames}`;
 
     // Update the Slack message
-    const success = await updateTreeMessage(tree.channelId, messageTs, blocks, fallbackText);
+    const result = await updateTreeMessage(tree.channelId, messageTs, blocks, fallbackText);
+    const success = result === "ok";
     if (success) {
       lastRenderedTree.set(messageTs, serialized);
       treeLastUpdateTime.set(messageTs, now);
       console.log(
         `[Slack] Updated tree message ${messageTs} (${nodes.length} root(s), terminal=${fullyTerminal})`,
       );
+    } else if (result === "not_found") {
+      const taskIds = Array.from(tree.rootTaskIds);
+      for (const taskId of taskIds) {
+        taskToTree.delete(taskId);
+        taskMessages.delete(taskId);
+        try {
+          setSlackMessageTracking(taskId, {
+            slackProgressMessageTs: null,
+            slackTreeRootMessageTs: null,
+          });
+        } catch (error) {
+          console.error(`[Slack] Failed to clear stale message tracking for ${taskId}:`, error);
+        }
+      }
+      treeMessages.delete(messageTs);
+      lastRenderedTree.delete(messageTs);
+      treeLastUpdateTime.delete(messageTs);
+      console.warn(
+        `[Slack] Dropped stale tree ${messageTs} (${taskIds.length} task(s)); will repost on next tick`,
+      );
+      continue;
     }
 
     // DM channels: set assistant status in parallel for typing indicator UX
@@ -437,6 +475,50 @@ export function startTaskWatcher(intervalMs = 3000): void {
   }
   console.log(`[Slack] Initialized with ${existingCompleted.length} existing completed tasks`);
 
+  let hydratedTrees = 0;
+  let hydratedFlat = 0;
+  for (const task of getInProgressSlackTasks()) {
+    if (!task.slackChannelId || !task.slackThreadTs) continue;
+
+    const treeTs = task.slackTreeRootMessageTs;
+    const progressTs = task.slackProgressMessageTs;
+
+    if (treeTs) {
+      let tree = treeMessages.get(treeTs);
+      if (!tree) {
+        tree = {
+          channelId: task.slackChannelId,
+          threadTs: task.slackThreadTs,
+          messageTs: treeTs,
+          rootTaskIds: new Set(),
+        };
+        treeMessages.set(treeTs, tree);
+      }
+      tree.rootTaskIds.add(task.id);
+      taskToTree.set(task.id, treeTs);
+      taskMessages.set(task.id, {
+        channelId: task.slackChannelId,
+        threadTs: task.slackThreadTs,
+        messageTs: treeTs,
+      });
+      if (task.progress) sentProgress.set(task.id, task.progress);
+      hydratedTrees++;
+    } else if (progressTs) {
+      taskMessages.set(task.id, {
+        channelId: task.slackChannelId,
+        threadTs: task.slackThreadTs,
+        messageTs: progressTs,
+      });
+      if (task.progress) sentProgress.set(task.id, task.progress);
+      hydratedFlat++;
+    }
+  }
+  if (hydratedTrees > 0 || hydratedFlat > 0) {
+    console.log(
+      `[Slack] Hydrated ${hydratedTrees} tree task(s) and ${hydratedFlat} flat task(s) from DB`,
+    );
+  }
+
   watcherInterval = setInterval(async () => {
     // Prevent overlapping processing cycles
     if (isProcessing || !getSlackApp()) return;
@@ -515,8 +597,20 @@ export function startTaskWatcher(intervalMs = 3000): void {
           sentProgress.set(task.id, "__in_progress__");
           lastSendTime.set(progressKey, now);
           try {
-            await updateProgressInPlace(task, "Starting...", tracked.messageTs);
-            console.log(`[Slack] Updated to in-progress for task ${task.id.slice(0, 8)}`);
+            const result = await updateProgressInPlace(task, "Starting...", tracked.messageTs);
+            if (result === "not_found") {
+              taskMessages.delete(task.id);
+              sentProgress.delete(task.id);
+              setSlackMessageTracking(task.id, {
+                slackProgressMessageTs: null,
+                slackTreeRootMessageTs: null,
+              });
+            } else if (result === "ok") {
+              console.log(`[Slack] Updated to in-progress for task ${task.id.slice(0, 8)}`);
+            } else {
+              sentProgress.delete(task.id);
+              lastSendTime.delete(progressKey);
+            }
           } catch (error) {
             sentProgress.delete(task.id);
             lastSendTime.delete(progressKey);
@@ -535,23 +629,42 @@ export function startTaskWatcher(intervalMs = 3000): void {
           sentProgress.set(task.id, task.progress);
           lastSendTime.set(progressKey, now);
           try {
+            let postedTs: string | undefined;
             if (tracked) {
               // Update the existing message in-place via chat.update
-              await updateProgressInPlace(task, task.progress, tracked.messageTs);
-              console.log(`[Slack] Updated progress in-place for task ${task.id.slice(0, 8)}`);
+              const result = await updateProgressInPlace(task, task.progress, tracked.messageTs);
+              if (result === "ok") {
+                console.log(`[Slack] Updated progress in-place for task ${task.id.slice(0, 8)}`);
+              } else if (result === "not_found") {
+                taskMessages.delete(task.id);
+                postedTs = await sendProgressUpdate(task, task.progress);
+                if (postedTs && task.slackChannelId && task.slackThreadTs) {
+                  taskMessages.set(task.id, {
+                    channelId: task.slackChannelId,
+                    threadTs: task.slackThreadTs,
+                    messageTs: postedTs,
+                  });
+                }
+              } else {
+                sentProgress.delete(task.id);
+                lastSendTime.delete(progressKey);
+              }
             } else {
               // No tracked message (e.g., multi-task assignment or server restart)
               // Post a new progress message and track its ts
-              const messageTs = await sendProgressUpdate(task, task.progress);
-              if (messageTs && task.slackChannelId && task.slackThreadTs) {
+              postedTs = await sendProgressUpdate(task, task.progress);
+              if (postedTs && task.slackChannelId && task.slackThreadTs) {
                 taskMessages.set(task.id, {
                   channelId: task.slackChannelId,
                   threadTs: task.slackThreadTs,
-                  messageTs,
+                  messageTs: postedTs,
                 });
               }
               console.log(`[Slack] Sent initial progress for task ${task.id.slice(0, 8)}`);
             }
+            if (postedTs) {
+              setSlackMessageTracking(task.id, { slackProgressMessageTs: postedTs });
+            }
           } catch (error) {
             // If send fails, clear markers so we can retry
             sentProgress.delete(task.id);

package/src/tests/agents-list-model-display.test.ts

@@ -42,4 +42,17 @@ describe("agents list model display", () => {
       providerId: "openrouter",
     });
   });
+
+  test("presents latest Anthropic direct model ids as readable labels", () => {
+    expect(getAgentModelPresentation("claude-fable-5")).toMatchObject({
+      label: "Claude Fable 5",
+      provider: "Anthropic",
+      providerId: "anthropic",
+    });
+    expect(getAgentModelPresentation("claude-mythos-5")).toMatchObject({
+      label: "Claude Mythos 5",
+      provider: "Anthropic",
+      providerId: "anthropic",
+    });
+  });
 });

package/src/tests/aws-error-classifier.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Unit tests for `classifyAwsSdkError` in `src/utils/aws-error-classifier.ts`.
+ *
+ * Exercises all four error categories and the no-match path.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { classifyAwsSdkError } from "../utils/aws-error-classifier";
+
+describe("classifyAwsSdkError — aws-auth", () => {
+  test("ExpiredTokenException", () => {
+    const r = classifyAwsSdkError(
+      "ExpiredTokenException: The security token included in the request is expired",
+    );
+    expect(r).not.toBeNull();
+    expect(r!.category).toBe("aws-auth");
+    expect(r!.message).toContain("aws sso login");
+  });
+
+  test("ExpiredToken (without Exception suffix)", () => {
+    const r = classifyAwsSdkError("ExpiredToken: token expired");
+    expect(r?.category).toBe("aws-auth");
+  });
+
+  test("CredentialsProviderError", () => {
+    const r = classifyAwsSdkError("CredentialsProviderError: Could not load credentials");
+    expect(r?.category).toBe("aws-auth");
+  });
+
+  test("Unable to locate credentials", () => {
+    const r = classifyAwsSdkError(
+      'Unable to locate credentials. You can configure credentials by running "aws configure".',
+    );
+    expect(r?.category).toBe("aws-auth");
+  });
+
+  test("security token ... expired (lower-case)", () => {
+    const r = classifyAwsSdkError("The security token included in the request is expired");
+    expect(r?.category).toBe("aws-auth");
+  });
+
+  test("InvalidSignatureException", () => {
+    const r = classifyAwsSdkError(
+      "InvalidSignatureException: The request signature we calculated does not match the signature you provided",
+    );
+    expect(r?.category).toBe("aws-auth");
+  });
+
+  test("UnrecognizedClientException", () => {
+    const r = classifyAwsSdkError(
+      "UnrecognizedClientException: The security token included in the request is invalid",
+    );
+    expect(r?.category).toBe("aws-auth");
+  });
+});
+
+describe("classifyAwsSdkError — aws-throttle", () => {
+  test("ThrottlingException", () => {
+    const r = classifyAwsSdkError("ThrottlingException: Rate exceeded");
+    expect(r?.category).toBe("aws-throttle");
+    expect(r!.message).toContain("quota");
+  });
+
+  test("TooManyRequestsException", () => {
+    const r = classifyAwsSdkError("TooManyRequestsException: Too many requests");
+    expect(r?.category).toBe("aws-throttle");
+  });
+
+  test("ServiceQuotaExceededException", () => {
+    const r = classifyAwsSdkError(
+      "ServiceQuotaExceededException: You have exceeded your request quota for this service",
+    );
+    expect(r?.category).toBe("aws-throttle");
+  });
+
+  test("Rate exceeded (standalone phrase)", () => {
+    const r = classifyAwsSdkError("Rate exceeded. Reduce your request rate.");
+    expect(r?.category).toBe("aws-throttle");
+  });
+});
+
+describe("classifyAwsSdkError — aws-access", () => {
+  test("AccessDeniedException with bedrock:InvokeModel", () => {
+    const r = classifyAwsSdkError(
+      "AccessDeniedException: User: arn:aws:iam::123:user/dev is not authorized to perform: bedrock:InvokeModel on resource: arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-v2",
+    );
+    expect(r?.category).toBe("aws-access");
+    expect(r!.message).toContain("bedrock:InvokeModel");
+  });
+
+  test("not authorized to perform (phrase match)", () => {
+    const r = classifyAwsSdkError("User is not authorized to perform: bedrock:InvokeModel");
+    expect(r?.category).toBe("aws-access");
+  });
+});
+
+describe("classifyAwsSdkError — aws-model", () => {
+  test("ValidationException", () => {
+    const r = classifyAwsSdkError(
+      "ValidationException: Invocation of model ID anthropic.claude-v99 with on-demand throughput isn't supported",
+    );
+    expect(r?.category).toBe("aws-model");
+    expect(r!.message).toContain("MODEL_OVERRIDE");
+  });
+
+  test("ResourceNotFoundException", () => {
+    const r = classifyAwsSdkError("ResourceNotFoundException: Could not find model");
+    expect(r?.category).toBe("aws-model");
+  });
+
+  test("ModelTimeoutException", () => {
+    const r = classifyAwsSdkError(
+      "ModelTimeoutException: The model timed out processing your request",
+    );
+    expect(r?.category).toBe("aws-model");
+  });
+
+  test("ModelNotReadyException", () => {
+    const r = classifyAwsSdkError("ModelNotReadyException: The model is not ready for inference");
+    expect(r?.category).toBe("aws-model");
+  });
+});
+
+describe("classifyAwsSdkError — priority ordering", () => {
+  test("aws-auth wins over aws-model when both match (ExpiredToken + ValidationException)", () => {
+    // Should not happen in practice, but priority must be deterministic
+    const r = classifyAwsSdkError("ExpiredTokenException and also ValidationException");
+    expect(r?.category).toBe("aws-auth");
+  });
+});
+
+describe("classifyAwsSdkError — no-match", () => {
+  test("returns null for empty string", () => {
+    expect(classifyAwsSdkError("")).toBeNull();
+  });
+
+  test("returns null for unrelated error", () => {
+    expect(classifyAwsSdkError("TypeError: Cannot read property 'foo' of undefined")).toBeNull();
+  });
+
+  test("returns null for generic network error", () => {
+    expect(classifyAwsSdkError("ECONNREFUSED 127.0.0.1:3013")).toBeNull();
+  });
+
+  test("returns null for Claude API error (not AWS)", () => {
+    expect(classifyAwsSdkError("401 Unauthorized: Invalid API key")).toBeNull();
+  });
+});

package/src/tests/claude-managed-adapter.test.ts

@@ -794,6 +794,18 @@ describe("ClaudeManagedAdapter (Phase 4) — repo provisioning + cost data", ()
   });
 
   test("CLAUDE_MANAGED_MODEL_PRICING covers sonnet, opus, haiku at minimum", () => {
+    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-fable-5"]).toEqual({
+      inputPerMillion: 10.0,
+      outputPerMillion: 50.0,
+      cacheReadPerMillion: 1.0,
+      cacheWritePerMillion: 12.5,
+    });
+    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-mythos-5"]).toEqual({
+      inputPerMillion: 10.0,
+      outputPerMillion: 50.0,
+      cacheReadPerMillion: 1.0,
+      cacheWritePerMillion: 12.5,
+    });
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-4-6"]).toBeDefined();
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-opus-4-7"]).toBeDefined();
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-haiku-4-5"]).toBeDefined();

package/src/tests/context-window.test.ts

@@ -8,6 +8,13 @@ import {
 } from "../utils/context-window";
 
 describe("getContextWindowSize", () => {
+  test("returns 1M for fable and mythos models", () => {
+    expect(getContextWindowSize("claude-fable-5")).toBe(1_000_000);
+    expect(getContextWindowSize("claude-mythos-5")).toBe(1_000_000);
+    expect(getContextWindowSize("fable")).toBe(1_000_000);
+    expect(getContextWindowSize("mythos")).toBe(1_000_000);
+  });
+
   test("returns 1M for opus models", () => {
     expect(getContextWindowSize("claude-opus-4-8")).toBe(1_000_000);
     expect(getContextWindowSize("claude-opus-4-7")).toBe(1_000_000);