@desplega.ai/agent-swarm 1.71.2 → 1.72.0

package/src/providers/claude-managed-models.ts

@@ -0,0 +1,117 @@
+/**
+ * Pricing table for Anthropic-managed Claude models, mirroring the layout of
+ * `src/providers/codex-models.ts`. Rates are USD per million tokens (Mtok)
+ * sourced from https://platform.claude.com/docs/en/about-claude/pricing
+ * (verified 2026-04-28).
+ *
+ * The managed-agents API does NOT report dollar cost on the `span.model_request_end`
+ * event — only token counts (`input_tokens`, `output_tokens`,
+ * `cache_read_input_tokens`, `cache_creation_input_tokens`). Phase 4 of the
+ * provider plan computes USD locally via {@link computeClaudeManagedCostUsd},
+ * then folds in Anthropic's $0.08/session-hour runtime fee inside the adapter.
+ *
+ * Bump this file when Anthropic publishes new rates or new models.
+ *
+ * Cache nomenclature mapping:
+ * - `cache_read_input_tokens`        → "cache hit" rate     (cheapest)
+ * - `cache_creation_input_tokens`    → "cache write" rate   (input × 1.25 for 5m TTL)
+ * - regular `input_tokens` (uncached) → standard input rate
+ *
+ * Anthropic's pricing page lists 5-minute and 1-hour cache TTLs separately;
+ * managed-agents currently uses the 5-minute breakpoint by default, which is
+ * the rate captured here. If a future SDK release surfaces TTL on the usage
+ * payload, refine these by TTL.
+ */
+
+/** Models supported by the managed-agents surface for the swarm worker. */
+export const CLAUDE_MANAGED_MODELS = [
+  "claude-sonnet-4-6",
+  "claude-opus-4-7",
+  "claude-haiku-4-5",
+] as const;
+
+export type ClaudeManagedModel = (typeof CLAUDE_MANAGED_MODELS)[number];
+
+/** Pricing per million tokens (USD). */
+export interface ClaudeManagedModelPricing {
+  /** USD per million uncached input tokens. */
+  inputPerMillion: number;
+  /** USD per million output tokens. */
+  outputPerMillion: number;
+  /** USD per million tokens read from prompt cache. */
+  cacheReadPerMillion: number;
+  /** USD per million tokens written to prompt cache (5-minute TTL). */
+  cacheWritePerMillion: number;
+}
+
+/**
+ * Anthropic public list pricing as of 2026-04-28. Source:
+ * https://platform.claude.com/docs/en/about-claude/pricing
+ *
+ * - claude-sonnet-4-6: $3 / $15 / $0.30 / $3.75    (in / out / cache-read / cache-write)
+ * - claude-opus-4-7:   $15 / $75 / $1.50 / $18.75
+ * - claude-haiku-4-5:  $1 / $5 / $0.10 / $1.25
+ */
+export const CLAUDE_MANAGED_MODEL_PRICING: Record<ClaudeManagedModel, ClaudeManagedModelPricing> = {
+  "claude-sonnet-4-6": {
+    inputPerMillion: 3.0,
+    outputPerMillion: 15.0,
+    cacheReadPerMillion: 0.3,
+    cacheWritePerMillion: 3.75,
+  },
+  "claude-opus-4-7": {
+    inputPerMillion: 15.0,
+    outputPerMillion: 75.0,
+    cacheReadPerMillion: 1.5,
+    cacheWritePerMillion: 18.75,
+  },
+  "claude-haiku-4-5": {
+    inputPerMillion: 1.0,
+    outputPerMillion: 5.0,
+    cacheReadPerMillion: 0.1,
+    cacheWritePerMillion: 1.25,
+  },
+};
+
+/**
+ * Models we've already warned about — keeps `console.warn` from spamming the
+ * worker logs when an old session keeps replaying through `span.model_request_end`
+ * events with an unrecognized model string.
+ */
+const warnedUnknownModels = new Set<string>();
+
+/**
+ * Compute USD cost for one Claude managed-agents session, given the SDK's
+ * accumulated token counts.
+ *
+ * Returns `0` (with a deduplicated `console.warn`) for unknown model strings —
+ * we'd rather under-report than make up a number on a typo.
+ *
+ * Note: the runtime $0.08/session-hour fee is NOT folded in here. The adapter
+ * computes that separately because it depends on the session's wallclock
+ * `durationMs`, which is provider-state, not token-state.
+ */
+export function computeClaudeManagedCostUsd(
+  model: string,
+  inputTokens: number,
+  outputTokens: number,
+  cacheReadTokens: number,
+  cacheWriteTokens: number,
+): number {
+  const pricing = CLAUDE_MANAGED_MODEL_PRICING[model as ClaudeManagedModel];
+  if (!pricing) {
+    if (!warnedUnknownModels.has(model)) {
+      warnedUnknownModels.add(model);
+      console.warn(
+        `[claude-managed-models] Unknown model "${model}" — returning $0 cost. ` +
+          `Add it to CLAUDE_MANAGED_MODEL_PRICING in src/providers/claude-managed-models.ts.`,
+      );
+    }
+    return 0;
+  }
+  const inputCost = (inputTokens / 1_000_000) * pricing.inputPerMillion;
+  const outputCost = (outputTokens / 1_000_000) * pricing.outputPerMillion;
+  const cacheReadCost = (cacheReadTokens / 1_000_000) * pricing.cacheReadPerMillion;
+  const cacheWriteCost = (cacheWriteTokens / 1_000_000) * pricing.cacheWritePerMillion;
+  return inputCost + outputCost + cacheReadCost + cacheWriteCost;
+}

