fix the initial team swithc issue

Author: Dhruvkumar-Microsoft

src/App/src/api/apiClient.tsx

@@ -20,10 +20,10 @@ function syncBaseUrl(): void {
 }
 
 export const apiClient = {
-    get: <T = any>(url: string, config?: { params?: Record<string, unknown> }): Promise<T> => {
-        syncBaseUrl();
-        return httpClient.get<T>(url, { params: config?.params });
-    },
+   get: <T = any>(url: string, config?: { params?: Record<string, unknown>; timeout?: number }): Promise<T> => {
+       syncBaseUrl();
+       return httpClient.get<T>(url, { params: config?.params, timeout: config?.timeout });
+   },
 
     post: <T = any>(url: string, body?: unknown): Promise<T> => {
         syncBaseUrl();

src/App/src/api/httpClient.ts

@@ -61,11 +61,11 @@ class HttpClient {
     }
 
     /** Core request method — applies interceptors, timeout, and error handling */
-    private async request(
+   private async request(
         path: string,
-        options: RequestInit & { params?: Record<string, unknown> } = {}
+        options: RequestInit & { params?: Record<string, unknown>; timeout?: number } = {}
     ): Promise<Response> {
-        const { params, ...fetchOptions } = options;
+        const { params, timeout, ...fetchOptions } = options;
         const url = this.buildUrl(path, params);
 
         // Build initial config
@@ -78,9 +78,11 @@ class HttpClient {
 
         const { url: finalUrl, ...rest } = config;
 
-        // Timeout via AbortController
+
+        // Timeout via AbortController (per-request override falls back to the default)
         const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const timeoutId = setTimeout(() => controller.abort(), timeout ?? this.timeout);
+
 
         try {
             let response = await fetch(finalUrl, {
@@ -102,12 +104,13 @@ class HttpClient {
     /** HTTP GET */
     async get<T = unknown>(
         path: string,
-        config?: { params?: Record<string, unknown>; headers?: Record<string, string> }
+        config?: { params?: Record<string, unknown>; headers?: Record<string, string>; timeout?: number }
     ): Promise<T> {
         const response = await this.request(path, {
             method: 'GET',
             params: config?.params,
             headers: config?.headers,
+            timeout: config?.timeout,
         });
 
         if (!response.ok) {

src/backend/api/router.py

@@ -341,19 +341,31 @@ async def process_request(
 
     # Ensure the workflow is valid (rebuild if terminated or stuck from a prior run)
     current_workflow = orchestration_config.get_current_orchestration(user_id)
+
+    cached_team_id = getattr(current_workflow, "_team_id", None)
+    team_mismatch = (
+        current_workflow is not None and cached_team_id != team_id
+    )
+
     workflow_unusable = (
         current_workflow is None
         or getattr(current_workflow, "_terminated", False)
         or getattr(current_workflow, "_is_running", False)
+        or team_mismatch
     )
     if workflow_unusable:
         logger.info(
-            "Workflow unusable for user '%s' (None=%s, terminated=%s, is_running=%s) — rebuilding",
+            "Workflow unusable for user '%s' (None=%s, terminated=%s, is_running=%s, "
+            "team_mismatch=%s cached_team=%s selected_team=%s) — rebuilding",
             user_id,
             current_workflow is None,
             getattr(current_workflow, "_terminated", False),
             getattr(current_workflow, "_is_running", False),
+            team_mismatch,
+            cached_team_id,
+            team_id,
         )
+
         # Force-clear the running flag so get_current_or_new_orchestration
         # sees it as terminated and takes the lightweight reset path.
         if current_workflow is not None and getattr(current_workflow, "_is_running", False):

src/backend/orchestration/orchestration_manager.py

@@ -202,10 +202,35 @@ async def get_current_or_new_orchestration(
         current = orchestration_config.get_current_orchestration(user_id)
         workflow_terminated = getattr(current, "_terminated", False)
 
-        # Full rebuild: no workflow exists or team explicitly changed
-        needs_full_rebuild = current is None or team_switched
+        # Detect a stale cached orchestration: it was built for a different team
+        # than the one now selected. Without this, /select_team leaves the prior
+        # team's workflow cached and the next run executes the wrong agents until
+        # a page refresh rebuilds it. The team_id tag is set on every workflow we
+        # build/reset below.
+        current_team_id = getattr(current, "_team_id", None)
+        team_changed = (
+            current is not None and current_team_id != team_config.team_id
+        )
+
+
+        cls.logger.info(
+            "get_current_or_new_orchestration: user='%s' selected_team='%s' "
+            "cached_team='%s' team_switched=%s team_changed=%s current_is_none=%s",
+            user_id, team_config.team_id, current_team_id,
+            team_switched, team_changed, current is None,
+        )
+
+
+        # Full rebuild: no workflow exists, team explicitly switched, or the
+        # cached workflow belongs to a different team than the selected one.
+        needs_full_rebuild = current is None or team_switched or team_changed
+
+
+        # Lightweight reset: workflow finished but agents are still valid for the
+        # same team (a team change always routes to full rebuild above so we
+        # never reuse the previous team's agents here).
+
 
-        # Lightweight reset: workflow finished but agents are still valid
         needs_workflow_reset = not needs_full_rebuild and workflow_terminated
 
         if needs_full_rebuild: