@desplega.ai/agent-swarm 1.83.0 → 1.83.2

package/src/tools/task-tool-ctx.ts

@@ -0,0 +1,43 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AgentTask, User } from "@/types";
+import type { RequestInfo } from "./utils";
+
+export type ToolCtx =
+  | { kind: "owner"; agentId?: string; sourceTaskId?: string; sessionId?: string }
+  | { kind: "user"; userId: string; user: User; sessionId?: string };
+
+export function ownerCtx(info: RequestInfo): ToolCtx {
+  return {
+    kind: "owner",
+    agentId: info.agentId,
+    sourceTaskId: info.sourceTaskId,
+    sessionId: info.sessionId,
+  };
+}
+
+export function userCtx(user: User, sessionId?: string): ToolCtx {
+  return {
+    kind: "user",
+    userId: user.id,
+    user,
+    sessionId,
+  };
+}
+
+export function assertOwnsTask(ctx: ToolCtx, task: AgentTask): CallToolResult | null {
+  if (ctx.kind === "owner" || task.requestedByUserId === ctx.userId) {
+    return null;
+  }
+
+  const message = `Forbidden: this task is not yours (task ${task.id}).`;
+  // RBAC chokepoint — a future admin/role tier widens visibility here, in this one function.
+  return {
+    isError: true,
+    content: [{ type: "text", text: message }],
+    structuredContent: {
+      success: false,
+      code: "forbidden",
+      message,
+    },
+  };
+}

package/src/types.ts

@@ -1682,7 +1682,7 @@ export type ContextSnapshot = z.infer<typeof ContextSnapshotSchema>;
 // effective_from <= now" lookup is a pure integer comparison. Matches the
 // SQL columns in migration 046_budgets_and_pricing.sql verbatim.
 
