@desplega.ai/agent-swarm 1.150.0 → 1.151.0

package/src/tools/extension-common.ts

@@ -0,0 +1,84 @@
+import * as z from "zod";
+import { proxySwarmApi } from "./script-common";
+import { type RequestInfo, type SwarmToolResult, swarmToolOutputSchema, toolErr } from "./utils";
+
+export const EXTENSION_TRANSPORT_ERROR =
+  "extension_* tools require HTTP MCP transport because agent identity is unavailable over stdio. Use MCP_BASE_URL=http://... or invoke the HTTP API directly.";
+
+const extensionListItemSchema = z.looseObject({
+  id: z.string().optional(),
+  name: z.string().optional(),
+  version: z.number().optional(),
+  activeVersion: z.number().optional(),
+  enabled: z.boolean().optional(),
+  status: z.string().optional(),
+  priority: z.number().optional(),
+  consecutiveFailures: z.number().optional(),
+});
+
+export const extensionToolOutputSchema = swarmToolOutputSchema({
+  id: z.string().optional(),
+  name: z.string().optional(),
+  version: z.number().optional(),
+  activeVersion: z.number().optional(),
+  enabled: z.boolean().optional(),
+  status: z.string().optional(),
+  priority: z.number().optional(),
+  consecutiveFailures: z.number().optional(),
+  contentDeduped: z.boolean().optional(),
+  extensions: z.array(extensionListItemSchema).optional(),
+});
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function coerceExtensionSummary(entry: unknown) {
+  const extension = isRecord(entry) ? entry : {};
+  return {
+    id: typeof extension.id === "string" ? extension.id : undefined,
+    name: typeof extension.name === "string" ? extension.name : undefined,
+    version: typeof extension.version === "number" ? extension.version : undefined,
+    activeVersion:
+      typeof extension.activeVersion === "number" ? extension.activeVersion : undefined,
+    enabled: typeof extension.enabled === "boolean" ? extension.enabled : undefined,
+    status: typeof extension.status === "string" ? extension.status : undefined,
+    priority: typeof extension.priority === "number" ? extension.priority : undefined,
+    consecutiveFailures:
+      typeof extension.consecutiveFailures === "number" ? extension.consecutiveFailures : undefined,
+  };
+}
+
+function errorMessage(data: unknown, status: number): string {
+  if (isRecord(data) && typeof data.error === "string" && data.error) return data.error;
+  return `Extensions API request failed with ${status}`;
+}
+
+function renderDiagnostics(data: unknown): string | undefined {
+  if (!isRecord(data) || !Array.isArray(data.diagnostics)) return undefined;
+  const diagnostics = data.diagnostics.map(String).filter(Boolean);
+  return diagnostics.length > 0 ? diagnostics.join("\n") : undefined;
+}
+
+export async function proxyExtensionsApi<T>(args: {
+  method: "GET" | "POST";
+  path: string;
+  body?: unknown;
+  requestInfo: RequestInfo;
+  success: (data: unknown) => SwarmToolResult<T & Record<string, unknown>>;
+}): Promise<SwarmToolResult<T & Record<string, unknown>>> {
+  return proxySwarmApi({
+    ...args,
+    transportError: EXTENSION_TRANSPORT_ERROR,
+    respond: (data, response) => {
+      if (!response.ok) {
+        const diagnostics = renderDiagnostics(data);
+        if (response.status === 400 && diagnostics) {
+          return toolErr("Extension rejected by typecheck.", { details: diagnostics });
+        }
+        return toolErr(errorMessage(data, response.status), { details: diagnostics });
+      }
+      return args.success(data);
+    },
+  });
+}

package/src/tools/extension-install.ts

@@ -0,0 +1,65 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createToolRegistrar, toolOk } from "@/tools/utils";
+import { ExtensionManifestSchema } from "@/types";
+import {
+  coerceExtensionSummary,
+  extensionToolOutputSchema,
+  proxyExtensionsApi,
+} from "./extension-common";
+
+export const EXTENSION_INSTALL_DESCRIPTION =
+  "Validate and store a TypeScript extension bundle (manifest plus a files map with one hooks.ts). Fetch the hook contract first: GET /api/extensions/type-defs returns swarm-extension.d.ts with every event and modify shape. The extension remains disabled until an operator enables it.";
+
+function extensionInstallResult(data: unknown, fallbackName: string) {
+  const body = data as {
+    extension?: unknown;
+    contentDeduped?: unknown;
+  };
+  const extension = coerceExtensionSummary(body.extension);
+  const name = extension.name ?? fallbackName;
+  const version = typeof extension.version === "number" ? ` v${extension.version}` : "";
+  const deduped = body.contentDeduped === true ? " Content was unchanged." : "";
+  const enableInstruction =
+    "An operator must enable it from the dashboard or `POST /api/extensions/{id}/enable`.";
+
+  return toolOk(`Extension \`${name}\`${version} installed.${deduped} ${enableInstruction}`, {
+    data: {
+      ...extension,
+      name,
+      contentDeduped: body.contentDeduped === true,
+    },
+  });
+}
+
+export const registerExtensionInstallTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "extension-install",
+    {
+      title: "Extension Install",
+      description: EXTENSION_INSTALL_DESCRIPTION,
+      annotations: { openWorldHint: false },
+      inputSchema: z
+        .object({
+          manifest: ExtensionManifestSchema.describe("Extension bundle manifest."),
+          files: z.record(z.string(), z.string()).describe("Bundle files keyed by relative path."),
+          priority: z
+            .number()
+            .int()
+            .optional()
+            .describe("Handler priority. Lower values run first."),
+          config: z.record(z.string(), z.unknown()).optional().describe("Extension configuration."),
+        })
+        .strict(),
+      outputSchema: extensionToolOutputSchema,
+    },
+    async (args, requestInfo) =>
+      proxyExtensionsApi({
+        method: "POST",
+        path: "/api/extensions/install",
+        body: args,
+        requestInfo,
+        success: (data) => extensionInstallResult(data, args.manifest.name),
+      }),
+  );
+};

package/src/tools/extension-list.ts

@@ -0,0 +1,66 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createToolRegistrar, toolOk } from "@/tools/utils";
+import {
+  coerceExtensionSummary,
+  extensionToolOutputSchema,
+  proxyExtensionsApi,
+} from "./extension-common";
+
+export const EXTENSION_LIST_DESCRIPTION =
+  "List installed extensions and their activation state. To write a new one, fetch GET /api/extensions/type-defs for the hook contract and install it with extension-install.";
+
+type ExtensionListItem = ReturnType<typeof coerceExtensionSummary>;
+
+function extensionListItems(data: unknown): ExtensionListItem[] {
+  if (
+    typeof data !== "object" ||
+    data === null ||
+    !Array.isArray((data as { extensions?: unknown }).extensions)
+  ) {
+    return [];
+  }
+  return (data as { extensions: unknown[] }).extensions.map(coerceExtensionSummary);
+}
+
+function renderExtensionsTable(extensions: ExtensionListItem[]): string {
+  const header = "| Name | Version | Active | Enabled | Status | Priority | Failures |";
+  const divider = "| --- | ---: | ---: | --- | --- | ---: | ---: |";
+  const rows = extensions.map(
+    (extension) =>
+      `| ${extension.name ?? "?"} | ${extension.version ?? "?"} | ${extension.activeVersion ?? "?"} | ${extension.enabled ?? false} | ${extension.status ?? "unknown"} | ${extension.priority ?? "?"} | ${extension.consecutiveFailures ?? 0} |`,
+  );
+  return [header, divider, ...rows].join("\n");
+}
+
+export const registerExtensionListTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "extension-list",
+    {
+      title: "Extension List",
+      description: EXTENSION_LIST_DESCRIPTION,
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      inputSchema: z
+        .object({
+          enabledOnly: z.boolean().optional().describe("Return only enabled extensions."),
+        })
+        .strict(),
+      outputSchema: extensionToolOutputSchema,
+    },
+    async ({ enabledOnly }, requestInfo) =>
+      proxyExtensionsApi({
+        method: "GET",
+        path: "/api/extensions",
+        requestInfo,
+        success: (data) => {
+          const extensions = extensionListItems(data).filter(
+            (extension) => !enabledOnly || extension.enabled,
+          );
+          return toolOk(`Found ${extensions.length} extension(s).`, {
+            details: renderExtensionsTable(extensions),
+            data: { extensions },
+          });
+        },
+      }),
+  );
+};

package/src/tools/script-common.ts

@@ -3,6 +3,7 @@ import { getApiKey } from "@/utils/api-key";
 import { getMcpBaseUrl } from "@/utils/constants";
 import {
   type RequestInfo,
+  type SwarmToolData,
   type SwarmToolResult,
   swarmToolOutputSchema,
   toolErr,
@@ -161,7 +162,37 @@ export async function proxyScriptsApi(args: {
    */
   uncappedDetails?: boolean;
 }): Promise<SwarmToolResult> {
-  if (!args.requestInfo.agentId) return toolErr(SCRIPT_TRANSPORT_ERROR);
+  return proxySwarmApi({
+    ...args,
+    transportError: SCRIPT_TRANSPORT_ERROR,
+    respond: (data, res) => {
+      const toolData = { status: res.status, data };
+      const failure = describeScriptFailure(res.ok, res.status, data);
+      if (failure) {
+        return toolErr(failure.message, {
+          details: failure.details ?? capDetails(args.failureDetails?.(data)),
+          data: toolData,
+        });
+      }
+
+      const successDetails = args.successDetails?.(data);
+      return toolOk(args.successMessage(data), {
+        details: args.uncappedDetails ? successDetails : capDetails(successDetails),
+        data: toolData,
+      });
+    },
+  });
+}
+
+export async function proxySwarmApi<T extends Record<string, unknown>>(args: {
+  method: "GET" | "POST" | "PATCH" | "DELETE";
+  path: string;
+  body?: unknown;
+  requestInfo: RequestInfo;
+  transportError: string;
+  respond: (data: unknown, response: { ok: boolean; status: number }) => SwarmToolResult<T>;
+}): Promise<SwarmToolResult<T>> {
+  if (!args.requestInfo.agentId) return toolErr(args.transportError);
 
   const apiKey = getApiKey();
   const headers: Record<string, string> = {
@@ -172,8 +203,7 @@ export async function proxyScriptsApi(args: {
   if (args.requestInfo.sourceTaskId) {
     headers["X-Source-Task-Id"] = args.requestInfo.sourceTaskId;
   }
-  // Runtime identity is process context from the worker's MCP session — it
-  // rides the proxy like the agent identity, never as tool or script input.
+  // Forward runtime identity from the worker's MCP session, like agent identity.
   if (args.requestInfo.runtimeInstanceId) {
     headers["X-Runtime-Instance-ID"] = args.requestInfo.runtimeInstanceId;
   }
@@ -189,22 +219,17 @@ export async function proxyScriptsApi(args: {
     try {
       data = JSON.parse(text);
     } catch {
-      data = { error: text };
+      const contentType = res.headers.get("content-type") ?? "unknown";
+      // Transport-level failure: only `{ status }` is known here, and that shape
+      // is not statically related to the caller's `T`. Tool output schemas are
+      // loose with every data field optional, so the wire result stays valid.
+      const transportData: SwarmToolData = { status: res.status };
+      return toolErr<T>(
+        `Swarm API returned non-JSON response (HTTP ${res.status}, Content-Type: ${contentType}). Check API/proxy routing.`,
+        { details: capDetails(text), data: transportData as T },
+      );
     }
   }
 
-  const toolData = { status: res.status, data };
-  const failure = describeScriptFailure(res.ok, res.status, data);
-  if (failure) {
-    return toolErr(failure.message, {
-      details: failure.details ?? capDetails(args.failureDetails?.(data)),
-      data: toolData,
-    });
-  }
-
-  const successDetails = args.successDetails?.(data);
-  return toolOk(args.successMessage(data), {
-    details: args.uncappedDetails ? successDetails : capDetails(successDetails),
-    data: toolData,
-  });
+  return args.respond(data, res);
 }

package/src/tools/send-task.ts

@@ -15,6 +15,7 @@ import {
   hasCapacity,
 } from "@/be/db";
 import { repointTrackerSyncBySwarmId } from "@/be/db-queries/tracker";
+import { applyPreTaskCreate } from "@/extensions/apply-task-create";
 import { checkSlackRoutingCoherence } from "@/tasks/slack-routing";
 import { findDuplicateTask } from "@/tools/task-dedup";
 import { ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
@@ -28,6 +29,7 @@ import {
 import {
   type AgentTask,
   AssetKeySchema,
+  type CreateTaskOptions,
   FollowUpConfigSchema,
   ModelTierSchema,
   ReasoningEffortSchema,
@@ -382,6 +384,53 @@ export async function sendTaskHandler(
   const effectiveRoutingSource =
     agentId !== undefined ? "declared" : effectiveAgentId ? "engine_default" : undefined;
 
+  const requestedTaskOptions: CreateTaskOptions = {
+    key: assetKey,
+    agentId: offerMode ? undefined : effectiveAgentId,
+    offeredTo: offerMode ? effectiveAgentId : undefined,
+    creatorAgentId,
+    requestedByUserId,
+    source: "mcp",
+    sourceTaskId,
+    taskType,
+    tags,
+    priority,
+    dependsOn,
+    dir,
+    parentTaskId: effectiveParentTaskId,
+    vcsRepo: effectiveVcsRepo,
+    model: normalizedModel.model,
+    modelTier: normalizedModel.modelTier,
+    effort,
+    slackChannelId,
+    slackThreadTs,
+    slackUserId,
+    overrideSlackContext,
+    followUpConfig,
+    outputSchema,
+    routingReason: effectiveRoutingReason,
+    routingSource: effectiveRoutingSource,
+    routingNote: effectiveRoutingNote,
+    routingAffinity:
+      effectiveLeadOnly || requiredCapabilities?.length
+        ? { leadOnly: effectiveLeadOnly, capabilities: requiredCapabilities ?? [] }
+        : undefined,
+  };
+  const preCreate = await applyPreTaskCreate({
+    description: task,
+    options: requestedTaskOptions,
+    origin: "mcp",
+    requestInfo: ctx.kind === "owner" ? ctx.requestInfo : undefined,
+  });
+  if (preCreate.kind === "blocked") {
+    return toolErr(preCreate.reason, {
+      data: { yourAgentId: creatorAgentId },
+      details: JSON.stringify({ extension: preCreate.extension }),
+    });
+  }
+  const taskDescription = preCreate.description;
+  const taskOptions = preCreate.options;
+
   // The three dedup guards are pure reads, so they run twice: once here as a
   // fast path (keeping this tool's existing early-exit responses), and once
   // inside the write transaction below, where the check is authoritative.
@@ -405,9 +454,9 @@ export async function sendTaskHandler(
     // Dedup guard: check for similar recent tasks
     if (!allowDuplicate && creatorAgentId) {
       const duplicate = await findDuplicateTask({
-        taskDescription: task,
-        creatorAgentId,
-        targetAgentId: effectiveAgentId ?? undefined,
+        taskDescription,
+        creatorAgentId: taskOptions.creatorAgentId ?? creatorAgentId,
+        targetAgentId: taskOptions.agentId ?? taskOptions.offeredTo,
       });
       if (duplicate) {
         return {
@@ -487,42 +536,13 @@ export async function sendTaskHandler(
     const raced = await evaluateDedupGuards();
     if (raced) return { success: raced.ok, message: raced.message, task: raced.task };
 
-    const finalTags = tags;
-
     // If no agentId (and no auto-routed agentId), create an unassigned task for the pool
-    if (!effectiveAgentId) {
-      const newTask = await createTaskExtended(task, {
-        key: assetKey,
-        creatorAgentId,
-        requestedByUserId,
-        sourceTaskId,
-        taskType,
-        tags: finalTags,
-        priority,
-        dependsOn,
-        dir,
-        parentTaskId: effectiveParentTaskId,
-        vcsRepo: effectiveVcsRepo,
-        model: normalizedModel.model,
-        modelTier: normalizedModel.modelTier,
-        effort,
-        slackChannelId,
-        slackThreadTs,
-        slackUserId,
-        overrideSlackContext,
-        followUpConfig,
-        outputSchema,
-        routingReason: effectiveRoutingReason,
-        routingSource: effectiveRoutingSource,
-        routingNote: effectiveRoutingNote,
-        routingAffinity:
-          effectiveLeadOnly || requiredCapabilities?.length
-            ? { leadOnly: effectiveLeadOnly, capabilities: requiredCapabilities ?? [] }
-            : undefined,
-      });
+    const targetAgentId = taskOptions.offeredTo ?? taskOptions.agentId ?? undefined;
+    if (!targetAgentId) {
+      const newTask = await createTaskExtended(taskDescription, taskOptions);
       await transferTrackerSyncToResumeChild({
-        parentTaskId: effectiveParentTaskId,
-        taskType,
+        parentTaskId: taskOptions.parentTaskId,
+        taskType: taskOptions.taskType,
         child: newTask,
       });
 
@@ -533,16 +553,16 @@ export async function sendTaskHandler(
       };
     }
 
-    const agent = await getAgentById(effectiveAgentId);
+    const agent = await getAgentById(targetAgentId);
 
     if (!agent) {
       return {
         success: false,
-        message: `Agent with ID "${effectiveAgentId}" not found.`,
+        message: `Agent with ID "${targetAgentId}" not found.`,
       };
     }
 
-    if (effectiveLeadOnly && !agent.isLead) {
+    if (taskOptions.routingAffinity?.leadOnly && !agent.isLead) {
       return {
         success: false,
         message: `Lead-only task requires a Lead agent; "${agent.name}" is not a Lead.`,
@@ -550,49 +570,20 @@ export async function sendTaskHandler(
     }
 
     // For direct assignment (not offer), check if agent has capacity
-    if (!offerMode && !(await hasCapacity(effectiveAgentId))) {
-      const activeCount = await getActiveTaskCount(effectiveAgentId);
+    if (!taskOptions.offeredTo && !(await hasCapacity(targetAgentId))) {
+      const activeCount = await getActiveTaskCount(targetAgentId);
       return {
         success: false,
         message: `Agent "${agent.name}" is at capacity (${activeCount}/${agent.maxTasks ?? 1} tasks). Use offerMode: true to offer the task instead, or wait for a task to complete.`,
       };
     }
 
-    if (offerMode) {
+    if (taskOptions.offeredTo) {
       // Offer the task to the agent (they must accept/reject)
-      const newTask = await createTaskExtended(task, {
-        key: assetKey,
-        offeredTo: effectiveAgentId,
-        creatorAgentId,
-        requestedByUserId,
-        sourceTaskId,
-        taskType,
-        tags: finalTags,
-        priority,
-        dependsOn,
-        dir,
-        parentTaskId: effectiveParentTaskId,
-        vcsRepo: effectiveVcsRepo,
-        model: normalizedModel.model,
-        modelTier: normalizedModel.modelTier,
-        effort,
-        slackChannelId,
-        slackThreadTs,
-        slackUserId,
-        overrideSlackContext,
-        followUpConfig,
-        outputSchema,
-        routingReason: effectiveRoutingReason,
-        routingSource: effectiveRoutingSource,
-        routingNote: effectiveRoutingNote,
-        routingAffinity:
-          effectiveLeadOnly || requiredCapabilities?.length
-            ? { leadOnly: effectiveLeadOnly, capabilities: requiredCapabilities ?? [] }
-            : undefined,
-      });
+      const newTask = await createTaskExtended(taskDescription, taskOptions);
       await transferTrackerSyncToResumeChild({
-        parentTaskId: effectiveParentTaskId,
-        taskType,
+        parentTaskId: taskOptions.parentTaskId,
+        taskType: taskOptions.taskType,
         child: newTask,
       });
 
@@ -604,39 +595,10 @@ export async function sendTaskHandler(
     }
 
     // Direct assignment
-    const newTask = await createTaskExtended(task, {
-      key: assetKey,
-      agentId: effectiveAgentId,
-      creatorAgentId,
-      requestedByUserId,
-      sourceTaskId,
-      taskType,
-      tags: finalTags,
-      priority,
-      dependsOn,
-      dir,
-      parentTaskId: effectiveParentTaskId,
-      vcsRepo: effectiveVcsRepo,
-      model: normalizedModel.model,
-      modelTier: normalizedModel.modelTier,
-      effort,
-      slackChannelId,
-      slackThreadTs,
-      slackUserId,
-      overrideSlackContext,
-      followUpConfig,
-      outputSchema,
-      routingReason: effectiveRoutingReason,
-      routingSource: effectiveRoutingSource,
-      routingNote: effectiveRoutingNote,
-      routingAffinity:
-        effectiveLeadOnly || requiredCapabilities?.length
-          ? { leadOnly: effectiveLeadOnly, capabilities: requiredCapabilities ?? [] }
-          : undefined,
-    });
+    const newTask = await createTaskExtended(taskDescription, taskOptions);
     await transferTrackerSyncToResumeChild({
-      parentTaskId: effectiveParentTaskId,
-      taskType,
+      parentTaskId: taskOptions.parentTaskId,
+      taskType: taskOptions.taskType,
       child: newTask,
     });
 

package/src/tools/task-action.ts

@@ -28,6 +28,7 @@ import {
   updateTaskClaudeSessionId,
 } from "@/be/db";
 import { touchRuntimeInstance } from "@/be/multi-runtime";
+import { applyPreTaskCreate } from "@/extensions/apply-task-create";
 import { assertOwnsTask, ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
 import {
   createToolRegistrar,
@@ -39,6 +40,7 @@ import {
 import {
   AssetKeySchema,
   BudgetRefusalCauseSchema,
+  type CreateTaskOptions,
   ModelTierSchema,
   ReasoningEffortSchema,
   splitLegacyModelAlias,
@@ -265,7 +267,14 @@ export async function taskActionHandler(
 
   const agentId = ctx.agentId;
   let assetKey: string | undefined;
+  let preparedCreate: { description: string; options: CreateTaskOptions } | undefined;
   if (action === "create") {
+    if (!task) {
+      return taskActionResult(
+        { success: false, message: "Task description is required for 'create' action." },
+        agentId,
+      );
+    }
     try {
       assetKey = key
         ? await authorizeAssetKeyWrite(key, await resolveTaskAuditUserId(ctx.sourceTaskId, agentId))
@@ -279,33 +288,45 @@ export async function taskActionHandler(
             : String(error);
       return taskActionResult({ success: false, message }, agentId);
     }
+
+    const preCreate = await applyPreTaskCreate({
+      description: task,
+      options: {
+        key: assetKey,
+        creatorAgentId: agentId,
+        source: "mcp",
+        taskType,
+        tags,
+        priority,
+        dependsOn,
+        dir,
+        model: normalizedModel.model,
+        modelTier: normalizedModel.modelTier,
+        effort: input.effort,
+        routingAffinity:
+          leadOnly || requiredCapabilities?.length
+            ? { leadOnly, capabilities: requiredCapabilities ?? [] }
+            : undefined,
+      },
+      origin: "mcp",
+      requestInfo: ctx.requestInfo,
+    });
+    if (preCreate.kind === "blocked") {
+      return taskActionResult({ success: false, message: preCreate.reason }, agentId);
+    }
+    preparedCreate = {
+      description: preCreate.description,
+      options: preCreate.options,
+    };
   }
 
   const result = await getDbClient().transaction(async (): Promise<TaskActionResult> => {
     switch (action) {
       case "create": {
-        if (!task) {
-          return {
-            success: false,
-            message: "Task description is required for 'create' action.",
-          };
-        }
-        const newTask = await createTaskExtended(task, {
-          key: assetKey,
-          creatorAgentId: agentId,
-          taskType,
-          tags,
-          priority,
-          dependsOn,
-          dir,
-          model: normalizedModel.model,
-          modelTier: normalizedModel.modelTier,
-          effort: input.effort,
-          routingAffinity:
-            leadOnly || requiredCapabilities?.length
-              ? { leadOnly, capabilities: requiredCapabilities ?? [] }
-              : undefined,
-        });
+        const newTask = await createTaskExtended(
+          preparedCreate!.description,
+          preparedCreate!.options,
+        );
         return {
           success: true,
           message: `Created unassigned task "${newTask.id}".`,

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

@@ -9,6 +9,7 @@ export type ToolCtx =
       runtimeInstanceId?: string;
       sourceTaskId?: string;
       sessionId?: string;
+      requestInfo?: RequestInfo;
     }
   | { kind: "user"; userId: string; user: User; sessionId?: string };
 
@@ -19,6 +20,7 @@ export function ownerCtx(info: RequestInfo): ToolCtx {
     runtimeInstanceId: info.runtimeInstanceId,
     sourceTaskId: info.sourceTaskId,
     sessionId: info.sessionId,
+    requestInfo: info,
   };
 }
 

package/src/tools/tool-config.ts

@@ -197,13 +197,15 @@ export const DEFERRED_TOOLS = new Set([
   "room-reset",
   "room-decode",
 
-  // Reusable scripts (6)
+  // Reusable scripts and extensions (8)
   "script-upsert",
   "script-delete",
   "script-apis",
   "launch-script-run",
   "get-script-run",
   "list-script-runs",
+  "extension-install",
+  "extension-list",
 
   // External command routes (1)
   "swarm_x",