@desplega.ai/agent-swarm 1.152.2 → 1.153.0

package/src/providers/dsh-adapter.ts

@@ -0,0 +1,248 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DEFAULT_MODEL_TIER_MAP } from "../types";
+import { getOpenRouterBaseUrl } from "../utils/openrouter-base-url";
+import {
+  detachedProcessGroup,
+  registerProcessGroup,
+  terminateProcessGroup,
+} from "../utils/process-group";
+import { registerVolatileSecret, scrubSecrets } from "../utils/secret-scrubber";
+import { resolveSlashSkillPrompt } from "./codex-skill-resolver";
+import type {
+  CredStatus,
+  ProviderAdapter,
+  ProviderEvent,
+  ProviderResult,
+  ProviderSession,
+  ProviderSessionConfig,
+  ProviderTraits,
+} from "./types";
+
+// npm's `latest` is older and lacks the JSON/stdin contract used here.
+export const DSH_PACKAGE = "@deepseek-ai/dsh@0.1.7-alpha.2";
+
+export function checkDshCredentials(env: Record<string, string | undefined>): CredStatus {
+  return env.DEEPSEEK_API_KEY?.trim() || env.OPENROUTER_API_KEY?.trim()
+    ? { ready: true, missing: [], satisfiedBy: "env" }
+    : {
+        ready: false,
+        missing: ["DEEPSEEK_API_KEY", "OPENROUTER_API_KEY"],
+        hint: "Set DEEPSEEK_API_KEY or OPENROUTER_API_KEY for dsh.",
+      };
+}
+
+class DshSession implements ProviderSession {
+  sessionId: string | undefined;
+  private listeners: ((event: ProviderEvent) => void)[] = [];
+  private pending: ProviderEvent[] = [];
+  private output: string | undefined;
+  private failure: string | undefined;
+  private stderr = "";
+  private aborted = false;
+  private completion: Promise<ProviderResult>;
+
+  constructor(
+    private proc: Bun.Subprocess<"pipe", "pipe", "pipe">,
+    private directory: string,
+    prompt: string,
+  ) {
+    this.completion = this.run(prompt);
+  }
+
+  onEvent(listener: (event: ProviderEvent) => void): void {
+    this.listeners.push(listener);
+    for (const event of this.pending.splice(0)) listener(event);
+  }
+
+  private emit(event: ProviderEvent): void {
+    if (this.listeners.length === 0) this.pending.push(event);
+    else for (const listener of this.listeners) listener(event);
+  }
+
+  private consumeLine(line: string): void {
+    if (!line.trim()) return;
+    const clean = scrubSecrets(line);
+    this.emit({ type: "raw_log", content: clean });
+    try {
+      const event = JSON.parse(clean);
+      if (event.type === "session" && typeof event.sessionId === "string") {
+        this.sessionId = event.sessionId;
+        this.emit({ type: "session_init", sessionId: event.sessionId, provider: "dsh" });
+      } else if (event.type === "text" && typeof event.text === "string") {
+        this.emit({ type: "message", role: "assistant", content: event.text });
+      } else if (event.type === "final" && typeof event.text === "string") {
+        this.output = event.text;
+      } else if (event.type === "error" && typeof event.message === "string") {
+        this.failure = event.message;
+      } else if (event.type === "status" && typeof event.phase === "string") {
+        this.emit({ type: "progress", message: event.phase });
+        if (event.phase === "turn_end" && event.reason?.kind !== "completed") {
+          this.failure =
+            typeof event.reason?.error?.message === "string"
+              ? event.reason.error.message
+              : `dsh turn ended: ${event.reason?.kind ?? "unknown"}`;
+        }
+      }
+    } catch {
+      this.failure = "dsh emitted invalid JSON output";
+    }
+  }
+
+  private async readStdout(): Promise<void> {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for await (const chunk of this.proc.stdout) {
+      buffer += decoder.decode(chunk, { stream: true });
+      let newline = buffer.indexOf("\n");
+      while (newline >= 0) {
+        this.consumeLine(buffer.slice(0, newline));
+        buffer = buffer.slice(newline + 1);
+        newline = buffer.indexOf("\n");
+      }
+    }
+    this.consumeLine(buffer + decoder.decode());
+  }
+
+  private async readStderr(): Promise<void> {
+    const decoder = new TextDecoder();
+    for await (const chunk of this.proc.stderr) {
+      const content = scrubSecrets(decoder.decode(chunk, { stream: true }));
+      this.stderr = (this.stderr + content).slice(-8000);
+      this.emit({ type: "raw_stderr", content });
+    }
+  }
+
+  private async run(prompt: string): Promise<ProviderResult> {
+    try {
+      const [exitCode] = await Promise.all([
+        this.proc.exited,
+        this.readStdout(),
+        this.readStderr(),
+        (async () => {
+          this.proc.stdin.write(prompt);
+          await this.proc.stdin.end();
+        })(),
+      ]);
+      const isError = this.aborted || exitCode !== 0 || !!this.failure || this.output === undefined;
+      const failureReason = isError
+        ? this.aborted
+          ? "dsh session aborted"
+          : this.failure || this.stderr.trim() || `dsh exited ${exitCode} without a final result`
+        : undefined;
+      if (failureReason) this.emit({ type: "error", message: failureReason });
+      return {
+        exitCode: isError ? exitCode || 1 : 0,
+        sessionId: this.sessionId,
+        output: this.output,
+        isError,
+        failureReason,
+      };
+    } catch (error) {
+      await terminateProcessGroup(this.proc.pid);
+      const failureReason = scrubSecrets(String(error));
+      this.emit({ type: "error", message: failureReason });
+      return { exitCode: 1, sessionId: this.sessionId, isError: true, failureReason };
+    } finally {
+      await rm(this.directory, { recursive: true, force: true });
+    }
+  }
+
+  waitForCompletion(): Promise<ProviderResult> {
+    return this.completion;
+  }
+
+  async abort(): Promise<void> {
+    this.aborted = true;
+    await terminateProcessGroup(this.proc.pid);
+  }
+}
+
+export class DshAdapter implements ProviderAdapter {
+  readonly name = "dsh";
+  readonly traits: ProviderTraits = {
+    hasMcp: false,
+    nativeSkillDiscovery: false,
+    hasLocalEnvironment: true,
+    steerModes: [],
+  };
+
+  async createSession(config: ProviderSessionConfig): Promise<ProviderSession> {
+    const env = { ...process.env, ...config.env };
+    if (!checkDshCredentials(env).ready) {
+      throw new Error("dsh requires DEEPSEEK_API_KEY or OPENROUTER_API_KEY");
+    }
+    const model = config.model || DEFAULT_MODEL_TIER_MAP.dsh.regular;
+    const openrouter = model.startsWith("openrouter/");
+    const modelId = openrouter ? model.slice("openrouter/".length) : model;
+    const keyEnv = openrouter ? "OPENROUTER_API_KEY" : "DEEPSEEK_API_KEY";
+    if (!modelId.trim()) throw new Error("dsh requires a model ID after openrouter/");
+    if (!env[keyEnv]?.trim()) throw new Error(`dsh model ${model} requires ${keyEnv}`);
+    const binary = env.DSH_BINARY || Bun.which("dsh", { PATH: env.PATH });
+    if (!binary) {
+      throw new Error(
+        `dsh CLI not found. Install ${DSH_PACKAGE} during image provisioning or set DSH_BINARY to a trusted executable.`,
+      );
+    }
+    registerVolatileSecret(env[keyEnv]!, keyEnv);
+    const prompt = await resolveSlashSkillPrompt(config.prompt, {
+      providerLabel: "dsh",
+      skillsDir: join(env.HOME ?? "/home/worker", ".agents", "skills"),
+    });
+    const directory = await mkdtemp(join(tmpdir(), "swarm-dsh-"));
+    try {
+      const patchPath = join(directory, "patch.json");
+      // JSON is valid YAML. Values stay data, including arbitrary system prompts.
+      await writeFile(
+        patchPath,
+        JSON.stringify([
+          {
+            id: "agent-default-model",
+            config: { provider: openrouter ? "openrouter" : "deepseek-official", model: modelId },
+          },
+          { id: "system-prompt", config: { personaPrefix: config.systemPrompt } },
+          openrouter
+            ? {
+                id: "llm-pi-ai",
+                config: {
+                  providers: {
+                    openrouter: {
+                      apiKeyEnv: keyEnv,
+                      baseURL: getOpenRouterBaseUrl(env),
+                      api: "openai-completions",
+                      // Declare the selected ID even if the bundled catalog predates it.
+                      models: [{ id: modelId }],
+                    },
+                  },
+                },
+              }
+            : { id: "llm-deepseek", config: { apiKeyEnv: keyEnv } },
+        ]),
+        { mode: 0o600 },
+      );
+      const proc = registerProcessGroup(
+        Bun.spawn([binary, "--profile", "headless", "--patch", patchPath, "--json", "-"], {
+          cwd: config.cwd,
+          env,
+          stdin: "pipe",
+          stdout: "pipe",
+          stderr: "pipe",
+          detached: detachedProcessGroup,
+        }),
+      );
+      return new DshSession(proc, directory, prompt);
+    } catch (error) {
+      await rm(directory, { recursive: true, force: true });
+      throw error;
+    }
+  }
+
+  async canResume(_sessionId: string): Promise<boolean> {
+    return false;
+  }
+
+  formatCommand(commandName: string): string {
+    return `/${commandName}`;
+  }
+}