package/src/providers/claude-managed-swarm-events.ts

@@ -0,0 +1,77 @@
+/**
+ * Adapter-side swarm lifecycle hooks for the Claude Managed Agents provider.
+ *
+ * Phase 5 of the managed-agents rollout. Mirrors `codex-swarm-events.ts`:
+ * thin wrapper around `swarm-events-shared.ts` that wires the shared
+ * throttle/poll/heartbeat scaffolding to the managed-agents cancel pathway.
+ *
+ * ## Cancel callback semantics
+ *
+ * When the shared `checkCancelled` poll detects a cancellation, it (1) fires
+ * `abortRef.current?.abort()` and (2) invokes our `onCancel` callback. The
+ * callback issues `client.beta.sessions.events.send(sessionId, { events:
+ * [{ type: "user.interrupt" }] })` followed by
+ * `client.beta.sessions.archive(sessionId)`.
+ *
+ * Both calls are best-effort and `.catch()`-ed: an already-archived or
+ * already-terminated session returns errors that we don't want to leak into
+ * the event handler (which is supposed to be synchronous and never throw).
+ *
+ * The adapter's own `abort()` method does the same dance directly — this
+ * binding exists so EXTERNAL cancel polls (i.e. another worker process or
+ * the runner-side polling layer) can drive the same flow without going
+ * through `session.abort()`.
+ */
+
+import { createSwarmEventHandler, type SwarmEventHandlerOpts } from "./swarm-events-shared";
+import type { ProviderEvent } from "./types";
+
+/**
+ * Minimal slice of the managed-agents client surface we need to issue
+ * `user.interrupt` + archive. Kept as a structural type so this file doesn't
+ * have to import the full `ManagedAgentsClient` (and so unit tests can
+ * pass in a tiny stub).
+ */
+export interface ClaudeManagedCancelClient {
+  beta: {
+    sessions: {
+      archive: (sessionId: string) => unknown;
+      events: {
+        send: (sessionId: string, params: { events: Array<Record<string, unknown>> }) => unknown;
+      };
+    };
+  };
+}
+
+export interface ClaudeManagedSwarmEventHandlerOpts
+  extends Omit<SwarmEventHandlerOpts, "onCancel" | "sessionIdFallbackPrefix"> {
+  /** The Anthropic SDK client; used to send interrupt + archive on cancel. */
+  client: ClaudeManagedCancelClient;
+  /** The managed session currently in flight. */
+  managedSessionId: string;
+}
+
+/**
+ * Build a swarm-event handler that drives managed-agents cancel actions on
+ * top of the shared throttle/poll/heartbeat scaffolding.
+ */
+export function createClaudeManagedSwarmEventHandler(
+  opts: ClaudeManagedSwarmEventHandlerOpts,
+): (event: ProviderEvent) => void {
+  const { client, managedSessionId, ...shared } = opts;
+
+  return createSwarmEventHandler({
+    ...shared,
+    sessionIdFallbackPrefix: "claude-managed",
+    onCancel: () => {
+      // Fire-and-forget interrupt; swallow errors (already-archived sessions
+      // raise here and we don't want to leak that into the handler).
+      void Promise.resolve(
+        client.beta.sessions.events.send(managedSessionId, {
+          events: [{ type: "user.interrupt" }],
+        }),
+      ).catch(() => {});
+      void Promise.resolve(client.beta.sessions.archive(managedSessionId)).catch(() => {});
+    },
+  });
+}

package/src/providers/codex-adapter.ts

@@ -408,6 +408,7 @@ class CodexSession implements ProviderSession {
       numTurns: this.numTurns,
       model: this.resolvedModel,
       isError,
+      provider: "codex",
     };
   }
 
