feat(agents): add agentProviders config + init/doctor probe

Load ordered enable-list from config/env, probe available providers on
init and doctor, and filter workflow CLI providers by enabled∩live.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Waishnav

src/cli.ts

@@ -15,11 +15,13 @@ import { runLocalAgentProvider } from "./local-agent-adapters.js";
 import {
   isLocalAgentProvider,
   loadLocalAgentProfiles,
+  LOCAL_AGENT_PROVIDERS,
   type LocalAgentProfile,
 } from "./local-agent-profiles.js";
 import {
   assertLocalAgentProviderAvailable,
   formatLocalAgentProviderAvailabilitySummary,
+  getLocalAgentProviderAvailabilitySnapshot,
 } from "./local-agent-availability.js";
 import {
   formatAvailableLocalAgentTargets,
@@ -169,12 +171,18 @@ async function runInit({ force }: { force: boolean }): Promise<void> {
       validate: validateRequiredPublicBaseUrl,
     }));
 
+    const subagents = resolveSubagentsFlag(files.config);
+    const agentProviders =
+      subagents === true
+        ? probeAndBuildAgentProviders(files.config.agentProviders)
+        : files.config.agentProviders;
     const config: DevspaceUserConfig = {
       host: files.config.host ?? "127.0.0.1",
       port,
       allowedRoots,
       publicBaseUrl,
-      subagents: resolveSubagentsFlag(files.config),
+      subagents,
+      ...(agentProviders ? { agentProviders } : {}),
     };
     const auth = {
       ownerToken: files.auth.ownerToken ?? generateOwnerToken(),
@@ -277,11 +285,71 @@ async function runDoctor(): Promise<void> {
     console.log(`Public MCP URL: ${new URL("/mcp", config.publicBaseUrl).toString()}`);
     console.log(`Allowed roots: ${config.allowedRoots.join(", ")}`);
     console.log(`Allowed hosts: ${config.allowedHosts.join(", ")}`);
+    console.log(`Subagents: ${config.subagents ? "enabled" : "disabled"}`);
+    if (config.subagents) {
+      const snapshot = getLocalAgentProviderAvailabilitySnapshot();
+      console.log(
+        `Agent providers (live): ${formatLocalAgentProviderAvailabilitySummary(snapshot)}`,
+      );
+      if (config.agentProviders) {
+        console.log(
+          `Agent providers (enabled): ${
+            config.agentProviders.enabled.length
+              ? config.agentProviders.enabled.join(", ")
+              : "(empty — no providers)"
+          }`,
+        );
+        if (config.agentProviders.detectedAt) {
+          console.log(`Agent providers last probe: ${config.agentProviders.detectedAt}`);
+        }
+      } else {
+        console.log("Agent providers (config): missing (compat = all available)");
+      }
+
+      // Refresh lastProbe write-back when subagents on and config exists
+      if (files.configExists) {
+        const refreshed = probeAndBuildAgentProviders(files.config.agentProviders);
+        writeDevspaceConfig({
+          ...files.config,
+          agentProviders: {
+            // keep user enable-list if set; only refresh probe metadata + available adds when empty
+            enabled:
+              files.config.agentProviders?.enabled ?? refreshed.enabled,
+            detectedAt: refreshed.detectedAt,
+            lastProbe: refreshed.lastProbe,
+          },
+        });
+        console.log(`Agent providers probe written to ${files.configPath}`);
+      }
+    }
   } catch (error) {
     console.log(`Config status: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 
+/** Probe PATH and build AgentProvidersConfig (available ids in product order). */
+function probeAndBuildAgentProviders(
+  existing?: DevspaceUserConfig["agentProviders"],
+): NonNullable<DevspaceUserConfig["agentProviders"]> {
+  const snapshot = getLocalAgentProviderAvailabilitySnapshot();
+  const available = new Set(
+    snapshot.filter((row) => row.available).map((row) => row.name),
+  );
+  const enabled =
+    existing?.enabled && existing.enabled.length > 0
+      ? existing.enabled.filter((id) => LOCAL_AGENT_PROVIDERS.includes(id as never))
+      : LOCAL_AGENT_PROVIDERS.filter((id) => available.has(id));
+  return {
+    enabled,
+    detectedAt: new Date().toISOString(),
+    lastProbe: snapshot.map((row) => ({
+      id: row.name,
+      available: row.available,
+      detail: row.reason,
+    })),
+  };
+}
+
 function runConfigCommand(args: string[]): void {
   const [subcommand, key, ...rest] = args;
   const files = loadDevspaceFiles();

src/config.ts

@@ -4,6 +4,12 @@ import { expandHomePath } from "./roots.js";
 import type { LoggingConfig, LogFormat, LogLevel } from "./logger.js";
 import type { OAuthConfig } from "./oauth-provider.js";
 import { devspaceAgentsDir, devspaceSkillsDir, loadDevspaceFiles } from "./user-config.js";
+import type { AgentProvidersConfig } from "./workflow-types.js";
+import {
+  isLocalAgentProvider,
+  LOCAL_AGENT_PROVIDERS,
+  type LocalAgentProvider,
+} from "./local-agent-profiles.js";
 
 export type ToolMode = "minimal" | "full" | "codex";
 export type WidgetMode = "off" | "changes" | "full";
@@ -26,6 +32,12 @@ export interface ServerConfig {
   devspaceSkillsDir: string;
   devspaceAgentsDir: string;
   subagents: boolean;
+  /**
+   * Resolved enable-list for agent providers.
+   * Missing user config → undefined (compat: all live providers).
+   * Explicit empty → no providers.
+   */
+  agentProviders?: AgentProvidersConfig;
   agentDir: string;
   logging: LoggingConfig;
 }
@@ -234,11 +246,46 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): ServerConfig {
       env.DEVSPACE_SUBAGENTS === undefined
         ? files.config.subagents === true
         : parseBoolean(env.DEVSPACE_SUBAGENTS),
+    agentProviders: parseAgentProvidersConfig(
+      env.DEVSPACE_AGENT_PROVIDERS,
+      files.config.agentProviders,
+    ),
     agentDir: resolve(expandHomePath(env.DEVSPACE_AGENT_DIR ?? files.config.agentDir ?? defaultAgentDir())),
     logging: parseLoggingConfig(env),
   };
 }
 
+/**
+ * Env `DEVSPACE_AGENT_PROVIDERS=codex,claude` replaces enabled list.
+ * Missing config → undefined (compat all-available).
+ * Explicit enabled: [] stays empty.
+ */
+export function parseAgentProvidersConfig(
+  envValue: string | undefined,
+  fileConfig: AgentProvidersConfig | undefined,
+): AgentProvidersConfig | undefined {
+  if (envValue !== undefined) {
+    const enabled = envValue
+      .split(",")
+      .map((entry) => entry.trim())
+      .filter((entry): entry is LocalAgentProvider => isLocalAgentProvider(entry));
+    return { enabled };
+  }
+  if (!fileConfig) return undefined;
+  const enabled = (fileConfig.enabled ?? []).filter((id): id is LocalAgentProvider =>
+    isLocalAgentProvider(id),
+  );
+  return {
+    enabled,
+    detectedAt: fileConfig.detectedAt,
+    lastProbe: fileConfig.lastProbe,
+  };
+}
+
+export function defaultAgentProvidersOrder(): LocalAgentProvider[] {
+  return [...LOCAL_AGENT_PROVIDERS];
+}
+
 function parsePublicBaseUrl(value: string): string {
   const parsed = new URL(value);
   parsed.hash = "";

src/workflow-cli.ts

@@ -281,7 +281,7 @@ export async function runWorkflowWorker(
   try {
     const source = await readFile(claimed.scriptPath, "utf8");
     const parsed = parseWorkflowScript(source, { filename: claimed.scriptPath });
-    const enabledProviders = resolveEnabledProviders();
+    const enabledProviders = resolveEnabledProviders(config.agentProviders);
     const concurrency = resolveWorkflowConcurrency(
       parsed.meta.concurrency,
       availableParallelism(),
@@ -474,10 +474,15 @@ function formatRunLine(
   return `${run.id} ${run.status} ${run.name}${err}`;
 }
 
-function resolveEnabledProviders(): string[] {
+function resolveEnabledProviders(
+  agentProviders?: ServerConfig["agentProviders"],
+): string[] {
   const snapshot = getLocalAgentProviderAvailabilitySnapshot();
   const live = new Set(snapshot.filter((row) => row.available).map((row) => row.name));
-  return LOCAL_AGENT_PROVIDERS.filter((id) => live.has(id));
+  if (!agentProviders) {
+    return LOCAL_AGENT_PROVIDERS.filter((id) => live.has(id));
+  }
+  return agentProviders.enabled.filter((id) => live.has(id as never));
 }
 
 function splitFlags(args: string[]): {