package/src/providers/index.ts

@@ -47,13 +47,17 @@ export async function createProviderAdapter(provider: string): Promise<ProviderA
       const { OpencodeAdapter } = await import("./opencode-adapter");
       return new OpencodeAdapter();
     }
+    case "dsh": {
+      const { DshAdapter } = await import("./dsh-adapter");
+      return new DshAdapter();
+    }
     case "acp": {
       const { ACPAdapter } = await import("./acp-adapter");
       return new ACPAdapter();
     }
     default:
       throw new Error(
-        `Unknown HARNESS_PROVIDER: "${provider}". Supported: claude, pi, codex, devin, claude-managed, opencode, acp`,
+        `Unknown HARNESS_PROVIDER: "${provider}". Supported: claude, pi, codex, devin, claude-managed, opencode, acp, dsh`,
       );
   }
 }

package/src/providers/modelsdev-reasoning.json

@@ -1,5 +1,21 @@
 {
   "anthropic": {
+    "claude-opus-5-5": {
+      "id": "claude-opus-5-5",
+      "reasoning": true,
+      "reasoningOptions": [
+        {
+          "type": "effort",
+          "values": [
+            "low",
+            "medium",
+            "high",
+            "xhigh",
+            "max"
+          ]
+        }
+      ]
+    },
     "claude-sonnet-4-6": {
       "id": "claude-sonnet-4-6",
       "reasoning": true,
@@ -919,6 +935,40 @@
           ]
         }
       ]
