load mcp ui app cards on cloud task runs

Author: charlesvien

packages/core/src/mcp-apps/mcp-apps.ts

@@ -66,6 +66,7 @@ export class McpAppsService extends TypedEventEmitter<McpAppsServiceEvents> {
   private toolAssociations = new Map<string, McpToolUiAssociation>();
   private toolDefinitions = new Map<string, Tool>();
   private serverConfigs = new Map<string, McpServerConnectionConfig>();
+  private configResolver?: (serverName: string) => Promise<void>;
   private pendingConnections = new Map<string, Promise<ServerConnection>>();
   private pendingFetches = new Map<string, Promise<McpUiResource | null>>();
   private resourceMetaCache = new Map<string, McpResourceUiMeta>();
@@ -93,6 +94,29 @@ export class McpAppsService extends TypedEventEmitter<McpAppsServiceEvents> {
     }
   }
 
+  /**
+   * Merge server configs without clearing existing ones. Cloud runs never run a
+   * local agent session (the agent lives in the sandbox), so setServerConfigs is
+   * never called for them and a cloud run's UI-app resource fetch has no config
+   * to connect through ("No server config for: posthog"). This registers the
+   * config on demand so the card can load.
+   */
+  addServerConfigs(configs: McpServerConnectionConfig[]): void {
+    for (const config of configs) {
+      this.serverConfigs.set(config.name, config);
+    }
+  }
+
+  /**
+   * Register a fallback that lazily supplies a missing server config (expected to
+   * call addServerConfigs). getOrCreateConnection invokes it when a config is
+   * absent — the path cloud runs hit, since no local session ever registered
+   * their servers — so a UI-app resource fetch self-heals instead of throwing.
+   */
+  setConfigResolver(resolver: (serverName: string) => Promise<void>): void {
+    this.configResolver = resolver;
+  }
+
   /**
    * Called when the agent confirms MCP servers are connected.
    * Connects to each server, calls listTools() to discover _meta.ui fields
@@ -206,7 +230,11 @@ export class McpAppsService extends TypedEventEmitter<McpAppsServiceEvents> {
       return pending;
     }
 
-    const config = this.serverConfigs.get(serverName);
+    let config = this.serverConfigs.get(serverName);
+    if (!config && this.configResolver) {
+      await this.configResolver(serverName);
+      config = this.serverConfigs.get(serverName);
+    }
     if (!config) {
       throw new Error(`No server config for: ${serverName}`);
     }

packages/workspace-server/src/services/agent/agent.ts

@@ -440,6 +440,17 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
     this.log = loggerFactory.scope("agent-service");
     this.onAgentLog = makeOnAgentLog(loggerFactory);
 
+    // Cloud runs never start a local session (the agent lives in the sandbox), so
+    // getOrCreateSession never registers their MCP servers with the mcp-apps
+    // service. Resolve them on demand from the current auth state the first time a
+    // cloud-run UI-app resource is fetched, so the review card loads.
+    this.mcpAppsService.setConfigResolver(async () => {
+      const credentials = await this.agentAuthAdapter.getCurrentCredentials();
+      if (credentials) {
+        await this.ensureMcpAppsServerConfigs(credentials);
+      }
+    });
+
     powerManager.onResume(() => this.checkIdleDeadlines());
   }
 
@@ -698,6 +709,26 @@ If a repository IS genuinely required, attach one in this priority order:
     return this.toSessionResponse(session);
   }
 
+  /**
+   * Register the MCP server configs (posthog + installations) with the mcp-apps
+   * service without starting an agent session. A cloud run's agent lives in the
+   * sandbox, so getOrCreateSession never runs on the desktop and the mcp-apps
+   * service has no config to fetch a UI-app resource through — the review card
+   * then fails with "No server config for: posthog" and renders as text. The
+   * task view calls this when a cloud-run tool result carries a UI app.
+   */
+  async ensureMcpAppsServerConfigs(credentials: Credentials): Promise<void> {
+    const { servers } =
+      await this.agentAuthAdapter.buildMcpServers(credentials);
+    this.mcpAppsService.addServerConfigs(
+      servers.map((s) => ({
+        name: s.name,
+        url: s.url,
+        headers: Object.fromEntries(s.headers.map((h) => [h.name, h.value])),
+      })),
+    );
+  }
+
   async reconnectSession(
     params: ReconnectSessionInput,
   ): Promise<SessionResponse | null> {

packages/workspace-server/src/services/agent/auth-adapter.ts

@@ -79,6 +79,17 @@ export class AgentAuthAdapter {
     };
   }
 
+  /**
+   * The current signed-in credentials from auth state, or null when no project is
+   * selected. Lets the mcp-apps config resolver register servers for a cloud run
+   * without a session (where the renderer never supplies credentials).
+   */
+  async getCurrentCredentials(): Promise<Credentials | null> {
+    const { apiHost } = await this.authService.getValidAccessToken();
+    const projectId = this.authService.getState().currentProjectId;
+    return projectId === null ? null : { apiHost, projectId };
+  }
+
   async buildMcpServers(credentials: Credentials): Promise<{
     servers: AcpMcpServer[];
     toolApprovals: McpToolApprovals;

packages/workspace-server/src/services/agent/ports.ts

@@ -28,6 +28,8 @@ export interface AgentMcpServerConnectionConfig {
 export interface AgentMcpApps {
   handleDiscovery(serverNames: string[]): Promise<void>;
   setServerConfigs(configs: AgentMcpServerConnectionConfig[]): void;
+  addServerConfigs(configs: AgentMcpServerConnectionConfig[]): void;
+  setConfigResolver(resolver: (serverName: string) => Promise<void>): void;
   notifyToolCancelled(toolKey: string, toolCallId: string): void;
   notifyToolInput(toolKey: string, toolCallId: string, args: unknown): void;
   notifyToolResult(
@@ -56,6 +58,7 @@ type AgentFetchLike = (
 export interface AgentAuth {
   getValidAccessToken(): Promise<{ accessToken: string; apiHost: string }>;
   refreshAccessToken(): Promise<{ accessToken: string; apiHost: string }>;
+  getState(): { currentProjectId: number | null };
   authenticatedFetch(
     fetchImpl: AgentFetchLike,
     input: string | Request,