@desplega.ai/agent-swarm 1.71.2 → 1.72.0

package/src/http/session-data.ts

@@ -3,6 +3,7 @@ import { z } from "zod";
 import {
   createSessionCost,
   createSessionLogs,
+  getActivePricingRow,
   getAllSessionCosts,
   getDashboardCostSummary,
   getSessionCostSummary,
@@ -12,7 +13,7 @@ import {
   getSessionLogsByTaskId,
   getTaskById,
 } from "../be/db";
-import type { SessionCost } from "../types";
+import type { SessionCost, SessionCostSource } from "../types";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
 
@@ -69,6 +70,18 @@ const createSessionCostRoute = route({
     numTurns: z.number().int().optional(),
     model: z.string().optional(),
     isError: z.boolean().optional(),
+    /**
+     * Phase 6: when present, drives the codex pricing-table recompute path.
+     * Other providers ('claude' / 'pi') always trust harness-reported USD.
+     * Optional / undefined keeps back-compat for existing callers.
+     */
+    provider: z.enum(["claude", "codex", "pi"]).optional(),
+    /**
+     * Phase 6: epoch-ms timestamp used as the "active price at time T" lookup
+     * basis. Defaults to `Date.now()` when omitted. Including it lets
+     * historical recomputes pick the correct `effective_from` row.
+     */
+    createdAt: z.number().int().nonnegative().optional(),
   }),
   responses: {
     201: { description: "Cost record stored" },
@@ -170,19 +183,54 @@ export async function handleSessionData(
     if (!parsed) return true;
 
     try {
+      const inputTokens = parsed.body.inputTokens ?? 0;
+      const cachedInputTokens = parsed.body.cacheReadTokens ?? 0;
+      const outputTokens = parsed.body.outputTokens ?? 0;
+      const model = parsed.body.model || "opus";
+
+      // Phase 6: Codex USD recompute. When the worker reports `provider='codex'`
+      // and DB pricing rows exist for ALL three token classes at the lookup
+      // time, recompute `totalCostUsd` from tokens × DB prices and tag the
+      // row as 'pricing-table'. If any class has no row, fall back to the
+      // worker-reported value with `costSource='harness'` (back-compat for
+      // unseeded models). Claude / pi paths always use 'harness'.
+      let totalCostUsd = parsed.body.totalCostUsd;
+      let costSource: SessionCostSource = "harness";
+
+      if (parsed.body.provider === "codex") {
+        const lookupTime = parsed.body.createdAt ?? Date.now();
+        const inputRow = getActivePricingRow("codex", model, "input", lookupTime);
+        const cachedRow = getActivePricingRow("codex", model, "cached_input", lookupTime);
+        const outputRow = getActivePricingRow("codex", model, "output", lookupTime);
+
+        if (inputRow && cachedRow && outputRow) {
+          // Mirror the existing computeCodexCostUsd logic: subtract cached
+          // tokens from input before billing the uncached portion at the full
+          // rate (Codex SDK reports input_tokens as TOTAL across the turn).
+          const uncachedInputTokens = Math.max(0, inputTokens - cachedInputTokens);
+          totalCostUsd =
+            (uncachedInputTokens * inputRow.pricePerMillionUsd +
+              cachedInputTokens * cachedRow.pricePerMillionUsd +
+              outputTokens * outputRow.pricePerMillionUsd) /
+            1_000_000;
+          costSource = "pricing-table";
+        }
+      }
+
       const cost = createSessionCost({
         sessionId: parsed.body.sessionId,
         taskId: parsed.body.taskId || undefined,
         agentId: parsed.body.agentId,
-        totalCostUsd: parsed.body.totalCostUsd,
-        inputTokens: parsed.body.inputTokens ?? 0,
-        outputTokens: parsed.body.outputTokens ?? 0,
-        cacheReadTokens: parsed.body.cacheReadTokens ?? 0,
+        totalCostUsd,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens: cachedInputTokens,
         cacheWriteTokens: parsed.body.cacheWriteTokens ?? 0,
         durationMs: parsed.body.durationMs ?? 0,
         numTurns: parsed.body.numTurns ?? 1,
-        model: parsed.body.model || "opus",
+        model,
         isError: parsed.body.isError ?? false,
+        costSource,
       });
       json(res, { success: true, cost }, 201);
     } catch (error) {

package/src/http/tasks.ts

@@ -20,6 +20,7 @@ import {
 } from "../be/db";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { telemetry } from "../telemetry";
+import { ProviderNameSchema } from "../types";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
 
@@ -78,7 +79,22 @@ const updateClaudeSession = route({
   summary: "Update Claude session ID for a task",
   tags: ["Tasks"],
   params: z.object({ id: z.string() }),
-  body: z.object({ claudeSessionId: z.string().min(1) }),
+  body: z.union([
+    z.object({
+      claudeSessionId: z.string().min(1),
+      provider: z.literal("devin"),
+      providerMeta: z.object({
+        sessionUrl: z.string(),
+        maxAcuLimit: z.number().optional(),
+        acuCostUsd: z.number().optional(),
+      }),
+    }),
+    z.object({
+      claudeSessionId: z.string().min(1),
+      provider: ProviderNameSchema.exclude(["devin"]).optional(),
+      providerMeta: z.object({}).optional(),
+    }),
+  ]),
   responses: {
     200: { description: "Session ID updated" },
     404: { description: "Task not found" },
@@ -291,7 +307,12 @@ export async function handleTasks(
   if (updateClaudeSession.match(req.method, pathSegments)) {
     const parsed = await updateClaudeSession.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    const task = updateTaskClaudeSessionId(parsed.params.id, parsed.body.claudeSessionId);
+    const task = updateTaskClaudeSessionId(
+      parsed.params.id,
+      parsed.body.claudeSessionId,
+      parsed.body.provider,
+      parsed.body.providerMeta,
+    );
     if (!task) {
       jsonError(res, "Task not found", 404);
       return true;

package/src/prompts/base-prompt.ts

@@ -7,6 +7,7 @@
  * still assembled here based on runtime state.
  */
 
+import type { ProviderTraits } from "../providers/types";
 import { resolveTemplateAsync } from "./resolver";
 
 // Side-effect import: register all system + session templates
@@ -27,6 +28,7 @@ export type BasePromptArgs = {
   agentId: string;
   swarmUrl: string;
   capabilities?: string[];
+  traits?: ProviderTraits;
   name?: string;
   description?: string;
   soulMd?: string;
@@ -53,17 +55,25 @@ export type BasePromptArgs = {
 };
 
 export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
-  const { role, agentId, swarmUrl } = args;
+  const { role, agentId, swarmUrl, traits } = args;
+  const { hasMcp = true, hasLocalEnvironment: hasLocalEnv = true } = traits ?? {};
 
   const vars: Record<string, string> = { role, agentId, swarmUrl };
 
-  // Resolve the composite session template (lead or worker)
-  const compositeEventType = role === "lead" ? "system.session.lead" : "system.session.worker";
+  // Resolve the composite session template (trait-aware for remote providers)
+  let compositeEventType: string;
+  if (!hasMcp) {
+    // If no MCP, role cannot be lead
+    compositeEventType = "system.session.worker.remote";
+  } else {
+    compositeEventType = role === "lead" ? "system.session.lead" : "system.session.worker";
+  }
   const compositeResult = await resolveTemplateAsync(compositeEventType, vars);
   let prompt = compositeResult.text;
 
   // Conditionally inject Slack instructions for workers with Slack-originated tasks
-  if (role !== "lead" && args.slackContext) {
+  // Skip for providers without MCP — they can't call Slack tools (slack-reply, etc.)
+  if (role !== "lead" && args.slackContext && hasMcp) {
     const slackResult = await resolveTemplateAsync("system.agent.worker.slack", {
       slackChannelId: args.slackContext.channelId,
       slackThreadTs: args.slackContext.threadTs ?? "",
@@ -71,8 +81,21 @@ export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
     prompt += slackResult.text;
   }
 
-  // Inject agent identity (soul + identity + name/description) if available
-  if (args.soulMd || args.identityMd || args.name) {
+  // Inject agent identity
+  if (!hasLocalEnv) {
+    // Simplified identity for remote providers — no self-evolution, no /workspace files
+    prompt += "\n\n## Your Identity\n\n";
+    if (args.name) {
+      prompt += `**Name:** ${args.name}\n`;
+      if (args.description) {
+        prompt += `**Description:** ${args.description}\n`;
+      }
+      prompt += "\n";
+    }
+    prompt += `You are part of an agent swarm managed by the Desplega platform. `;
+    prompt += `You receive tasks from the swarm's lead agent and execute them independently. `;
+    prompt += `Focus on quality work and clear communication of results.\n`;
+  } else if (args.soulMd || args.identityMd || args.name) {
     prompt += "\n\n## Your Identity\n\n";
     if (args.name) {
       prompt += `**Name:** ${args.name}\n`;
@@ -90,13 +113,14 @@ export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
   }
 
   // Installed skills section (progressive disclosure — name + description only)
-  if (args.skillsSummary && args.skillsSummary.length > 0) {
+  // Skip for providers without MCP — skills require the Skill MCP tool
+  if (hasMcp && args.skillsSummary && args.skillsSummary.length > 0) {
     const summaries = args.skillsSummary.map((s) => `- /${s.name}: ${s.description}`).join("\n");
     prompt += `\n\n## Installed Skills\n\nThe following skills are available. Use the Skill tool to invoke them by name.\n\n${summaries}\n`;
   }
 
-  // Installed MCP servers section
-  if (args.mcpServersSummary) {
+  // Installed MCP servers section — skip for providers without MCP
+  if (hasMcp && args.mcpServersSummary) {
     prompt += `\n\n## Installed MCP Servers\n\nThe following MCP servers are configured for your use:\n${args.mcpServersSummary}\n`;
   }
 
@@ -108,13 +132,15 @@ export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
       prompt += `WARNING: ${args.repoContext.warning}\n\n`;
     }
 
-    if (args.repoContext.claudeMd) {
-      prompt += `The following CLAUDE.md is from the repository cloned at \`${args.repoContext.clonePath}\`. `;
-      prompt += `**IMPORTANT: These instructions apply ONLY when working within the \`${args.repoContext.clonePath}\` directory.** `;
-      prompt += `Do NOT apply these rules to files outside that directory.\n\n`;
-      prompt += `${args.repoContext.claudeMd}\n`;
-    } else if (!args.repoContext.warning) {
-      prompt += `Repository is cloned at \`${args.repoContext.clonePath}\` but has no CLAUDE.md file.\n`;
+    if (hasLocalEnv) {
+      if (args.repoContext.claudeMd) {
+        prompt += `The following CLAUDE.md is from the repository cloned at \`${args.repoContext.clonePath}\`. `;
+        prompt += `**IMPORTANT: These instructions apply ONLY when working within the \`${args.repoContext.clonePath}\` directory.** `;
+        prompt += `Do NOT apply these rules to files outside that directory.\n\n`;
+        prompt += `${args.repoContext.claudeMd}\n`;
+      } else if (!args.repoContext.warning) {
+        prompt += `Repository is cloned at \`${args.repoContext.clonePath}\` but has no CLAUDE.md file.\n`;
+      }
     }
 
     // Inject repo guidelines
@@ -153,73 +179,77 @@ export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
     }
   }
 
-  // Build conditional suffix (sections that depend on runtime env/capabilities)
-  let conditionalSuffix = "";
-
-  // Conditionally include agent-fs instructions when available
-  if (process.env.AGENT_FS_API_URL) {
-    const sharedOrgId = process.env.AGENT_FS_SHARED_ORG_ID || "YOUR_SHARED_ORG_ID";
-    const agentFsResult = await resolveTemplateAsync("system.agent.agent_fs", {
-      agentId,
-      sharedOrgId,
-    });
-    conditionalSuffix += agentFsResult.text;
-  }
+  // Skip conditional suffix and truncatable sections for remote providers — these
+  // reference local Docker environment features (agent-fs, services, artifacts, /workspace files)
+  if (hasLocalEnv) {
+    // Build conditional suffix (sections that depend on runtime env/capabilities)
+    let conditionalSuffix = "";
+
+    // Conditionally include agent-fs instructions when available
+    if (process.env.AGENT_FS_API_URL) {
+      const sharedOrgId = process.env.AGENT_FS_SHARED_ORG_ID || "YOUR_SHARED_ORG_ID";
+      const agentFsResult = await resolveTemplateAsync("system.agent.agent_fs", {
+        agentId,
+        sharedOrgId,
+      });
+      conditionalSuffix += agentFsResult.text;
+    }
 
-  if (!args.capabilities || args.capabilities.includes("services")) {
-    const servicesResult = await resolveTemplateAsync("system.agent.services", {
-      agentId,
-      swarmUrl,
-    });
-    conditionalSuffix += servicesResult.text;
-  }
+    if (!args.capabilities || args.capabilities.includes("services")) {
+      const servicesResult = await resolveTemplateAsync("system.agent.services", {
+        agentId,
+        swarmUrl,
+      });
+      conditionalSuffix += servicesResult.text;
+    }
 
-  if (!args.capabilities || args.capabilities.includes("artifacts")) {
-    const artifactsResult = await resolveTemplateAsync("system.agent.artifacts", {});
-    conditionalSuffix += artifactsResult.text;
-  }
+    if (!args.capabilities || args.capabilities.includes("artifacts")) {
+      const artifactsResult = await resolveTemplateAsync("system.agent.artifacts", {});
+      conditionalSuffix += artifactsResult.text;
+    }
 
-  if (args.capabilities) {
-    conditionalSuffix += `
+    if (args.capabilities) {
+      conditionalSuffix += `
 ### Capabilities enabled for this agent:
 
 - ${args.capabilities.join("\n- ")}
 `;
-  }
+    }
 
-  // Inject truncatable sections with per-section and total character caps
-  // Priority: agent CLAUDE.md > tools (tools cut first when over total budget)
-  const protectedLength = prompt.length + conditionalSuffix.length;
-  const totalBudget = Math.max(0, BOOTSTRAP_TOTAL_MAX_CHARS - protectedLength);
-  let totalUsed = 0;
-
-  // Agent CLAUDE.md (higher priority — injected first)
-  if (args.claudeMd) {
-    const perSectionBudget = Math.min(BOOTSTRAP_MAX_CHARS, totalBudget - totalUsed);
-    const section = truncateSection(
-      args.claudeMd,
-      "## Agent Instructions",
-      "CLAUDE.md",
-      perSectionBudget,
-    );
-    prompt += section;
-    totalUsed += section.length;
-  }
+    // Inject truncatable sections with per-section and total character caps
+    // Priority: agent CLAUDE.md > tools (tools cut first when over total budget)
+    const protectedLength = prompt.length + conditionalSuffix.length;
+    const totalBudget = Math.max(0, BOOTSTRAP_TOTAL_MAX_CHARS - protectedLength);
+    let totalUsed = 0;
+
+    // Agent CLAUDE.md (higher priority — injected first)
+    if (args.claudeMd) {
+      const perSectionBudget = Math.min(BOOTSTRAP_MAX_CHARS, totalBudget - totalUsed);
+      const section = truncateSection(
+        args.claudeMd,
+        "## Agent Instructions",
+        "CLAUDE.md",
+        perSectionBudget,
+      );
+      prompt += section;
+      totalUsed += section.length;
+    }
 
-  // Tools (lower priority — gets whatever budget remains)
-  if (args.toolsMd) {
-    const perSectionBudget = Math.min(BOOTSTRAP_MAX_CHARS, totalBudget - totalUsed);
-    const section = truncateSection(
-      args.toolsMd,
-      "## Your Tools & Capabilities",
-      "TOOLS.md",
-      perSectionBudget,
-    );
-    prompt += section;
-    totalUsed += section.length;
-  }
+    // Tools (lower priority — gets whatever budget remains)
+    if (args.toolsMd) {
+      const perSectionBudget = Math.min(BOOTSTRAP_MAX_CHARS, totalBudget - totalUsed);
+      const section = truncateSection(
+        args.toolsMd,
+        "## Your Tools & Capabilities",
+        "TOOLS.md",
+        perSectionBudget,
+      );
+      prompt += section;
+      totalUsed += section.length;
+    }
 
-  prompt += conditionalSuffix;
+    prompt += conditionalSuffix;
+  }
 
   return prompt;
 };

package/src/prompts/session-templates.ts

@@ -520,3 +520,46 @@ registerTemplate({
   ],
   category: "session",
 });
+
+// ============================================================================
+// Remote provider templates (no MCP, no Docker container)
+// ============================================================================
+
+registerTemplate({
+  eventType: "system.agent.worker.remote",
+  header: "",
+  defaultBody: `
+As a worker agent of the swarm, you are responsible for executing tasks assigned by the lead agent.
+
+- Each worker focuses on specific tasks or objectives, contributing to the overall goals of the swarm.
+- Workers MUST report their progress back to the lead and collaborate with other workers as needed.
+
+#### How Tasks Work
+
+You receive tasks via the session prompt. Each task has a description of what needs to be done.
+
+#### Completing Tasks
+
+When you finish a task:
+- Provide a clear summary of what you accomplished in your final message
+- If you created a PR, include the PR URL
+- If you encountered blockers, explain what blocked you and what you tried
+
+Your output is captured automatically — focus on doing the work and communicating results clearly.
+`,
+  variables: [],
+  category: "system",
+});
+
+registerTemplate({
+  eventType: "system.session.worker.remote",
+  header: "",
+  defaultBody: `{{@template[system.agent.role]}}
+
+{{@template[system.agent.worker.remote]}}`,
+  variables: [
+    { name: "role", description: "The agent's role" },
+    { name: "agentId", description: "The agent's unique identifier" },
+  ],
+  category: "session",
+});

package/src/providers/claude-adapter.ts

@@ -394,7 +394,7 @@ class ClaudeSession implements ProviderSession {
       // Session ID from init message
       if (json.type === "system" && json.subtype === "init" && json.session_id) {
         this._sessionId = json.session_id;
-        this.emit({ type: "session_init", sessionId: json.session_id });
+        this.emit({ type: "session_init", sessionId: json.session_id, provider: "claude" });
         if (json.model) {
           this.contextWindowSize = getContextWindowSize(json.model);
         }
@@ -434,6 +434,7 @@ class ClaudeSession implements ProviderSession {
           numTurns: json.num_turns || 1,
           model: this.model,
           isError: json.is_error || false,
+          provider: "claude",
         };
         setCost(cost);
         this.emit({
@@ -568,6 +569,7 @@ class ClaudeSession implements ProviderSession {
 
 export class ClaudeAdapter implements ProviderAdapter {
   readonly name = "claude";
+  readonly traits = { hasMcp: true, hasLocalEnvironment: true };
 
   async createSession(config: ProviderSessionConfig): Promise<ProviderSession> {
     const model = config.model || "opus";