+    },
+    "gpt-6-sol": {
+      "id": "gpt-6-sol",
+      "reasoning": true,
+      "reasoningOptions": [
+        {
+          "type": "effort",
+          "values": [
+            "none",
+            "low",
+            "medium",
+            "high",
+            "xhigh",
+            "max"
+          ]
+        }
+      ]
+    },
+    "gpt-6-luna": {
+      "id": "gpt-6-luna",
+      "reasoning": true,
+      "reasoningOptions": [
+        {
+          "type": "effort",
+          "values": [
+            "none",
+            "low",
+            "medium",
+            "high",
+            "xhigh",
+            "max"
+          ]
+        }
+      ]
     }
   },
   "openrouter": {

package/src/rbac/legacy-policy.ts

@@ -56,6 +56,20 @@ const leadOrOperatorOrUser: LegacyRule = {
     principal.kind === "operator" || principal.kind === "user" || actsAsLead(principal),
 };
 
+const extensionWrite: LegacyRule = {
+  name: "extension-owner-or-elevated",
+  denyReason: "requires extension owner, lead agent, operator, or user authentication",
+  evaluate: (principal, resource) => {
+    if (leadOrOperatorOrUser.evaluate(principal, resource)) return true;
+    return (
+      principal.kind === "agent" &&
+      principal.agentId !== "" &&
+      resource?.kind === "extension" &&
+      (resource.extensionId === undefined || resource.createdByAgentId === principal.agentId)
+    );
+  },
+};
+
 // Deployment-only: agents cannot reset this through swarm_config.
 const extensionActivation: LegacyRule = {
   name: "extension-activation",
@@ -242,6 +256,6 @@ export const LEGACY_POLICY = {
   "script.api.update": leadOnly,
   "script.api.rotate": leadOnly,
   "script.api.delete": leadOnly,
-  "extension.write": leadOrOperatorOrUser,
+  "extension.write": extensionWrite,
   "extension.activate": extensionActivation,
 } as const satisfies Record<PermissionVerb, LegacyRule>;

package/src/rbac/types.ts

@@ -32,6 +32,8 @@ export type RbacResource =
   | { kind: "app"; appId: string }
   /** Skills, mcp-servers, memory entries, scripts. */
   | { kind: "owned"; ownerAgentId?: string | null; scope?: string }
+  /** An omitted extensionId denotes a new install; existing rows retain their creator. */
+  | { kind: "extension"; extensionId?: string; createdByAgentId?: string | null }
   | { kind: "none" };
 
 export type RbacDecision =

package/src/server.ts

@@ -9,6 +9,7 @@ import { registerGithubTaskReactions } from "./github/task-reactions";
 import { loadGlobalConfigsIntoEnv } from "./http/core";
 import { resolveTemplate } from "./prompts/resolver";
 import { isRbacEnabled } from "./rbac";
+import { getSlackConfiguration } from "./slack/config";
 import { registerAcceptSteerTool } from "./tools/accept-steer";
 import { registerAppDiffTool } from "./tools/app-diff";
 import { registerAppGetTool } from "./tools/app-get";
@@ -268,7 +269,12 @@ export function hasCapability(cap: CAPABILITIES_T): boolean {
 }
 
 export function getEnabledCapabilities(): CAPABILITIES_T[] {
-  return Array.from(getCapabilities());
+  const capabilities = Array.from(getCapabilities());
+  // Phase 1 has no HTTP receiver. Do not advertise usable Slack tools to
+  // workers when HTTP (or an invalid transport) was selected.
+  return getSlackConfiguration().mode === "socket"
+    ? capabilities
+    : capabilities.filter((capability) => capability !== "slack");
 }
 
 /**

package/src/slack/app.ts

@@ -1,5 +1,6 @@
 import { App, LogLevel } from "@slack/bolt";
 import { emitBuiltInIntegrationConnectedOnce, ensureSlackRenderV2Activation } from "../be/db";
+import { getSlackConfiguration } from "./config";
 import { getSlackSocketModeBlockReason, SLACK_DEV_SOCKET_MODE_OPT_IN } from "./socket-mode-guard";
 import { startTaskWatcher, stopTaskWatcher } from "./watcher";
 
@@ -16,23 +17,38 @@ export async function initSlackApp(): Promise<App | null> {
     console.log("[Slack] Already initialized, skipping");
     return app;
   }
-  initialized = true;
-
-  // Check if Slack is explicitly disabled
-  const slackDisable = process.env.SLACK_DISABLE;
-  if (slackDisable === "true" || slackDisable === "1") {
+  const config = getSlackConfiguration();
+  if (config.disabled) {
     console.log("[Slack] Disabled via SLACK_DISABLE");
     return null;
   }
 
-  const botToken = process.env.SLACK_BOT_TOKEN;
-  const appToken = process.env.SLACK_APP_TOKEN;
+  if (!config.mode) {
+    console.error(
+      "[Slack] Invalid SLACK_MODE; expected socket or http. Slack integration disabled",
+    );
+    return null;
+  }
+
+  if (config.missingCredentials.length > 0) {
+    console.log(
+      `[Slack] Missing ${config.missingCredentials.join(" or ")} for ${config.mode} mode, Slack integration disabled`,
+    );
+    return null;
+  }
 
-  if (!botToken || !appToken) {
-    console.log("[Slack] Missing SLACK_BOT_TOKEN or SLACK_APP_TOKEN, Slack integration disabled");
+  // Phase 1 establishes the transport contract only. Never fall back to a
+  // socket when HTTP was explicitly selected; the receiver lands in Phase 3.
+  if (config.mode === "http") {
+    console.error(
+      "[Slack] HTTP mode is configured but unavailable until the HTTP receiver is installed",
+    );
     return null;
   }
 
+  const botToken = process.env.SLACK_BOT_TOKEN as string;
+  const appToken = process.env.SLACK_APP_TOKEN as string;
+
   const socketModeBlockReason = getSlackSocketModeBlockReason(process.env);
   if (socketModeBlockReason) {
     console.error(
@@ -51,6 +67,9 @@ export async function initSlackApp(): Promise<App | null> {
     ...(slackApiUrl ? { clientOptions: { slackApiUrl } } : {}),
   });
 
+  // Failed validation must remain retryable without requiring stopSlackApp().
+  initialized = true;
+
   // Register handlers
   const { registerMessageHandler } = await import("./handlers");
   const { registerCommandHandler } = await import("./commands");
@@ -69,7 +88,7 @@ export async function initSlackApp(): Promise<App | null> {
   return app;
 }
 
-export async function startSlackApp(): Promise<void> {
+export async function startSlackApp(): Promise<boolean> {
   if (!app) {
     await initSlackApp();
   }
@@ -84,7 +103,10 @@ export async function startSlackApp(): Promise<void> {
 
     // Start watching for task completions
     await startTaskWatcher();
+    return true;
   }
+
+  return false;
 }
 
 export async function stopSlackApp(): Promise<void> {

package/src/slack/config.ts

@@ -0,0 +1,29 @@
+export const SLACK_MODES = ["socket", "http"] as const;
+export type SlackMode = (typeof SLACK_MODES)[number];
+
+export type SlackConfiguration = {
+  disabled: boolean;
+  mode: SlackMode | null;
+  missingCredentials: string[];
+};
+
+/** Resolve Slack transport and credential presence without exposing credential values. */
+export function getSlackConfiguration(env: NodeJS.ProcessEnv = process.env): SlackConfiguration {
+  const rawMode = env.SLACK_MODE === undefined ? "socket" : env.SLACK_MODE.trim();
+  const mode = SLACK_MODES.includes(rawMode as SlackMode) ? (rawMode as SlackMode) : null;
+  const missingCredentials = ["SLACK_BOT_TOKEN"];
+
+  if (mode === "socket") missingCredentials.push("SLACK_APP_TOKEN");
+  if (mode === "http") missingCredentials.push("SLACK_SIGNING_SECRET");
+
+  return {
+    disabled: env.SLACK_DISABLE === "true" || env.SLACK_DISABLE === "1",
+    mode,
+    missingCredentials: missingCredentials.filter((key) => !env[key]?.trim()),
+  };
+}
+
+export function isSlackConfigured(env: NodeJS.ProcessEnv = process.env): boolean {
+  const config = getSlackConfiguration(env);
+  return !config.disabled && config.mode !== null && config.missingCredentials.length === 0;
+}

package/src/telemetry.ts

@@ -8,6 +8,7 @@
  */
 import { randomUUID } from "node:crypto";
 import pkg from "../package.json";
+import { isSlackConfigured } from "./slack/config";
 import { isEnvFlagEnabled } from "./utils/env-flag";
 
 const TELEMETRY_ENDPOINT = "https://proxy.desplega.sh/v1/events";
@@ -269,9 +270,7 @@ export function _hasEmbeddingKey(env: NodeJS.ProcessEnv = process.env): boolean
  * Exported for tests; not part of the public API.
  */
 export function _hasSlackChannel(env: NodeJS.ProcessEnv = process.env): boolean {
-  return (
-    !!(env.SLACK_BOT_TOKEN && env.SLACK_APP_TOKEN) && !isEnvFlagEnabled("SLACK_DISABLE", false, env)
-  );
+  return isSlackConfigured(env);
 }
 
 /**

package/src/tests/agents-harness-provider.test.ts

@@ -333,6 +333,25 @@ describe("PATCH /api/agents/:id/harness-provider", () => {
 });
 
 describe("PATCH /api/agents/:id/runtime", () => {
+  test("accepts dsh and persists its harness and model for the worker", async () => {
+    const agent = await createAgent({
+      name: "dsh-worker",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    const res = await fetch(`${baseUrl}/api/agents/${agent.id}/runtime`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "dsh", model: "deepseek-flash" }),
+    });
+    expect(res.status).toBe(200);
+    expect((await getAgentById(agent.id))?.harnessProvider).toBe("dsh");
+    const rows = await getSwarmConfigs({ scope: "agent", scopeId: agent.id });
+    expect(rows.find((row) => row.key === "HARNESS_PROVIDER")?.value).toBe("dsh");
+    expect(rows.find((row) => row.key === "MODEL_OVERRIDE")?.value).toBe("deepseek-flash");
+  });
+
   test("updates harness_provider and agent-scoped runtime config rows", async () => {
     const a = await createAgent({
       name: "runtime-target-1",

package/src/tests/agents-list-model-display.test.ts

@@ -1,9 +1,38 @@
 import { describe, expect, test } from "bun:test";
+import type { LiveModelsCatalog } from "../../apps/ui/src/lib/agent-runtime-models";
 import {
   getAgentModelDisplay,
   getAgentModelPresentation,
 } from "../../apps/ui/src/lib/agents-list-model-display";
 
+const liveCatalog: LiveModelsCatalog = {
+  openrouter: {
+    id: "openrouter",
+    name: "OpenRouter",
+    models: {
+      "deepseek/deepseek-v4-pro": { id: "deepseek/deepseek-v4-pro", name: "DeepSeek V4 Pro" },
+      "deepseek/deepseek-v4.1-flash": {
+        id: "deepseek/deepseek-v4.1-flash",
+        name: "DeepSeek V4.1 Flash",
+      },
+    },
+  },
+  opencode: {
+    id: "opencode",
+    name: "OpenCode Zen",
+    models: {
+      "glm-5.3-flash": { id: "glm-5.3-flash", name: "GLM-5.3-Flash" },
+    },
+  },
+  anthropic: {
+    id: "anthropic",
+    name: "Anthropic",
+    models: {
+      "claude-opus-5-5": { id: "claude-opus-5-5", name: "Claude Opus 5.5" },
+    },
+  },
+};
+
 describe("agents list model display", () => {
   test("shows configured and last-used models when they diverge", () => {
     const display = getAgentModelDisplay("claude-opus-4-7", "claude-sonnet-4-6");
@@ -43,6 +72,31 @@ describe("agents list model display", () => {
     });
   });
 
+  test.each([
+    ["openrouter/deepseek/deepseek-v4-pro", "DeepSeek V4 Pro", "OpenRouter"],
+    ["openrouter/deepseek/deepseek-v4.1-flash", "DeepSeek V4.1 Flash", "OpenRouter"],
+    ["opencode/glm-5.3-flash", "GLM-5.3-Flash", "OpenCode Zen"],
+    ["claude-opus-5-5", "Claude Opus 5.5", "Anthropic"],
+  ])("resolves %s from the live catalog", (model, label, provider) => {
+    expect(getAgentModelPresentation(model, liveCatalog)).toMatchObject({
+      raw: model,
+      label,
+      provider,
+    });
+  });
+
+  test("title-cases an uncatalogued model id without a maintained label entry", () => {
+    expect(
+      getAgentModelPresentation("opencode/future-model-v8.2-preview", liveCatalog),
+    ).toMatchObject({
+      label: "Future Model V8.2 Preview",
+      provider: null,
+    });
+    expect(
+      getAgentModelPresentation("openrouter/deepseek/deepseek-v5.1-flash", liveCatalog)?.label,
+    ).toBe("Deepseek V5.1 Flash");
+  });
+
   test("presents latest Anthropic direct model ids as readable labels", () => {
     expect(getAgentModelPresentation("claude-fable-5-1")).toMatchObject({
       label: "Claude Fable 5.1",
@@ -54,6 +108,11 @@ describe("agents list model display", () => {
       provider: "Anthropic",
       providerId: "anthropic",
     });
+    expect(getAgentModelPresentation("claude-opus-5-5")).toMatchObject({
+      label: "Claude Opus 5.5",
+      provider: "Anthropic",
+      providerId: "anthropic",
+    });
     expect(getAgentModelPresentation("claude-opus-5")).toMatchObject({
       label: "Claude Opus 5",
       provider: "Anthropic",
@@ -75,7 +134,7 @@ describe("agents list model display", () => {
       providerId: "anthropic",
     });
     expect(getAgentModelPresentation("opus")).toMatchObject({
-      label: "Claude Opus 5",
+      label: "Claude Opus 5.5",
       provider: "Anthropic",
       providerId: "anthropic",
     });

package/src/tests/base-prompt.test.ts

@@ -25,6 +25,8 @@ const ENV_KEYS = [
   "SLACK_DISABLE",
   "SLACK_BOT_TOKEN",
   "SLACK_APP_TOKEN",
+  "SLACK_MODE",
+  "SLACK_SIGNING_SECRET",
   "STEERING_ENABLED",
   "AGENT_FS_API_URL",
   "SCRIPTS_ONLY_MCP",
@@ -561,6 +563,29 @@ describe("getBasePrompt: slack section", () => {
     expect(result).toContain(SLACK_HEADER);
   });
 
+  test("a tool capability alone does not bypass the default socket credential gate", async () => {
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      serverCapabilities: ["core", "slack"],
+    });
+    expect(result).not.toContain(SLACK_HEADER);
+  });
+
+  test("supports the HTTP prompt contract without distributing Slack secrets to the worker", async () => {
+    process.env.SLACK_MODE = "http";
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      serverCapabilities: ["core", "slack"],
+    });
+    expect(result).toContain(SLACK_HEADER);
+
+    const withoutCapability = await getBasePrompt({
+      ...minimalArgs,
+      serverCapabilities: ["core"],
+    });
+    expect(withoutCapability).not.toContain(SLACK_HEADER);
+  });
+
   test("a scripts-only worker with a Slack task gets the scripts-only variant only", async () => {
     enableSlack();
     const result = await getBasePrompt({