-export const BudgetScopeSchema = z.enum(["global", "agent"]);
+export const BudgetScopeSchema = z.enum(["global", "agent", "user"]);
 export type BudgetScope = z.infer<typeof BudgetScopeSchema>;
 
 export const BudgetSchema = z.object({
@@ -1730,7 +1730,7 @@ export const PricingRowSchema = z.object({
 });
 export type PricingRow = z.infer<typeof PricingRowSchema>;
 
-export const BudgetRefusalCauseSchema = z.enum(["agent", "global"]);
+export const BudgetRefusalCauseSchema = z.enum(["agent", "global", "user"]);
 export type BudgetRefusalCause = z.infer<typeof BudgetRefusalCauseSchema>;
 
 export const BudgetRefusalNotificationSchema = z.object({
@@ -1742,6 +1742,8 @@ export const BudgetRefusalNotificationSchema = z.object({
   agentBudgetUsd: z.number().nullable().optional(),
   globalSpendUsd: z.number().nullable().optional(),
   globalBudgetUsd: z.number().nullable().optional(),
+  userSpendUsd: z.number().nullable().optional(),
+  userBudgetUsd: z.number().nullable().optional(),
   followUpTaskId: z.string().nullable().optional(),
   createdAt: z.number(), // epoch ms
 });
@@ -1761,6 +1763,8 @@ export const BudgetRefusedTriggerSchema = z.object({
   agentBudget: z.number().optional(),
   globalSpend: z.number().optional(),
   globalBudget: z.number().optional(),
+  userSpend: z.number().optional(),
+  userBudget: z.number().optional(),
   resetAt: z.string(), // ISO 8601, next UTC midnight
 });
 export type BudgetRefusedTrigger = z.infer<typeof BudgetRefusedTriggerSchema>;

package/src/utils/error-tracker.ts

@@ -11,13 +11,34 @@ export interface ErrorSignal {
 }
 
 /**
- * Clamps a candidate reset timestamp (ms) to [now+60s, now+6h].
+ * Maximum cooldown horizon for a rate-limit reset. A weekly OAuth limit resets
+ * up to ~7 days out, so the cap must be at least that or a weekly-limited key
+ * gets re-clamped to a short cooldown and re-handed to a worker every few hours
+ * (the fail-every-6h sawtooth). 7d still guards against absurd far-future
+ * (malformed) values.
+ */
+export const MAX_RATE_LIMIT_RESET_MS = 7 * 24 * 60 * 60 * 1000;
+
+/**
+ * Single source of truth for "does this text look like a rate-limit signal?".
+ * Shared by the runner's cooldown gate and {@link parseStderrForErrors} so the
+ * two matchers can't drift. Tolerates a qualifier between "your" and "limit"
+ * (weekly / 5-hour / daily): matches "hit your weekly limit", "hit your 5-hour
+ * limit", "hit your limit", "Claude usage limit reached", "rate limit exceeded",
+ * "429 Too Many Requests"; does not match "No conversation found with session ID".
+ */
+export function isRateLimitMessage(s: string): boolean {
+  return /rate.?limit|hit your[\w\s-]*limit|usage[ _-]?limit|too many requests|\b429\b/i.test(s);
+}
+
+/**
+ * Clamps a candidate reset timestamp (ms) to [now+60s, now+7d].
  * Protects against past timestamps (clock skew) and absurdly far future values (malformed).
  */
 function clampRateLimitResetMs(candidateMs: number): number {
   const nowMs = Date.now();
   const minMs = nowMs + 60_000;
-  const maxMs = nowMs + 6 * 60 * 60 * 1000;
+  const maxMs = nowMs + MAX_RATE_LIMIT_RESET_MS;
   return Math.min(Math.max(candidateMs, minMs), maxMs);
 }
 
@@ -96,6 +117,26 @@ export class SessionErrorTracker {
     }
   }
 
+  /**
+   * Process a Codex-style usage-limit error message (from a `{type:"error"}`
+   * or `{type:"turn.failed"}` SDK event). Only stashes when the message
+   * contains the usage-limit signature AND carries a parseable wall-clock
+   * reset time. "Try again later." and workspace-credit branches fall through
+   * to the runner's tier-3 fallback instead.
+   * Last call wins — multiple events per session are deduped to the latest.
+   */
+  processCodexUsageLimitMessage(message: string): void {
+    if (!message) return;
+    if (!/usage limit|hit your usage/i.test(message)) return;
+
+    const iso = parseCodexRateLimitResetTime(message);
+    if (!iso) return;
+
+    const candidateMs = new Date(iso).getTime();
+    if (!Number.isFinite(candidateMs)) return;
+    this.rateLimitResetAtMs = clampRateLimitResetMs(candidateMs);
+  }
+
   /**
    * Returns the stashed rate limit reset time as an ISO string, or undefined
    * if no rejected rate_limit_event was seen in this session.
@@ -173,7 +214,14 @@ export class SessionErrorTracker {
 
   /** Check if the failure was due to a missing/stale session ID */
   isSessionNotFound(): boolean {
-    return this.errors.some((e) => e.message.includes("No conversation found with session ID"));
+    return this.errors.some((e) => {
+      const message = e.message.toLowerCase();
+      return (
+        message.includes("no conversation found with session id") ||
+        (message.includes("--resume requires a valid session id") &&
+          message.includes("does not match any session title"))
+      );
+    });
   }
 
   getErrors(): ReadonlyArray<ErrorSignal> {
@@ -250,6 +298,76 @@ const MONTH_NAMES: Record<string, number> = {
   december: 11,
 };
 
+/**
+ * Parse the reset time embedded in a Codex `UsageLimitReached` error message.
+ * Codex emits one of these formats via chrono's `%-I:%M %p` (same day) or
+ * `%b %-d{th/st/nd/rd}, %Y %-I:%M %p` (different day):
+ *   "Try again at 8:35 PM."
+ *   "or try again at 8:35 PM."
+ *   "Try again at May 26th, 2026 8:35 PM."
+ *   "or try again at May 26th, 2026 8:35 PM."
+ * Wall-clock times are UTC because the agent-swarm Docker worker has TZ=Etc/UTC;
+ * chrono::Local resolves to UTC in that container.
+ */
+export function parseCodexRateLimitResetTime(
+  message: string,
+  now: Date = new Date(),
+): string | undefined {
+  if (!message) return undefined;
+
+  // Different-day format (more specific — try first):
+  // "Month Day{st/nd/rd/th}, Year HH:MM AM/PM"
+  const datedMatch = message.match(
+    /\btry again at\s+([A-Za-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?,\s+(\d{4})\s+(\d{1,2}):(\d{2})\s*(AM|PM|am|pm)\b/i,
+  );
+  if (datedMatch) {
+    const monthIdx = MONTH_NAMES[datedMatch[1]!.toLowerCase()];
+    if (monthIdx !== undefined) {
+      const day = Number.parseInt(datedMatch[2]!, 10);
+      const year = Number.parseInt(datedMatch[3]!, 10);
+      const rawHours = Number.parseInt(datedMatch[4]!, 10);
+      const minutes = Number.parseInt(datedMatch[5]!, 10);
+      const ampm = datedMatch[6]!.toLowerCase();
+      if (rawHours < 1 || rawHours > 12 || minutes < 0 || minutes > 59) return undefined;
+      let hours = rawHours;
+      if (ampm === "pm" && hours !== 12) hours += 12;
+      if (ampm === "am" && hours === 12) hours = 0;
+      const d = new Date(Date.UTC(year, monthIdx, day, hours, minutes, 0));
+      // Round-trip guard: Date.UTC silently normalises out-of-range days (e.g. May 32 → June 1).
+      if (d.getUTCFullYear() !== year || d.getUTCMonth() !== monthIdx || d.getUTCDate() !== day) {
+        return undefined;
+      }
+      return d.toISOString();
+    }
+  }
+
+  // Same-day format: "HH:MM AM/PM"
+  // Anchored on "try again at" so we don't match times elsewhere in the message.
+  const timeMatch = message.match(/\btry again at\s+(\d{1,2}):(\d{2})\s*(AM|PM|am|pm)\b/i);
+  if (timeMatch) {
+    const rawHours = Number.parseInt(timeMatch[1]!, 10);
+    const minutes = Number.parseInt(timeMatch[2]!, 10);
+    const ampm = timeMatch[3]!.toLowerCase();
+    if (rawHours < 1 || rawHours > 12 || minutes < 0 || minutes > 59) return undefined;
+    let hours = rawHours;
+    if (ampm === "pm" && hours !== 12) hours += 12;
+    if (ampm === "am" && hours === 12) hours = 0;
+    const candidate = new Date(
+      Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), hours, minutes, 0),
+    );
+    // Rollover: if the parsed wall-clock is more than SKEW_MS before "now", assume tomorrow.
+    // At-or-just-before-now candidates (clock skew, second truncation) stay same-day and
+    // flow to clampRateLimitResetMs which applies the now+60s floor.
+    const SKEW_MS = 2 * 60 * 1000;
+    if (candidate.getTime() < now.getTime() - SKEW_MS) {
+      candidate.setUTCDate(candidate.getUTCDate() + 1);
+    }
+    return candidate.toISOString();
+  }
+
+  return undefined;
+}
+
 /**
  * Parse a rate limit error message to extract a reset time, returning an ISO datetime string.
  * Handles patterns like:
@@ -338,12 +456,7 @@ export function parseStderrForErrors(stderr: string, tracker: SessionErrorTracke
   const lower = stderr.toLowerCase();
   const firstLine = stderr.trim().split("\n")[0] ?? stderr.trim();
 
-  if (
-    lower.includes("rate limit") ||
-    lower.includes("rate_limit") ||
-    lower.includes("429") ||
-    lower.includes("hit your limit")
-  ) {
+  if (isRateLimitMessage(stderr)) {
     tracker.addStderrError(firstLine);
   } else if (
     lower.includes("authentication") ||

package/src/utils/skills-refresh.ts

@@ -0,0 +1,123 @@
+/**
+ * Worker-side per-task skill refresh.
+ *
+ * Polls the cheap signature endpoint; on a hash mismatch, refetches the
+ * full skill list and re-runs filesystem sync (claude/pi/codex dirs). The
+ * worker stores the signature returned in the list response so the cached
+ * hash always corresponds exactly to the snapshot it acted on — avoids a
+ * stale-hash race between the signature and list endpoints.
+ *
+ * Transient errors are swallowed (returned as `changed: false`) so a flaky
+ * API can't churn the system prompt.
+ */
+
+export type SkillsRefreshContext = {
+  apiUrl: string;
+  swarmUrl: string;
+  apiKey: string;
+  agentId: string;
+  role: string;
+};
+
+export type SkillsRefreshResult = {
+  changed: boolean;
+  summary?: { name: string; description: string }[];
+};
+
+export async function refreshSkillsIfChanged(
+  ctx: SkillsRefreshContext,
+  lastHashRef: { current: string | null },
+): Promise<SkillsRefreshResult> {
+  const { apiUrl, swarmUrl, apiKey, agentId, role } = ctx;
+  const authHeaders: Record<string, string> = { "X-Agent-ID": agentId };
+  if (apiKey) authHeaders.Authorization = `Bearer ${apiKey}`;
+
+  // Step 1: cheap signature probe
+  try {
+    const sigResp = await fetch(`${apiUrl}/api/agents/${agentId}/skills/signature`, {
+      headers: authHeaders,
+    });
+    if (sigResp.ok) {
+      const sig = (await sigResp.json()) as { hash: string };
+      if (lastHashRef.current !== null && sig.hash === lastHashRef.current) {
+        return { changed: false };
+      }
+    } else if (sigResp.status >= 500) {
+      // Transient — don't churn the prompt on a flaky API
+      return { changed: false };
+    }
+    // 4xx falls through (e.g. fresh worker hitting a legacy server without
+    // the signature endpoint yet) — let the list call drive the result.
+  } catch {
+    return { changed: false };
+  }
+
+  // Step 2: full fetch + sync (only reached when hash differs or first call)
+  let summary: { name: string; description: string }[] | undefined;
+  let newHash: string | null = null;
+  try {
+    const skillsResp = await fetch(`${apiUrl}/api/agents/${agentId}/skills`, {
+      headers: authHeaders,
+    });
+    if (skillsResp.ok) {
+      const skillsData = (await skillsResp.json()) as {
+        skills: { name: string; description: string; isActive: boolean; isEnabled: boolean }[];
+        signature?: string;
+      };
+      summary = skillsData.skills
+        .filter((s) => s.isActive && s.isEnabled)
+        .map((s) => ({ name: s.name, description: s.description }));
+      if (typeof skillsData.signature === "string") {
+        newHash = skillsData.signature;
+      }
+    }
+  } catch {
+    // Non-fatal — skills are optional
+  }
+
+  // Step 3: filesystem sync (claude/pi/codex dirs)
+  let syncOk = false;
+  try {
+    const syncHeaders: Record<string, string> = {
+      "Content-Type": "application/json",
+      "X-Agent-ID": agentId,
+    };
+    if (apiKey) syncHeaders.Authorization = `Bearer ${apiKey}`;
+    const syncRes = await fetch(`${swarmUrl}/api/skills/sync-filesystem`, {
+      method: "POST",
+      headers: syncHeaders,
+    });
+    if (syncRes.ok) {
+      const syncResult = (await syncRes.json()) as {
+        synced: number;
+        removed: number;
+        errors: string[];
+      };
+      console.log(
+        `[${role}] Skills synced: ${syncResult.synced} written, ${syncResult.removed} removed`,
+      );
+      if (syncResult.errors.length > 0) {
+        console.warn(`[${role}] Skill sync errors: ${syncResult.errors.join(", ")}`);
+      }
+      syncOk = true;
+    } else {
+      console.warn(`[${role}] Skill sync failed: HTTP ${syncRes.status}`);
+    }
+  } catch (err) {
+    console.warn(`[${role}] Skill sync failed: ${(err as Error).message}`);
+  }
+
+  if (summary === undefined && newHash === null) {
+    return { changed: false };
+  }
+
+  // Only cache the new hash once the FS sync has actually succeeded —
+  // otherwise a transient sync failure would leave the cached hash matching
+  // the current signature, causing later polls to short-circuit and the
+  // disk state to stay stale until an unrelated skill mutation. The next
+  // poll re-enters this code path (lastHashRef unchanged) and retries.
+  if (syncOk && newHash !== null) {
+    lastHashRef.current = newHash;
+  }
+  return { changed: true, summary };
+}