@desplega.ai/agent-swarm 1.56.6 → 1.57.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.56.6",
+  "version": "1.57.0",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",

package/src/be/db.ts

@@ -727,6 +727,8 @@ type AgentTaskRow = {
   totalContextTokensUsed: number | null;
   contextWindowSize: number | null;
   was_paused: number;
+  credentialKeySuffix: string | null;
+  credentialKeyType: string | null;
 };
 
 function rowToAgentTask(row: AgentTaskRow): AgentTask {
@@ -780,6 +782,8 @@ function rowToAgentTask(row: AgentTaskRow): AgentTask {
     output: row.output ?? undefined,
     progress: row.progress ?? undefined,
     wasPaused: !!row.was_paused,
+    credentialKeySuffix: row.credentialKeySuffix ?? undefined,
+    credentialKeyType: row.credentialKeyType ?? undefined,
   };
 }
 
@@ -7575,10 +7579,9 @@ export function recordKeyUsage(
 
   // Record which key was used on the task
   if (taskId) {
-    db.prepare("UPDATE agent_tasks SET credentialKeySuffix = ? WHERE id = ?").run(
-      keySuffix,
-      taskId,
-    );
+    db.prepare(
+      "UPDATE agent_tasks SET credentialKeySuffix = ?, credentialKeyType = ? WHERE id = ?",
+    ).run(keySuffix, keyType, taskId);
   }
 }
 
@@ -7641,3 +7644,43 @@ export function getKeyStatuses(
     .prepare<ApiKeyStatus, string[]>(`SELECT * FROM api_key_status ${where} ORDER BY keyIndex`)
     .all(...params);
 }
+
+export interface KeyCostSummary {
+  keyType: string;
+  keySuffix: string;
+  totalCost: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  taskCount: number;
+}
+
+/**
+ * Aggregate cost data per API key by joining session_costs through agent_tasks.
+ */
+export function getKeyCostSummary(keyType?: string): KeyCostSummary[] {
+  const db = getDb();
+  const conditions = ["t.credentialKeySuffix IS NOT NULL"];
+  const params: string[] = [];
+
+  if (keyType) {
+    conditions.push("t.credentialKeyType = ?");
+    params.push(keyType);
+  }
+
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  return db
+    .prepare<KeyCostSummary, string[]>(
+      `SELECT
+        t.credentialKeyType as keyType,
+        t.credentialKeySuffix as keySuffix,
+        COALESCE(SUM(sc.totalCostUsd), 0) as totalCost,
+        COALESCE(SUM(sc.inputTokens), 0) as totalInputTokens,
+        COALESCE(SUM(sc.outputTokens), 0) as totalOutputTokens,
+        COUNT(DISTINCT sc.taskId) as taskCount
+      FROM session_costs sc
+      JOIN agent_tasks t ON sc.taskId = t.id
+      ${where}
+      GROUP BY t.credentialKeyType, t.credentialKeySuffix`,
+    )
+    .all(...params);
+}

package/src/be/migrations/029_task_credential_key_type.sql

@@ -0,0 +1,2 @@
+-- Store which credential type (env var name) was used per task
+ALTER TABLE agent_tasks ADD COLUMN credentialKeyType TEXT;

package/src/http/api-keys.ts

@@ -2,6 +2,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
 import {
   getAvailableKeyIndices,
+  getKeyCostSummary,
   getKeyStatuses,
   markKeyRateLimited,
   recordKeyUsage,
@@ -93,6 +94,22 @@ const listStatuses = route({
   auth: { apiKey: true },
 });
 
+const getCosts = route({
+  method: "get",
+  path: "/api/keys/costs",
+  pattern: ["api", "keys", "costs"],
+  summary: "Get aggregated cost data per API key",
+  tags: ["API Keys"],
+  query: z.object({
+    keyType: z.string().optional(),
+  }),
+  responses: {
+    200: { description: "Per-key cost aggregation" },
+    401: { description: "Unauthorized" },
+  },
+  auth: { apiKey: true },
+});
+
 // ─── Handler ─────────────────────────────────────────────────────────────────
 
 export async function handleApiKeys(
@@ -149,6 +166,21 @@ export async function handleApiKeys(
     return true;
   }
 
+  // GET /api/keys/costs
+  if (getCosts.match(req.method, pathSegments)) {
+    const parsed = await getCosts.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const { keyType } = parsed.query;
+    try {
+      const costs = getKeyCostSummary(keyType);
+      json(res, { success: true, costs });
+    } catch (err) {
+      jsonError(res, err instanceof Error ? err.message : "Failed to get key costs", 500);
+    }
+    return true;
+  }
+
   // GET /api/keys/status
   if (listStatuses.match(req.method, pathSegments)) {
     const parsed = await listStatuses.parse(req, res, pathSegments, queryParams);

package/src/tests/api-key-tracking.test.ts

@@ -103,12 +103,16 @@ describe("resolveCredentialPools", () => {
     expect(env.ANTHROPIC_API_KEY).toBe("key-ccc33");
   });
 
-  test("non-pool vars are unchanged", async () => {
+  test("single keys are tracked with index 0", async () => {
     const env: Record<string, string | undefined> = {
       ANTHROPIC_API_KEY: "single-key",
     };
     const selections = await resolveCredentialPools(env);
-    expect(selections.length).toBe(0);
+    expect(selections.length).toBe(1);
+    expect(selections[0]!.index).toBe(0);
+    expect(selections[0]!.total).toBe(1);
+    expect(selections[0]!.keySuffix).toBe("e-key");
+    expect(selections[0]!.keyType).toBe("ANTHROPIC_API_KEY");
     expect(env.ANTHROPIC_API_KEY).toBe("single-key");
   });
 });

package/src/types.ts

@@ -149,6 +149,10 @@ export const AgentTaskSchema = z.object({
   peakContextPercent: z.number().min(0).max(100).optional(),
   totalContextTokensUsed: z.number().int().min(0).optional(),
   contextWindowSize: z.number().int().min(0).optional(),
+
+  // Credential tracking
+  credentialKeySuffix: z.string().optional(),
+  credentialKeyType: z.string().optional(),
 });
 
 export const AgentStatusSchema = z.enum(["idle", "busy", "offline"]);

package/src/utils/credentials.ts

@@ -91,8 +91,8 @@ async function fetchAvailableIndices(
   const availableIndicesMap: Record<string, number[]> = {};
   for (const envVar of CREDENTIAL_POOL_VARS) {
     const val = env[envVar];
-    if (val?.includes(",")) {
-      const totalKeys = val.split(",").filter((s) => s.trim()).length;
+    if (val) {
+      const totalKeys = val.includes(",") ? val.split(",").filter((s) => s.trim()).length : 1;
       try {
         const resp = await fetch(
           `${apiUrl}/api/keys/available?keyType=${encodeURIComponent(envVar)}&totalKeys=${totalKeys}`,
@@ -134,7 +134,7 @@ export async function resolveCredentialPools(
   const selections: CredentialSelection[] = [];
   for (const envVar of CREDENTIAL_POOL_VARS) {
     const val = env[envVar];
-    if (val?.includes(",")) {
+    if (val) {
       const available = availableIndicesMap?.[envVar];
       const result = selectCredential(val, available, envVar);
       env[envVar] = result.selected;