@desplega.ai/agent-swarm 1.52.1 → 1.53.0

package/src/http/events.ts

@@ -0,0 +1,188 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { z } from "zod";
+import {
+  createEvent,
+  createEventsBatch,
+  getEventCountsFiltered,
+  getEventsFiltered,
+} from "../be/events";
+import {
+  EventCategorySchema,
+  EventNameSchema,
+  EventSourceSchema,
+  EventStatusSchema,
+} from "../types";
+import { route } from "./route-def";
+import { json, jsonError } from "./utils";
+
+// ─── Route Definitions ───────────────────────────────────────────────────────
+
+const eventBodySchema = z.object({
+  category: EventCategorySchema,
+  event: EventNameSchema,
+  status: EventStatusSchema.optional(),
+  source: EventSourceSchema,
+  agentId: z.string().optional(),
+  taskId: z.string().optional(),
+  sessionId: z.string().optional(),
+  parentEventId: z.string().optional(),
+  numericValue: z.number().optional(),
+  durationMs: z.number().int().optional(),
+  data: z.record(z.string(), z.unknown()).optional(),
+});
+
+const createEventRoute = route({
+  method: "post",
+  path: "/api/events",
+  pattern: ["api", "events"],
+  summary: "Store a single event",
+  tags: ["Events"],
+  body: eventBodySchema,
+  responses: {
+    201: { description: "Event stored" },
+    400: { description: "Validation error" },
+  },
+  auth: { apiKey: true },
+});
+
+const createEventsBatchRoute = route({
+  method: "post",
+  path: "/api/events/batch",
+  pattern: ["api", "events", "batch"],
+  summary: "Store multiple events in a batch",
+  tags: ["Events"],
+  body: z.object({
+    events: z.array(eventBodySchema).min(1).max(500),
+  }),
+  responses: {
+    201: { description: "Events stored" },
+    400: { description: "Validation error" },
+  },
+  auth: { apiKey: true },
+});
+
+const getEventsRoute = route({
+  method: "get",
+  path: "/api/events",
+  pattern: ["api", "events"],
+  summary: "Query events with filters",
+  tags: ["Events"],
+  query: z.object({
+    category: EventCategorySchema.optional(),
+    event: EventNameSchema.optional(),
+    status: EventStatusSchema.optional(),
+    source: EventSourceSchema.optional(),
+    agentId: z.string().optional(),
+    taskId: z.string().optional(),
+    sessionId: z.string().optional(),
+    since: z.string().optional(),
+    until: z.string().optional(),
+    limit: z.coerce.number().int().min(1).max(1000).optional(),
+  }),
+  responses: {
+    200: { description: "List of events" },
+  },
+  auth: { apiKey: true },
+});
+
+const getEventCountsRoute = route({
+  method: "get",
+  path: "/api/events/counts",
+  pattern: ["api", "events", "counts"],
+  summary: "Get event counts grouped by event name",
+  tags: ["Events"],
+  query: z.object({
+    category: EventCategorySchema.optional(),
+    source: EventSourceSchema.optional(),
+    agentId: z.string().optional(),
+    taskId: z.string().optional(),
+    sessionId: z.string().optional(),
+    since: z.string().optional(),
+    until: z.string().optional(),
+  }),
+  responses: {
+    200: { description: "Event counts" },
+  },
+  auth: { apiKey: true },
+});
+
+// ─── Handler ─────────────────────────────────────────────────────────────────
+
+export async function handleEvents(
+  req: IncomingMessage,
+  res: ServerResponse,
+  pathSegments: string[],
+  queryParams: URLSearchParams,
+  _myAgentId: string | undefined,
+): Promise<boolean> {
+  // Match batch BEFORE generic /api/events (POST)
+  if (createEventsBatchRoute.match(req.method, pathSegments)) {
+    const parsed = await createEventsBatchRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    try {
+      const count = createEventsBatch(parsed.body.events);
+      json(res, { success: true, count }, 201);
+    } catch (error) {
+      console.error("[HTTP] Failed to create events batch:", error);
+      jsonError(res, "Failed to store events batch", 500);
+    }
+    return true;
+  }
+
+  // Match counts BEFORE generic /api/events (GET)
+  if (getEventCountsRoute.match(req.method, pathSegments)) {
+    const parsed = await getEventCountsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const counts = getEventCountsFiltered({
+      category: parsed.query.category || undefined,
+      source: parsed.query.source || undefined,
+      agentId: parsed.query.agentId || undefined,
+      taskId: parsed.query.taskId || undefined,
+      sessionId: parsed.query.sessionId || undefined,
+      since: parsed.query.since || undefined,
+      until: parsed.query.until || undefined,
+    });
+    json(res, { counts });
+    return true;
+  }
+
+  // POST /api/events — single event
+  if (createEventRoute.match(req.method, pathSegments)) {
+    const parsed = await createEventRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    try {
+      const event = createEvent(parsed.body);
+      json(res, { success: true, event }, 201);
+    } catch (error) {
+      console.error("[HTTP] Failed to create event:", error);
+      jsonError(res, "Failed to store event", 500);
+    }
+    return true;
+  }
+
+  // GET /api/events — filtered query
+  if (getEventsRoute.match(req.method, pathSegments)) {
+    const parsed = await getEventsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const events = getEventsFiltered({
+      category: parsed.query.category || undefined,
+      event: parsed.query.event || undefined,
+      status: parsed.query.status || undefined,
+      source: parsed.query.source || undefined,
+      agentId: parsed.query.agentId || undefined,
+      taskId: parsed.query.taskId || undefined,
+      sessionId: parsed.query.sessionId || undefined,
+      since: parsed.query.since || undefined,
+      until: parsed.query.until || undefined,
+      limit: parsed.query.limit ?? 100,
+    });
+    json(res, { events });
+    return true;
+  }
+
+  return false;
+}

package/src/http/index.ts

@@ -19,11 +19,14 @@ import { handleActiveSessions } from "./active-sessions";
 import { handleAgentRegister, handleAgentsRest } from "./agents";
 import { handleApprovalRequests } from "./approval-requests";
 import { handleConfig } from "./config";
+import { handleContext } from "./context";
 import { handleCore, loadGlobalConfigsIntoEnv } from "./core";
 import { handleDbQuery } from "./db-query";
 import { handleEcosystem } from "./ecosystem";
 import { handleEpics } from "./epics";
+import { handleEvents } from "./events";
 import { handleMcp } from "./mcp";
+import { handleMcpServers } from "./mcp-servers";
 import { handleMemory } from "./memory";
 import { handlePoll } from "./poll";
 import { handlePromptTemplates } from "./prompt-templates";
@@ -102,6 +105,7 @@ const httpServer = createHttpServer(async (req, res) => {
     () => handleTrackers(req, res, pathSegments),
     () => handleWebhooks(req, res, pathSegments),
     () => handleAgentsRest(req, res, pathSegments, queryParams, myAgentId),
+    () => handleContext(req, res, pathSegments, queryParams, myAgentId),
     () => handleTasks(req, res, pathSegments, queryParams, myAgentId),
     () => handleStats(req, res, pathSegments, queryParams),
     () => handleActiveSessions(req, res, pathSegments, queryParams, myAgentId),
@@ -114,7 +118,9 @@ const httpServer = createHttpServer(async (req, res) => {
     () => handleDbQuery(req, res, pathSegments, queryParams),
     () => handleRepos(req, res, pathSegments, queryParams),
     () => handleSkills(req, res, pathSegments, queryParams, myAgentId),
+    () => handleMcpServers(req, res, pathSegments, queryParams),
     () => handleMemory(req, res, pathSegments, myAgentId),
+    () => handleEvents(req, res, pathSegments, queryParams, myAgentId),
     () => handleMcp(req, res, transports),
   ];
 

package/src/http/mcp-servers.ts

@@ -0,0 +1,364 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { z } from "zod";
+import {
+  createMcpServer,
+  deleteMcpServer,
+  getAgentMcpServers,
+  getMcpServerById,
+  getResolvedConfig,
+  installMcpServer,
+  listMcpServers,
+  uninstallMcpServer,
+  updateMcpServer,
+} from "../be/db";
+import { route } from "./route-def";
+import { json, jsonError } from "./utils";
+
+// ─── Route Definitions ───────────────────────────────────────────────────────
+
+const listMcpServersRoute = route({
+  method: "get",
+  path: "/api/mcp-servers",
+  pattern: ["api", "mcp-servers"],
+  summary: "List MCP servers with optional filters",
+  tags: ["MCP Servers"],
+  auth: { apiKey: true },
+  query: z.object({
+    scope: z.string().optional(),
+    transport: z.string().optional(),
+    ownerAgentId: z.string().optional(),
+    enabled: z.string().optional(),
+    search: z.string().optional(),
+  }),
+  responses: {
+    200: { description: "MCP server list" },
+  },
+});
+
+const getMcpServerRoute = route({
+  method: "get",
+  path: "/api/mcp-servers/{id}",
+  pattern: ["api", "mcp-servers", null],
+  summary: "Get MCP server by ID",
+  tags: ["MCP Servers"],
+  auth: { apiKey: true },
+  params: z.object({ id: z.string() }),
+  responses: {
+    200: { description: "MCP server details" },
+    404: { description: "MCP server not found" },
+  },
+});
+
+const createMcpServerRoute = route({
+  method: "post",
+  path: "/api/mcp-servers",
+  pattern: ["api", "mcp-servers"],
+  summary: "Create a new MCP server",
+  tags: ["MCP Servers"],
+  auth: { apiKey: true },
+  body: z.object({
+    name: z.string().min(1),
+    transport: z.enum(["stdio", "http", "sse"]),
+    description: z.string().optional(),
+    scope: z.string().optional(),
+    ownerAgentId: z.string().optional(),
+    command: z.string().optional(),
+    args: z.string().optional(),
+    url: z.string().optional(),
+    headers: z.string().optional(),
+    envConfigKeys: z.string().optional(),
+    headerConfigKeys: z.string().optional(),
+  }),
+  responses: {
+    201: { description: "MCP server created" },
+    400: { description: "Validation error" },
+  },
+});
+
+const updateMcpServerRoute = route({
+  method: "put",
+  path: "/api/mcp-servers/{id}",
+  pattern: ["api", "mcp-servers", null],
+  summary: "Update an MCP server",
+  tags: ["MCP Servers"],
+  auth: { apiKey: true },
+  params: z.object({ id: z.string() }),
+  body: z.record(z.string(), z.unknown()),
+  responses: {
+    200: { description: "MCP server updated" },
+    404: { description: "MCP server not found" },
+  },
+});
+
+const deleteMcpServerRoute = route({
+  method: "delete",
+  path: "/api/mcp-servers/{id}",
+  pattern: ["api", "mcp-servers", null],
+  summary: "Delete an MCP server",
+  tags: ["MCP Servers"],
+  auth: { apiKey: true },
+  params: z.object({ id: z.string() }),
+  responses: {
+    200: { description: "MCP server deleted" },
+    404: { description: "MCP server not found" },
+  },
+});
+
+const installMcpServerRoute = route({
+  method: "post",
+  path: "/api/mcp-servers/{id}/install",
+  pattern: ["api", "mcp-servers", null, "install"],
+  summary: "Install MCP server for an agent",
+  tags: ["MCP Servers"],
+  auth: { apiKey: true },
+  params: z.object({ id: z.string() }),
+  body: z.object({
+    agentId: z.string(),
+  }),
+  responses: {
+    200: { description: "MCP server installed" },
+    404: { description: "MCP server not found" },
+  },
+});
+
+const uninstallMcpServerRoute = route({
+  method: "delete",
+  path: "/api/mcp-servers/{id}/install/{agentId}",
+  pattern: ["api", "mcp-servers", null, "install", null],
+  summary: "Uninstall MCP server for an agent",
+  tags: ["MCP Servers"],
+  auth: { apiKey: true },
+  params: z.object({ id: z.string(), agentId: z.string() }),
+  responses: {
+    200: { description: "MCP server uninstalled" },
+  },
+});
+
+const getAgentMcpServersRoute = route({
+  method: "get",
+  path: "/api/agents/{id}/mcp-servers",
+  pattern: ["api", "agents", null, "mcp-servers"],
+  summary: "Get all MCP servers installed for an agent",
+  tags: ["MCP Servers"],
+  auth: { apiKey: true },
+  params: z.object({ id: z.string() }),
+  query: z.object({
+    resolveSecrets: z.string().optional(),
+  }),
+  responses: {
+    200: { description: "Agent MCP servers list" },
+  },
+});
+
+// ─── Handler ─────────────────────────────────────────────────────────────────
+
+export async function handleMcpServers(
+  req: IncomingMessage,
+  res: ServerResponse,
+  pathSegments: string[],
+  queryParams: URLSearchParams,
+): Promise<boolean> {
+  // GET /api/agents/:id/mcp-servers (must be before /api/mcp-servers routes)
+  if (getAgentMcpServersRoute.match(req.method, pathSegments)) {
+    const parsed = await getAgentMcpServersRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const servers = getAgentMcpServers(parsed.params.id);
+    const resolveSecrets = parsed.query.resolveSecrets === "true";
+
+    if (resolveSecrets) {
+      const configs = getResolvedConfig(parsed.params.id);
+      const configMap = new Map(configs.map((c) => [c.key, c.value]));
+
+      const serversWithSecrets = servers.map((server) => {
+        const resolvedEnv: Record<string, string> = {};
+        const resolvedHeaders: Record<string, string> = {};
+
+        // Resolve env config keys (JSON object: {"ENV_VAR": "config-key-name"})
+        if (server.envConfigKeys) {
+          try {
+            const mapping = JSON.parse(server.envConfigKeys) as Record<string, string>;
+            for (const [envVar, configKey] of Object.entries(mapping)) {
+              const value = configMap.get(configKey);
+              if (value !== undefined) {
+                resolvedEnv[envVar] = value;
+              }
+            }
+          } catch {
+            // Invalid JSON — skip resolution
+          }
+        }
+
+        // Resolve header config keys (JSON object: {"Header-Name": "config-key-name"})
+        if (server.headerConfigKeys) {
+          try {
+            const mapping = JSON.parse(server.headerConfigKeys) as Record<string, string>;
+            for (const [headerName, configKey] of Object.entries(mapping)) {
+              const value = configMap.get(configKey);
+              if (value !== undefined) {
+                resolvedHeaders[headerName] = value;
+              }
+            }
+          } catch {
+            // Invalid JSON — skip resolution
+          }
+        }
+
+        return { ...server, resolvedEnv, resolvedHeaders };
+      });
+
+      json(res, { servers: serversWithSecrets, total: serversWithSecrets.length });
+    } else {
+      json(res, { servers, total: servers.length });
+    }
+    return true;
+  }
+
+  // POST /api/mcp-servers/:id/install
+  if (installMcpServerRoute.match(req.method, pathSegments)) {
+    const parsed = await installMcpServerRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const server = getMcpServerById(parsed.params.id);
+    if (!server) {
+      jsonError(res, "MCP server not found", 404);
+      return true;
+    }
+
+    try {
+      const agentMcpServer = installMcpServer(parsed.body.agentId, parsed.params.id);
+      json(res, { agentMcpServer });
+    } catch (err) {
+      jsonError(res, err instanceof Error ? err.message : "Install failed", 400);
+    }
+    return true;
+  }
+
+  // DELETE /api/mcp-servers/:id/install/:agentId
+  if (uninstallMcpServerRoute.match(req.method, pathSegments)) {
+    const parsed = await uninstallMcpServerRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const removed = uninstallMcpServer(parsed.params.agentId, parsed.params.id);
+    json(res, { success: removed });
+    return true;
+  }
+
+  // GET /api/mcp-servers
+  if (listMcpServersRoute.match(req.method, pathSegments)) {
+    const parsed = await listMcpServersRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const servers = listMcpServers({
+      scope: parsed.query.scope as "global" | "swarm" | "agent" | undefined,
+      transport: parsed.query.transport as "stdio" | "http" | "sse" | undefined,
+      ownerAgentId: parsed.query.ownerAgentId,
+      isEnabled: parsed.query.enabled !== undefined ? parsed.query.enabled === "true" : undefined,
+      search: parsed.query.search,
+    });
+
+    json(res, { servers, total: servers.length });
+    return true;
+  }
+
+  // GET /api/mcp-servers/:id
+  if (getMcpServerRoute.match(req.method, pathSegments)) {
+    const parsed = await getMcpServerRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const server = getMcpServerById(parsed.params.id);
+    if (!server) {
+      jsonError(res, "MCP server not found", 404);
+      return true;
+    }
+    json(res, server);
+    return true;
+  }
+
+  // POST /api/mcp-servers
+  if (createMcpServerRoute.match(req.method, pathSegments)) {
+    const parsed = await createMcpServerRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    // Transport-specific validation
+    if (parsed.body.transport === "stdio" && !parsed.body.command) {
+      jsonError(res, "command is required for stdio transport", 400);
+      return true;
+    }
+    if ((parsed.body.transport === "http" || parsed.body.transport === "sse") && !parsed.body.url) {
+      jsonError(res, "url is required for http/sse transport", 400);
+      return true;
+    }
+
+    try {
+      const server = createMcpServer({
+        name: parsed.body.name,
+        transport: parsed.body.transport,
+        description: parsed.body.description,
+        scope: parsed.body.scope as "global" | "swarm" | "agent" | undefined,
+        ownerAgentId: parsed.body.ownerAgentId,
+        command: parsed.body.command,
+        args: parsed.body.args,
+        url: parsed.body.url,
+        headers: parsed.body.headers,
+        envConfigKeys: parsed.body.envConfigKeys,
+        headerConfigKeys: parsed.body.headerConfigKeys,
+      });
+      json(res, { server }, 201);
+    } catch (err) {
+      jsonError(res, err instanceof Error ? err.message : "Create failed", 400);
+    }
+    return true;
+  }
+
+  // PUT /api/mcp-servers/:id
+  if (updateMcpServerRoute.match(req.method, pathSegments)) {
+    const parsed = await updateMcpServerRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    // Transport-specific validation on update (only if transport is being set)
+    const transport = parsed.body.transport as string | undefined;
+    if (transport === "stdio" && parsed.body.command === undefined) {
+      // Check if existing server already has a command
+      const existing = getMcpServerById(parsed.params.id);
+      if (existing && !existing.command && !parsed.body.command) {
+        jsonError(res, "command is required for stdio transport", 400);
+        return true;
+      }
+    }
+    if ((transport === "http" || transport === "sse") && parsed.body.url === undefined) {
+      const existing = getMcpServerById(parsed.params.id);
+      if (existing && !existing.url && !parsed.body.url) {
+        jsonError(res, "url is required for http/sse transport", 400);
+        return true;
+      }
+    }
+
+    const server = updateMcpServer(
+      parsed.params.id,
+      parsed.body as Parameters<typeof updateMcpServer>[1],
+    );
+    if (!server) {
+      jsonError(res, "MCP server not found", 404);
+      return true;
+    }
+    json(res, { server });
+    return true;
+  }
+
+  // DELETE /api/mcp-servers/:id
+  if (deleteMcpServerRoute.match(req.method, pathSegments)) {
+    const parsed = await deleteMcpServerRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+
+    const deleted = deleteMcpServer(parsed.params.id);
+    if (!deleted) {
+      jsonError(res, "MCP server not found", 404);
+      return true;
+    }
+    json(res, { success: true });
+    return true;
+  }
+
+  return false;
+}

package/src/http/tasks.ts

@@ -17,6 +17,7 @@ import {
   updateAgentStatusFromCapacity,
   updateTaskClaudeSessionId,
   updateTaskProgress,
+  updateTaskVcs,
 } from "../be/db";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
@@ -187,6 +188,26 @@ const resumeTaskRoute = route({
   },
 });
 
+const updateTaskVcsRoute = route({
+  method: "patch",
+  path: "/api/tasks/{id}/vcs",
+  pattern: ["api", "tasks", null, "vcs"],
+  summary: "Update VCS (PR/MR) info for a task",
+  tags: ["Tasks"],
+  params: z.object({ id: z.string() }),
+  body: z.object({
+    vcsProvider: z.enum(["github", "gitlab"]),
+    vcsRepo: z.string(),
+    vcsNumber: z.number().int().positive(),
+    vcsUrl: z.string().url(),
+  }),
+  responses: {
+    200: { description: "VCS info updated" },
+    404: { description: "Task not found" },
+  },
+  auth: { apiKey: true },
+});
+
 // ─── Handler ─────────────────────────────────────────────────────────────────
 
 export async function handleTasks(
@@ -515,6 +536,18 @@ export async function handleTasks(
     return true;
   }
 
+  if (updateTaskVcsRoute.match(req.method, pathSegments)) {
+    const parsed = await updateTaskVcsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const task = updateTaskVcs(parsed.params.id, parsed.body);
+    if (!task) {
+      jsonError(res, "Task not found", 404);
+      return true;
+    }
+    json(res, task);
+    return true;
+  }
+
   if (resumeTaskRoute.match(req.method, pathSegments)) {
     const parsed = await resumeTaskRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;

package/src/linear/outbound.ts

@@ -1,6 +1,7 @@
 import { getTrackerSync, updateTrackerSync } from "../be/db-queries/tracker";
+import { ensureToken } from "../oauth/ensure-token";
 import { workflowEventBus } from "../workflows/event-bus";
-import { getLinearClient } from "./client";
+import { getLinearClient, resetLinearClient } from "./client";
 import { endAgentSession, postAgentSessionAction, taskSessionMap } from "./sync";
 
 let subscribed = false;
@@ -85,6 +86,8 @@ async function handleTaskCompleted(data: unknown): Promise<void> {
   } else {
     // No session — fall back to issue comment
     try {
+      await ensureToken("linear");
+      resetLinearClient(); // Clear cached client so it picks up refreshed token
       const client = getLinearClient();
       if (!client) {
         console.log("[Linear Outbound] No Linear client available, skipping sync for", taskId);
@@ -133,6 +136,8 @@ async function handleTaskFailed(data: unknown): Promise<void> {
   } else {
     // No session — fall back to issue comment
     try {
+      await ensureToken("linear");
+      resetLinearClient(); // Clear cached client so it picks up refreshed token
       const client = getLinearClient();
       if (!client) {
         console.log("[Linear Outbound] No Linear client available, skipping sync for", taskId);
@@ -180,6 +185,8 @@ async function handleTaskCancelled(data: unknown): Promise<void> {
     console.log(`[Linear Outbound] Posted cancellation to AgentSession for task ${taskId}`);
   } else {
     try {
+      await ensureToken("linear");
+      resetLinearClient(); // Clear cached client so it picks up refreshed token
       const client = getLinearClient();
       if (!client) {
         console.log("[Linear Outbound] No Linear client available, skipping sync for", taskId);

package/src/linear/sync.ts

@@ -6,6 +6,7 @@ import {
   getTrackerSyncByExternalId,
   updateTrackerSync,
 } from "../be/db-queries/tracker";
+import { ensureToken } from "../oauth/ensure-token";
 import { resolveTemplate } from "../prompts/resolver";
 // Side-effect import: registers all Linear event templates in the in-memory registry
 import "./templates";
@@ -46,6 +47,7 @@ async function postAgentActivity(
     | { type: "thought" | "response" | "error"; body: string }
     | { type: "action"; action: string; parameter?: string; result?: string },
 ): Promise<boolean> {
+  await ensureToken("linear");
   const tokens = getOAuthTokens("linear");
   if (!tokens) {
     console.log("[Linear Sync] No OAuth tokens, cannot post AgentSession activity");
@@ -96,6 +98,7 @@ async function updateAgentSession(
   sessionId: string,
   input: Record<string, unknown>,
 ): Promise<boolean> {
+  await ensureToken("linear");
   const tokens = getOAuthTokens("linear");
   if (!tokens) {
     console.log("[Linear Sync] No OAuth tokens, cannot update AgentSession");