fix(server): T3 tools work again after a thread switches back to a reused provider session

apps/server/src/orchestration-v2/ProviderSessionManager.test.ts

@@ -2406,6 +2406,61 @@ it.effect(
     }),
 );
 
+it.effect(
+  "ProviderSessionManagerV2 takes the thread's MCP credential back when a run returns to a still-attached session",
+  () =>
+    Effect.gen(function* () {
+      const state = yield* Ref.make(emptyState);
+      const effect = Effect.gen(function* () {
+        const eventSink = yield* EventSink.EventSinkV2;
+        const idAllocator = yield* IdAllocator.IdAllocatorV2;
+        const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
+        const registry = yield* McpSessionRegistry.McpSessionRegistry;
+        const now = yield* DateTime.now;
+        const threadId = ThreadId.make("thread-provider-session-manager-returning-provider");
+        const providerSessionId = yield* idAllocator.allocate.providerSession({
+          providerInstanceId: modelSelection.instanceId,
+          threadId,
+        });
+        const tokenOf = (config: McpProviderSession.McpProviderSessionConfig | undefined) =>
+          config?.authorizationHeader.replace(/^Bearer\s+/, "") ?? "";
+
+        yield* eventSink.write({
+          events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
+        });
+        yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
+
+        // The thread switches to another provider, whose attach replaces the
+        // thread's credential while this session stays attached.
+        yield* registry.revokeThread(threadId);
+        const otherProvider = yield* registry.issue({
+          threadId,
+          providerInstanceId: ProviderInstanceId.make("claudeAgent"),
+        });
+        McpProviderSession.setMcpProviderSession(otherProvider.config);
+
+        // The thread switches back and its next turn reuses this session.
+        yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
+        assert.equal((yield* Ref.get(state)).openCount, 1);
+
+        const reclaimed = McpProviderSession.readMcpProviderSession(threadId);
+        assert.equal(reclaimed?.providerInstanceId, modelSelection.instanceId);
+        assert.equal(
+          (yield* registry.resolve(tokenOf(reclaimed)))?.thread.providerInstanceId,
+          modelSelection.instanceId,
+        );
+        assert.isUndefined(yield* registry.resolve(tokenOf(otherProvider.config)));
+
+        // The session's record follows the new credential, so release revokes it.
+        yield* manager.close(providerSessionId);
+        assert.isUndefined(yield* registry.resolve(tokenOf(reclaimed)));
+        assert.isUndefined(McpProviderSession.readMcpProviderSession(threadId));
+      });
+
+      yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1_000 })));
+    }),
+);
+
 it.effect(
   "ProviderSessionManagerV2 revokes a rotated credential despite a stale record on another live session",
   () =>

apps/server/src/orchestration-v2/ProviderSessionManager.ts

@@ -1308,22 +1308,34 @@ export const layerWithOptions = (
               Effect.tap((runtime) => Effect.sync(() => (attachedTo = runtime))),
               Effect.uninterruptible,
             );
+            // A thread stays attached to the session it ran on before switching
+            // providers, and the other provider's attach took over the thread's
+            // credential slot. A run returning to this session must take it
+            // back, or the process calls T3 tools scoped to the other provider.
+            const reclaimsCredential =
+              attached === undefined &&
+              McpProviderSession.readMcpProviderSession(input.threadId)?.providerInstanceId !==
+                input.providerInstanceId &&
+              (yield* Ref.get(sessions))
+                .get(sessionKey(input.providerSessionId))
+                ?.attachedThreadIds.has(input.threadId) === true;
+            if (attached === undefined && !reclaimsCredential) return;
+            const prepared = yield* prepareMcpSession(input.threadId, input.providerInstanceId);
+            preparedForCleanup = prepared;
+            if (prepared.mcpCredentialId !== undefined) {
+              const mcpCredentialId = prepared.mcpCredentialId;
+              yield* Ref.update(sessions, (current) => {
+                const key = sessionKey(input.providerSessionId);
+                const entry = current.get(key);
+                if (entry === undefined) return current;
+                const mcpCredentialIdByThread = new Map(entry.mcpCredentialIdByThread);
+                mcpCredentialIdByThread.set(input.threadId, mcpCredentialId);
+                const updated = new Map(current);
+                updated.set(key, { ...entry, mcpCredentialIdByThread });
+                return updated;
+              });
+            }
             if (attached !== undefined) {
-              const prepared = yield* prepareMcpSession(input.threadId, input.providerInstanceId);
-              preparedForCleanup = prepared;
-              if (prepared.mcpCredentialId !== undefined) {
-                const mcpCredentialId = prepared.mcpCredentialId;
-                yield* Ref.update(sessions, (current) => {
-                  const key = sessionKey(input.providerSessionId);
-                  const entry = current.get(key);
-                  if (entry === undefined) return current;
-                  const mcpCredentialIdByThread = new Map(entry.mcpCredentialIdByThread);
-                  mcpCredentialIdByThread.set(input.threadId, mcpCredentialId);
-                  const updated = new Map(current);
-                  updated.set(key, { ...entry, mcpCredentialIdByThread });
-                  return updated;
-                });
-              }
               const entry = (yield* Ref.get(sessions)).get(sessionKey(input.providerSessionId));
               if (entry !== undefined) {
                 yield* withActivityError(