@akira-tl/forgerelay 0.8.5 → 0.8.6

package/dist/composite-activity.js

@@ -21,7 +21,7 @@ export class CompositeActivityCoordinator {
             remoteActivities: new Map(),
             remoteOutputs: new Map(),
         });
-        return snapshotResult(snapshot, `Started Composite Workspace Host Turn ${snapshot.turnId}.`);
+        return panelResult(snapshot, `Started Composite Workspace Host Turn ${snapshot.turnId}.`);
     }
     currentTurnId(conversationScopeId, compositeWorkspaceId) {
         const turnId = this.queries.currentTurnId(conversationScopeId, compositeWorkspaceId);
@@ -43,6 +43,8 @@ export class CompositeActivityCoordinator {
             member,
             workspaceId: executionWorkspaceId,
             remoteTurnId,
+            stateRevision: optionalNonnegativeInteger(panel.structuredContent, "revision"),
+            state: optionalActivityState(panel.structuredContent),
         });
         return turnId;
     }
@@ -50,47 +52,86 @@ export class CompositeActivityCoordinator {
         const state = this.turns.get(turnId);
         if (!state)
             return undefined;
-        const local = this.queries.snapshot(turnId);
+        const local = this.queries.state(turnId);
         const remoteSnapshots = await Promise.all([...state.remoteMembers.values()].map(async (route) => ({
             route,
-            snapshot: await this.remoteWorkspaces.activitySnapshot({ turnId: route.remoteTurnId }, state.conversationScopeId),
+            snapshot: await this.remoteWorkspaces.activitySnapshot({
+                turnId: route.remoteTurnId,
+                ...(route.stateRevision !== undefined ? { knownRevision: route.stateRevision } : {}),
+            }, state.conversationScopeId),
         })));
-        state.remoteActivities.clear();
-        state.remoteOutputs.clear();
-        const remoteActivities = [];
         let revision = local.revision;
         for (const { route, snapshot } of remoteSnapshots) {
             if (!snapshot?.structuredContent)
                 continue;
-            const structured = snapshot.structuredContent;
-            const remoteRevision = structured.revision;
-            if (typeof remoteRevision === "number" && Number.isInteger(remoteRevision) && remoteRevision >= 0) {
-                revision += remoteRevision;
-            }
-            const activities = Array.isArray(structured.activities)
+            const remoteRevision = optionalNonnegativeInteger(snapshot.structuredContent, "revision");
+            const remoteState = optionalActivityState(snapshot.structuredContent);
+            if (remoteRevision !== undefined)
+                route.stateRevision = remoteRevision;
+            if (remoteState !== undefined)
+                route.state = remoteState;
+            revision += route.stateRevision ?? 0;
+        }
+        const snapshot = {
+            turnId,
+            revision,
+            changed: knownRevision === undefined || knownRevision !== revision,
+            state: aggregateSourceState(local, state.remoteMembers.values()),
+        };
+        return dataResult(snapshot);
+    }
+    async index(turnId, knownRevision) {
+        const state = this.turns.get(turnId);
+        if (!state)
+            return undefined;
+        const incremental = knownRevision !== undefined && state.lastIndexRevision === knownRevision;
+        const local = this.queries.index(turnId, incremental ? state.localIndexRevision : undefined);
+        const remoteIndexes = await Promise.all([...state.remoteMembers.values()].map(async (route) => ({
+            route,
+            index: await this.remoteWorkspaces.activityIndex(route.remoteTurnId, incremental ? route.indexRevision : undefined, state.conversationScopeId),
+        })));
+        state.localIndexRevision = local.revision;
+        const returnedRemoteActivities = [];
+        for (const { route, index } of remoteIndexes) {
+            if (!index?.structuredContent)
+                continue;
+            const structured = index.structuredContent;
+            const remoteRevision = optionalNonnegativeInteger(structured, "revision");
+            const remoteState = optionalActivityState(structured);
+            const incoming = Array.isArray(structured.activities)
                 ? structured.activities
                 : [];
-            for (const activity of activities) {
-                const presented = { ...activity, member: route.member };
-                remoteActivities.push(presented);
-                state.remoteActivities.set(activity.activityId, route);
-                if (activity.outputId)
-                    state.remoteOutputs.set(activity.outputId, route);
+            if (remoteRevision !== undefined) {
+                route.indexRevision = remoteRevision;
+                route.stateRevision = remoteRevision;
             }
+            if (remoteState !== undefined)
+                route.state = remoteState;
+            route.activities = incremental
+                ? mergeActivities(route.activities ?? [], incoming)
+                : [...incoming];
+            returnedRemoteActivities.push(...(incremental ? incoming : route.activities).map((activity) => ({
+                ...activity,
+                member: route.member,
+            })));
         }
-        const activities = [...local.activities, ...remoteActivities]
-            .sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+        rebuildRemoteRoutes(state);
+        const revision = local.revision + [...state.remoteMembers.values()]
+            .reduce((sum, route) => sum + (route.indexRevision ?? route.stateRevision ?? 0), 0);
         const changed = knownRevision === undefined || knownRevision !== revision;
-        const snapshot = {
+        const activities = changed
+            ? [...local.activities, ...returnedRemoteActivities]
+                .sort((left, right) => left.startedAt.localeCompare(right.startedAt))
+            : [];
+        state.lastIndexRevision = revision;
+        const index = {
             turnId,
             revision,
             changed,
-            state: aggregateState(activities),
-            activities: changed ? activities : [],
+            state: aggregateSourceState(local, state.remoteMembers.values()),
+            activities,
         };
-        return snapshotResult(snapshot, changed
-            ? `Composite Activity snapshot ${turnId} revision ${revision}.`
-            : `Composite Activity snapshot ${turnId} unchanged at revision ${revision}.`);
+        return dataResult(index);
     }
     async detail(turnId, activityId) {
         const state = this.turns.get(turnId);
@@ -114,14 +155,14 @@ export class CompositeActivityCoordinator {
             },
         };
     }
-    async output(turnId, outputId) {
+    async output(turnId, outputId, cursor) {
         const state = this.turns.get(turnId);
         if (!state)
             return undefined;
         const route = state.remoteOutputs.get(outputId);
         if (!route)
             return undefined;
-        return this.remoteWorkspaces.activityOutput(route.remoteTurnId, outputId, state.conversationScopeId);
+        return this.remoteWorkspaces.activityOutput(route.remoteTurnId, outputId, state.conversationScopeId, cursor);
     }
     forgetComposite(workspaceId) {
         for (const [turnId, state] of this.turns) {
@@ -130,21 +171,71 @@ export class CompositeActivityCoordinator {
         }
     }
 }
-function snapshotResult(snapshot, text) {
+function panelResult(snapshot, text) {
     return {
         content: [{ type: "text", text }],
         structuredContent: snapshot,
     };
 }
-function aggregateState(activities) {
-    if (activities.length === 0)
+function dataResult(snapshot) {
+    return {
+        content: [],
+        structuredContent: snapshot,
+    };
+}
+function aggregateSourceState(local, remotes) {
+    const sources = [
+        ...(local.revision > 0 ? [{ revision: local.revision, state: local.state }] : []),
+        ...[...remotes].flatMap((route) => {
+            const revision = route.stateRevision ?? route.indexRevision ?? 0;
+            return revision > 0 && route.state ? [{ revision, state: route.state }] : [];
+        }),
+    ];
+    if (sources.length === 0)
         return "working";
-    if (activities.some((activity) => activity.status === "working"))
+    if (sources.some((source) => source.state === "working"))
         return "working";
-    if (activities.some((activity) => activity.status === "error"))
+    if (sources.some((source) => source.state === "error"))
         return "error";
     return "done";
 }
+function mergeActivities(current, incoming) {
+    const updates = new Map(incoming.map((activity) => [activity.activityId, activity]));
+    const merged = current.map((activity) => updates.get(activity.activityId) ?? activity);
+    const existing = new Set(current.map((activity) => activity.activityId));
+    for (const activity of incoming) {
+        if (!existing.has(activity.activityId))
+            merged.push(activity);
+    }
+    return merged;
+}
+function rebuildRemoteRoutes(state) {
+    state.remoteActivities.clear();
+    state.remoteOutputs.clear();
+    for (const route of state.remoteMembers.values()) {
+        for (const activity of route.activities ?? []) {
+            state.remoteActivities.set(activity.activityId, route);
+            if (activity.outputId)
+                state.remoteOutputs.set(activity.outputId, route);
+        }
+    }
+}
+function optionalNonnegativeInteger(value, field) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const candidate = value[field];
+    return typeof candidate === "number" && Number.isInteger(candidate) && candidate >= 0
+        ? candidate
+        : undefined;
+}
+function optionalActivityState(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const candidate = value.state;
+    return candidate === "working" || candidate === "done" || candidate === "error"
+        ? candidate
+        : undefined;
+}
 function requiredString(value, field, label) {
     if (!value || typeof value !== "object")
         throw new Error(`${label} did not return structured content.`);

package/dist/config.js

@@ -1,4 +1,3 @@
-import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { expandHomePath } from "./roots.js";
@@ -49,7 +48,7 @@ function parseBoolean(value) {
     return ["1", "true", "yes", "on"].includes(value?.toLowerCase() ?? "");
 }
 function productEnv(env, suffix) {
-    return env[`FORGERELAY_${suffix}`] ?? env[`DEVSPACE_${suffix}`];
+    return env[`FORGERELAY_${suffix}`];
 }
 function parseToolMode(env) {
     const mode = productEnv(env, "TOOL_MODE");
@@ -57,9 +56,9 @@ function parseToolMode(env) {
         return mode;
     if (mode)
         throw new Error(`Invalid FORGERELAY_TOOL_MODE: ${mode}`);
-    const legacyMinimal = productEnv(env, "MINIMAL_TOOLS");
-    if (legacyMinimal !== undefined) {
-        return parseBoolean(legacyMinimal) ? "minimal" : "full";
+    const minimalTools = productEnv(env, "MINIMAL_TOOLS");
+    if (minimalTools !== undefined) {
+        return parseBoolean(minimalTools) ? "minimal" : "full";
     }
     return "minimal";
 }
@@ -173,14 +172,10 @@ function parseOAuthConfig(env, ownerToken) {
     };
 }
 function defaultStateDir() {
-    const current = join(homedir(), ".local", "share", "forgerelay");
-    const legacy = join(homedir(), ".local", "share", "devspace");
-    return existsSync(current) || !existsSync(legacy) ? current : legacy;
+    return join(homedir(), ".local", "share", "forgerelay");
 }
 function defaultWorktreeRoot() {
-    const current = join(homedir(), ".forgerelay", "worktrees");
-    const legacy = join(homedir(), ".devspace", "worktrees");
-    return existsSync(current) || !existsSync(legacy) ? current : legacy;
+    return join(homedir(), ".forgerelay", "worktrees");
 }
 function defaultAgentDir() {
     return join(homedir(), ".codex");
@@ -260,8 +255,8 @@ export function loadConfig(env = process.env) {
         taskReminderInterval: parseNonNegativeInteger(productEnv(env, "TASK_REMINDER_INTERVAL") ?? numberConfigValue(files.config.taskReminderInterval), DEFAULT_TASK_REMINDER_INTERVAL, "FORGERELAY_TASK_REMINDER_INTERVAL"),
         skillsEnabled: productEnv(env, "SKILLS") === undefined ? true : parseBoolean(productEnv(env, "SKILLS")),
         skillPaths: parsePathList(productEnv(env, "SKILL_PATHS")),
-        devspaceSkillsDir: forgerelaySkillsDir(env),
-        devspaceAgentsDir: forgerelayAgentsDir(env),
+        configSkillsDir: forgerelaySkillsDir(env),
+        configAgentsDir: forgerelayAgentsDir(env),
         subagents: productEnv(env, "SUBAGENTS") === undefined
             ? files.config.subagents === true
             : parseBoolean(productEnv(env, "SUBAGENTS")),

package/dist/lsp/test-support/server-fixture.js

@@ -26,13 +26,13 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
     await writeFile(join(agentDir, "AGENTS.md"), "global instructions\n");
     await writeFile(join(project, "AGENTS.md"), "project instructions\n");
     const config = loadConfig({
-        DEVSPACE_CONFIG_DIR: join(root, ".config"),
-        DEVSPACE_ALLOWED_ROOTS: root,
-        DEVSPACE_WORKTREE_ROOT: join(root, ".worktrees"),
-        DEVSPACE_AGENT_DIR: agentDir,
-        DEVSPACE_WIDGETS: "full",
-        DEVSPACE_TOOL_MODE: "full",
-        DEVSPACE_OAUTH_OWNER_TOKEN: "test-owner-token-that-is-long-enough",
+        FORGERELAY_CONFIG_DIR: join(root, ".config"),
+        FORGERELAY_ALLOWED_ROOTS: root,
+        FORGERELAY_WORKTREE_ROOT: join(root, ".worktrees"),
+        FORGERELAY_AGENT_DIR: agentDir,
+        FORGERELAY_WIDGETS: "full",
+        FORGERELAY_TOOL_MODE: "full",
+        FORGERELAY_OAUTH_OWNER_TOKEN: "test-owner-token-that-is-long-enough",
         PORT: "1",
     });
     const store = new SqliteWorkspaceStore(stateDir);

package/dist/process-sessions.js

@@ -65,8 +65,8 @@ function processEnvironment(input) {
         ...(input?.codexCi ? { CODEX_CI: "1" } : {}),
         LANG: process.env.LANG ?? "C.UTF-8",
         LC_ALL: process.env.LC_ALL ?? "C.UTF-8",
-        ...(input?.workspaceId ? { FORGERELAY_WORKSPACE_ID: input.workspaceId, DEVSPACE_WORKSPACE_ID: input.workspaceId } : {}),
-        ...(input?.workspaceRoot ? { FORGERELAY_WORKSPACE_ROOT: input.workspaceRoot, DEVSPACE_WORKSPACE_ROOT: input.workspaceRoot } : {}),
+        ...(input?.workspaceId ? { FORGERELAY_WORKSPACE_ID: input.workspaceId } : {}),
+        ...(input?.workspaceRoot ? { FORGERELAY_WORKSPACE_ROOT: input.workspaceRoot } : {}),
     };
 }
 function codePointLength(value) {

package/dist/remote-auth.js

@@ -47,7 +47,7 @@ export function isRemoteMcpUnauthorized(error) {
     return error instanceof UnauthorizedError ||
         (error instanceof StreamableHTTPError && error.code === 401);
 }
-export async function withRemoteMcpClient(remote, endpointInput, operation) {
+export async function connectRemoteMcpClient(remote, endpointInput) {
     const endpoint = normalizeRemoteServiceTarget(endpointInput);
     const client = new Client({ name: "forgerelay-cli", version: packageVersion });
     const transport = new StreamableHTTPClientTransport(publicEndpointUrl(endpoint, "mcp"), {
@@ -57,6 +57,16 @@ export async function withRemoteMcpClient(remote, endpointInput, operation) {
     });
     try {
         await client.connect(transport);
+        return client;
+    }
+    catch (error) {
+        await client.close().catch(() => undefined);
+        throw error;
+    }
+}
+export async function withRemoteMcpClient(remote, endpointInput, operation) {
+    const client = await connectRemoteMcpClient(remote, endpointInput);
+    try {
         return await operation(client);
     }
     finally {

package/dist/remote-mcp-connection-pool.js

@@ -0,0 +1,90 @@
+import { connectRemoteMcpClient } from "./remote-auth.js";
+import { openRemoteServiceEndpoint, } from "./remote-transport.js";
+export class RemoteMcpConnectionPool {
+    entries = new Map();
+    async get(remote) {
+        const fingerprint = connectionFingerprint(remote);
+        const existing = this.entries.get(remote.instanceId);
+        if (existing?.fingerprint === fingerprint)
+            return existing.promise;
+        if (existing)
+            await this.closeEntry(remote.instanceId, existing);
+        const entry = {
+            fingerprint,
+            promise: this.create(remote),
+        };
+        this.entries.set(remote.instanceId, entry);
+        try {
+            return await entry.promise;
+        }
+        catch (error) {
+            if (this.entries.get(remote.instanceId) === entry) {
+                this.entries.delete(remote.instanceId);
+            }
+            throw error;
+        }
+    }
+    async invalidate(instanceId, expected) {
+        const entry = this.entries.get(instanceId);
+        if (!entry)
+            return;
+        let connection;
+        try {
+            connection = await entry.promise;
+        }
+        catch {
+            if (this.entries.get(instanceId) === entry)
+                this.entries.delete(instanceId);
+            return;
+        }
+        if (expected && connection !== expected)
+            return;
+        await this.closeEntry(instanceId, entry, connection);
+    }
+    async closeAll() {
+        const entries = [...this.entries.entries()];
+        this.entries.clear();
+        await Promise.all(entries.map(async ([, entry]) => {
+            try {
+                const connection = await entry.promise;
+                await closeConnection(connection);
+            }
+            catch {
+                // Failed connection attempts already clean up their endpoint lease.
+            }
+        }));
+    }
+    async create(remote) {
+        const lease = await openRemoteServiceEndpoint(remote.target, remote.sshRoute);
+        try {
+            const client = await connectRemoteMcpClient(remote, lease.endpoint);
+            return { client, endpoint: lease.endpoint, lease };
+        }
+        catch (error) {
+            await lease.close().catch(() => undefined);
+            throw error;
+        }
+    }
+    async closeEntry(instanceId, entry, resolved) {
+        if (this.entries.get(instanceId) === entry)
+            this.entries.delete(instanceId);
+        try {
+            const connection = resolved ?? await entry.promise;
+            await closeConnection(connection);
+        }
+        catch {
+            // Failed connection attempts already clean up their endpoint lease.
+        }
+    }
+}
+async function closeConnection(connection) {
+    await connection.client.close().catch(() => undefined);
+    await connection.lease.close().catch(() => undefined);
+}
+function connectionFingerprint(remote) {
+    return JSON.stringify({
+        target: remote.target,
+        sshRoute: remote.sshRoute ?? [],
+        accessToken: remote.accessToken,
+    });
+}

package/dist/remote-transport.js

@@ -36,9 +36,10 @@ export async function readRemoteOwnerToken(sshRoute) {
         throw new Error("SSH owner-token command returned an empty token.");
     return token;
 }
-export async function withRemoteServiceEndpoint(target, sshRoute, operation) {
-    if (!sshRoute)
-        return operation(target);
+export async function openRemoteServiceEndpoint(target, sshRoute) {
+    if (!sshRoute) {
+        return { endpoint: target, close: async () => undefined };
+    }
     const url = new URL(target);
     if (url.protocol === "https:") {
         throw new Error("SSH-routed HTTPS service targets are not supported because loopback forwarding breaks TLS hostname verification; use the remote ForgeRelay HTTP loopback endpoint through SSH or direct HTTPS.");
@@ -73,19 +74,32 @@ export async function withRemoteServiceEndpoint(target, sshRoute, operation) {
     });
     try {
         await waitForLoopbackPort(tunnel, localPort, stderr, () => spawnError, () => forwardingReady);
-        const mapped = new URL(url);
-        mapped.hostname = "127.0.0.1";
-        mapped.port = String(localPort);
-        try {
-            return await operation(mapped.toString().replace(/\/$/, ""));
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Remote service request through SSH tunnel failed: ${message}`, { cause: error });
-        }
     }
-    finally {
+    catch (error) {
         await stopTunnel(tunnel);
+        throw error;
+    }
+    const mapped = new URL(url);
+    mapped.hostname = "127.0.0.1";
+    mapped.port = String(localPort);
+    return {
+        endpoint: mapped.toString().replace(/\/$/, ""),
+        close: () => stopTunnel(tunnel),
+    };
+}
+export async function withRemoteServiceEndpoint(target, sshRoute, operation) {
+    const lease = await openRemoteServiceEndpoint(target, sshRoute);
+    try {
+        return await operation(lease.endpoint);
+    }
+    catch (error) {
+        if (!sshRoute)
+            throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Remote service request through SSH tunnel failed: ${message}`, { cause: error });
+    }
+    finally {
+        await lease.close();
     }
 }
 function sshDestinationArgs(sshRoute) {

package/dist/remote-workspace-relay.js

@@ -2,7 +2,8 @@ import { randomBytes } from "node:crypto";
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
-import { isRemoteMcpUnauthorized, refreshRemoteAuthentication, withRemoteMcpClient, } from "./remote-auth.js";
+import { isRemoteMcpUnauthorized, refreshRemoteAuthentication, } from "./remote-auth.js";
+import { RemoteMcpConnectionPool } from "./remote-mcp-connection-pool.js";
 import { withRemoteServiceEndpoint } from "./remote-transport.js";
 import { loadForgeRelayFiles, writeForgeRelayRemote, } from "./user-config.js";
 const ROUTE_LOCK_RETRY_MS = 10;
@@ -15,6 +16,7 @@ export class RemoteWorkspaceRelay {
     authEnv;
     routeStateDir;
     routeStatePath;
+    mcpConnections = new RemoteMcpConnectionPool();
     constructor(configDir, stateDir) {
         this.authEnv = { FORGERELAY_CONFIG_DIR: configDir };
         this.routeStateDir = stateDir;
@@ -27,6 +29,9 @@ export class RemoteWorkspaceRelay {
         this.loadRoutes();
         return this.routes.has(workspaceId);
     }
+    async shutdown() {
+        await this.mcpConnections.closeAll();
+    }
     async inspectWorkspace(gatewayWorkspaceId) {
         const route = this.requireRoute(gatewayWorkspaceId);
         const resolved = this.remoteByInstance(route.remoteInstanceId);
@@ -235,11 +240,14 @@ export class RemoteWorkspaceRelay {
             throw sanitizedRemoteError(error, route.remoteWorkspaceId, gatewayWorkspaceId);
         }
     }
+    async activityIndex(turnId, knownRevision, conversationScopeId) {
+        return this.callTurnTool(turnId, "activity_index", { turnId, ...(knownRevision !== undefined ? { knownRevision } : {}) }, conversationScopeId);
+    }
     async activityDetail(turnId, activityId, conversationScopeId) {
         return this.callTurnTool(turnId, "activity_detail", { turnId, activityId }, conversationScopeId);
     }
-    async activityOutput(turnId, outputId, conversationScopeId) {
-        return this.callTurnTool(turnId, "activity_output", { turnId, outputId }, conversationScopeId);
+    async activityOutput(turnId, outputId, conversationScopeId, cursor) {
+        return this.callTurnTool(turnId, "activity_output", { turnId, outputId, ...(cursor !== undefined ? { cursor } : {}) }, conversationScopeId);
     }
     async callTurnTool(turnId, name, args, conversationScopeId) {
         const gatewayWorkspaceId = this.turnRoutes.get(turnId);
@@ -464,31 +472,53 @@ export class RemoteWorkspaceRelay {
         return { alias: entry[0], remote: entry[1] };
     }
     async callRemoteTool(alias, initialRemote, name, args, conversationScopeId) {
-        return withRemoteServiceEndpoint(initialRemote.target, initialRemote.sshRoute, async (endpoint) => {
-            let remote = initialRemote;
-            let refreshed = false;
-            if (remote.accessTokenExpiresAt <= Math.floor(Date.now() / 1000)) {
-                remote = await this.refreshRemote(alias, remote, endpoint);
+        let remote = initialRemote;
+        let refreshed = false;
+        if (remote.accessTokenExpiresAt <= Math.floor(Date.now() / 1000)) {
+            remote = await withRemoteServiceEndpoint(remote.target, remote.sshRoute, (endpoint) => this.refreshRemote(alias, remote, endpoint));
+            refreshed = true;
+        }
+        let connection;
+        try {
+            connection = await this.mcpConnections.get(remote);
+        }
+        catch (error) {
+            if (!refreshed && isRemoteMcpUnauthorized(error)) {
+                remote = await withRemoteServiceEndpoint(remote.target, remote.sshRoute, (endpoint) => this.refreshRemote(alias, remote, endpoint));
                 refreshed = true;
+                connection = await this.mcpConnections.get(remote);
             }
-            const invoke = () => withRemoteMcpClient(remote, endpoint, async (client) => CallToolResultSchema.parse(await client.callTool({
-                name,
-                arguments: args,
-                ...(conversationScopeId
-                    ? { _meta: { "openai/session": conversationScopeId } }
-                    : {}),
-            })));
-            try {
-                return await invoke();
+            else {
+                throw new Error(`Remote ForgeRelay ${alias} request failed: ${errorMessage(error)}`, { cause: error });
             }
-            catch (error) {
-                if (!refreshed && isRemoteMcpUnauthorized(error)) {
-                    remote = await this.refreshRemote(alias, remote, endpoint);
-                    return invoke();
+        }
+        const invoke = async (active) => CallToolResultSchema.parse(await active.client.callTool({
+            name,
+            arguments: args,
+            ...(conversationScopeId
+                ? { _meta: { "openai/session": conversationScopeId } }
+                : {}),
+        }));
+        try {
+            return await invoke(connection);
+        }
+        catch (error) {
+            if (!refreshed && isRemoteMcpUnauthorized(error)) {
+                remote = await this.refreshRemote(alias, remote, connection.endpoint);
+                refreshed = true;
+                await this.mcpConnections.invalidate(remote.instanceId, connection);
+                const refreshedConnection = await this.mcpConnections.get(remote);
+                try {
+                    return await invoke(refreshedConnection);
+                }
+                catch (retryError) {
+                    await this.mcpConnections.invalidate(remote.instanceId, refreshedConnection);
+                    throw new Error(`Remote ForgeRelay ${alias} request failed: ${errorMessage(retryError)}`, { cause: retryError });
                 }
-                throw new Error(`Remote ForgeRelay ${alias} request failed: ${errorMessage(error)}`, { cause: error });
             }
-        });
+            await this.mcpConnections.invalidate(remote.instanceId, connection);
+            throw new Error(`Remote ForgeRelay ${alias} request failed: ${errorMessage(error)}`, { cause: error });
+        }
     }
     async refreshRemote(alias, remote, endpoint) {
         const refreshed = await refreshRemoteAuthentication(remote, endpoint);