@@ -468,7 +469,7 @@ class CodexSession implements ProviderSession {
     switch (event.type) {
       case "thread.started": {
         this._sessionId = event.thread_id;
-        this.emit({ type: "session_init", sessionId: event.thread_id });
+        this.emit({ type: "session_init", sessionId: event.thread_id, provider: "codex" });
         break;
       }
       case "turn.started": {
@@ -742,6 +743,7 @@ class CodexSession implements ProviderSession {
 
 export class CodexAdapter implements ProviderAdapter {
   readonly name = "codex";
+  readonly traits = { hasMcp: true, hasLocalEnvironment: true };
 
   /**
    * Optional override for the skill resolver's skills directory. When unset,

package/src/providers/codex-skill-resolver.ts

@@ -30,6 +30,8 @@ import type { ProviderEvent } from "./types";
  */
 const SLASH_COMMAND_REGEX = /^\/([a-z0-9:_-]+)(?:\s+(.*))?$/;
 
+const MAX_SKILL_CHARS = Number(process.env.MAX_SKILL_CHARS) || 100_000;
+
 /**
  * Resolve the default skills directory for Codex.
  *
@@ -104,6 +106,14 @@ export async function resolveCodexPrompt(
     return prompt;
   }
 
+  if (skillContent.length > MAX_SKILL_CHARS) {
+    emit?.({
+      type: "raw_stderr",
+      content: `[codex] skill resolver: SKILL.md for /${commandName} exceeds ${MAX_SKILL_CHARS} chars (${skillContent.length}), truncating\n`,
+    });
+    skillContent = skillContent.slice(0, MAX_SKILL_CHARS);
+  }
+
   // Assemble the user-request body: trailing args from the slash line (if any),
   // plus any subsequent lines from the original prompt. Joined with a newline
   // so `/work-on-task foo\n\nproceed` becomes `foo\n\nproceed`.

package/src/providers/codex-swarm-events.ts

@@ -1,10 +1,12 @@
 /**
  * Adapter-side swarm lifecycle hooks for the Codex provider.
  *
- * Phase 5 of the codex provider rollout. Mirrors `pi-mono-extension.ts`
- * but adapted to the event-stream model: instead of pi-mono's
- * `pi.on("tool_call", ...)` extension API, we attach a single listener to
- * `CodexSession.onEvent(...)` and react to normalized `ProviderEvent`s.
+ * Phase 5 (managed-agents) extracted the throttle/poll/heartbeat scaffolding
+ * into `swarm-events-shared.ts`. This file is now a thin pass-through that
+ * preserves the codex-specific public API (`createCodexSwarmEventHandler`,
+ * `CodexSwarmEventHandlerOpts`) and adopts the shared implementation
+ * verbatim — same throttle constants, same `fireAndForget` semantics, same
+ * `try/catch` swallow-everything contract.
  *
  * ## Two-layer cancellation
  *
@@ -17,170 +19,27 @@
  * `AbortController`. This *accelerates* cancellation latency but does NOT
  * block tool execution — Codex's SDK lacks a preToolUse blocking hook
  * (unlike pi-mono's `block: true` return value).
- *
- * The handler MUST be synchronous from the caller's perspective. Every
- * fetch is fire-and-forget with `.catch(() => {})` so a single bad request
- * never breaks the session. The handler also never throws — `try/catch`
- * around the dispatch swallows everything for safety.
  */
 
-import { checkToolLoop } from "../hooks/tool-loop-detection";
+import { createSwarmEventHandler, type SwarmEventHandlerOpts } from "./swarm-events-shared";
 import type { ProviderEvent } from "./types";
 
-export interface CodexSwarmEventHandlerOpts {
-  apiUrl: string;
-  apiKey: string;
-  agentId: string;
-  /** Task currently being worked on. When null, all task-scoped hooks are no-ops. */
-  taskId: string | null;
-  /** Mutable reference to the session's per-turn AbortController. */
-  abortRef: { current: AbortController | null };
-}
-
-/** Throttle windows (ms) keyed by action name. */
-const CANCELLATION_THROTTLE_MS = 500;
-const HEARTBEAT_THROTTLE_MS = 5_000;
-const ACTIVITY_THROTTLE_MS = 5_000;
-const CONTEXT_THROTTLE_MS = 30_000;
-
-function apiHeaders(opts: CodexSwarmEventHandlerOpts): Record<string, string> {
-  return {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${opts.apiKey}`,
-    "X-Agent-ID": opts.agentId,
-  };
-}
-
-function fireAndForget(url: string, init: RequestInit): void {
-  void fetch(url, init).catch(() => {});
-}
+/**
+ * Codex-specific opts. Currently identical to the shared opts modulo the
+ * `onCancel` field (which codex doesn't use today). Re-exported so existing
+ * call sites (`codex-adapter.ts:303`) keep their import path stable.
+ */
+export type CodexSwarmEventHandlerOpts = Omit<
+  SwarmEventHandlerOpts,
+  "onCancel" | "sessionIdFallbackPrefix"
+>;
 
 /** Build the handler. The returned function reacts to normalized events. */
 export function createCodexSwarmEventHandler(
   opts: CodexSwarmEventHandlerOpts,
 ): (event: ProviderEvent) => void {
-  const lastCall: Record<string, number> = {};
-  let sessionId: string | undefined;
-
-  const shouldRun = (key: string, throttleMs: number): boolean => {
-    const now = Date.now();
-    if (now - (lastCall[key] ?? 0) < throttleMs) return false;
-    lastCall[key] = now;
-    return true;
-  };
-
-  const checkCancelled = (): void => {
-    const taskId = opts.taskId;
-    if (!taskId) return;
-    void (async () => {
-      try {
-        const res = await fetch(
-          `${opts.apiUrl}/cancelled-tasks?taskId=${encodeURIComponent(taskId)}`,
-          { headers: apiHeaders(opts) },
-        );
-        if (!res.ok) return;
-        const data = (await res.json()) as {
-          cancelled?: Array<{ id: string; failureReason?: string }>;
-        };
-        const isCancelled = data.cancelled?.some((t) => t.id === taskId);
-        if (isCancelled) {
-          opts.abortRef.current?.abort();
-        }
-      } catch {
-        // Swallow — fire-and-forget.
-      }
-    })();
-  };
-
-  const checkLoop = (toolName: string, args: unknown): void => {
-    const taskId = opts.taskId;
-    if (!taskId) return;
-    const argRecord = args && typeof args === "object" ? (args as Record<string, unknown>) : {};
-    void checkToolLoop(taskId, toolName, argRecord)
-      .then((result) => {
-        if (result.blocked) {
-          opts.abortRef.current?.abort();
-        }
-      })
-      .catch(() => {});
-  };
-
-  return (event: ProviderEvent): void => {
-    try {
-      switch (event.type) {
-        case "session_init": {
-          sessionId = event.sessionId;
-          break;
-        }
-        case "tool_start": {
-          if (shouldRun("cancellation", CANCELLATION_THROTTLE_MS)) {
-            checkCancelled();
-          }
-          checkLoop(event.toolName, event.args);
-          if (opts.taskId && shouldRun("heartbeat", HEARTBEAT_THROTTLE_MS)) {
-            fireAndForget(
-              `${opts.apiUrl}/api/active-sessions/heartbeat/${encodeURIComponent(opts.taskId)}`,
-              { method: "PUT", headers: apiHeaders(opts) },
-            );
-          }
-          if (shouldRun("activity", ACTIVITY_THROTTLE_MS)) {
-            fireAndForget(
-              `${opts.apiUrl}/api/agents/${encodeURIComponent(opts.agentId)}/activity`,
-              { method: "PUT", headers: apiHeaders(opts) },
-            );
-          }
-          break;
-        }
-        case "context_usage": {
-          if (opts.taskId && shouldRun("context-progress", CONTEXT_THROTTLE_MS)) {
-            fireAndForget(`${opts.apiUrl}/api/tasks/${encodeURIComponent(opts.taskId)}/context`, {
-              method: "POST",
-              headers: apiHeaders(opts),
-              body: JSON.stringify({
-                eventType: "progress",
-                sessionId: sessionId ?? `codex-${opts.taskId}`,
-                contextUsedTokens: event.contextUsedTokens,
-                contextTotalTokens: event.contextTotalTokens,
-                contextPercent: event.contextPercent,
-              }),
-            });
-          }
-          break;
-        }
-        case "compaction": {
-          if (opts.taskId) {
-            fireAndForget(`${opts.apiUrl}/api/tasks/${encodeURIComponent(opts.taskId)}/context`, {
-              method: "POST",
-              headers: apiHeaders(opts),
-              body: JSON.stringify({
-                eventType: "compaction",
-                sessionId: sessionId ?? `codex-${opts.taskId}`,
-                contextTotalTokens: event.contextTotalTokens,
-                preCompactTokens: event.preCompactTokens,
-                compactTrigger: event.compactTrigger,
-              }),
-            });
-          }
-          break;
-        }
-        case "result": {
-          // Final completion context event mirrors pi-mono's session_shutdown
-          // POST. The runner separately calls `/api/tasks/{id}/finish`.
-          if (opts.taskId) {
-            fireAndForget(`${opts.apiUrl}/api/tasks/${encodeURIComponent(opts.taskId)}/context`, {
-              method: "POST",
-              headers: apiHeaders(opts),
-              body: JSON.stringify({
-                eventType: "completion",
-                sessionId: sessionId ?? `codex-${opts.taskId}`,
-              }),
-            });
-          }
-          break;
-        }
-      }
-    } catch {
-      // Never throw from the handler — the event loop is hot.
-    }
-  };
+  return createSwarmEventHandler({
+    ...opts,
+    sessionIdFallbackPrefix: "codex",
+  });
 }