@forestadmin/workflow-executor 1.12.0 → 1.14.0

package/dist/oauth/token-endpoint-url.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = assertSafeTokenEndpoint;
+const net_1 = __importDefault(require("net"));
+const errors_1 = require("../errors");
+// The token endpoint comes from the deposit body, and the executor POSTs the refresh grant (with
+// client credentials) to it — so an unconstrained value is an SSRF vector. The guard rejects hosts
+// that are never a legitimate endpoint but are prime SSRF targets (loopback, link-local /
+// cloud-metadata) and requires TLS, while deliberately allowing private (RFC1918) hosts: a private
+// OAuth provider reached over the internal network is a supported deployment, so blocking it would
+// break a real use case. http and loopback are relaxed only when NODE_ENV explicitly opts in
+// (development/test) — see isRelaxedEnv. Only IP literals are inspected — resolving a hostname here
+// would be racy (it can resolve to a different address at fetch time), not safer.
+// Fail closed: the strict rules (https + no loopback) apply everywhere UNLESS NODE_ENV explicitly
+// opts into the local-dev relaxation. An unset or misspelled NODE_ENV stays strict, so a
+// misconfigured deploy can't silently allow loopback targets or cleartext http.
+function isRelaxedEnv() {
+    return process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test';
+}
+function unbracket(hostname) {
+    return hostname.startsWith('[') && hostname.endsWith(']') ? hostname.slice(1, -1) : hostname;
+}
+function classifyIpv4(host) {
+    const [a, b] = host.split('.').map(Number);
+    return {
+        loopback: a === 127, // 127.0.0.0/8
+        linkLocal: a === 169 && b === 254, // 169.254.0.0/16
+        unspecified: a === 0, // 0.0.0.0/8 — "this host"; connects to loopback on Linux
+    };
+}
+// Returns the embedded IPv4 of an IPv4-mapped IPv6 address (otherwise null). The WHATWG URL parser
+// normalizes `::ffff:127.0.0.1` to the hex form `::ffff:7f00:1`, which would otherwise dodge the
+// IPv4 loopback/link-local checks and still reach the executor's loopback / metadata interface.
+function embeddedIpv4(host) {
+    const tail = host.toLowerCase().match(/^::ffff:(.+)$/)?.[1];
+    if (!tail)
+        return null;
+    if (net_1.default.isIPv4(tail))
+        return tail;
+    const hex = tail.match(/^([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
+    if (!hex)
+        return null;
+    const hi = parseInt(hex[1], 16); // high 16 bits → first two octets
+    const lo = parseInt(hex[2], 16); // low 16 bits → last two octets
+    return `${Math.floor(hi / 256)}.${hi % 256}.${Math.floor(lo / 256)}.${lo % 256}`;
+}
+function classify(host) {
+    const kind = net_1.default.isIP(host);
+    if (kind === 4)
+        return classifyIpv4(host);
+    if (kind === 6) {
+        const mapped = embeddedIpv4(host);
+        if (mapped)
+            return classifyIpv4(mapped);
+        const normalized = host.toLowerCase().split('%')[0]; // drop any zone id
+        const firstHextet = normalized.split(':')[0];
+        return {
+            loopback: normalized === '::1' || normalized === '0:0:0:0:0:0:0:1',
+            linkLocal: /^fe[89ab]/.test(firstHextet), // fe80::/10
+            unspecified: normalized === '::' || normalized === '0:0:0:0:0:0:0:0',
+        };
+    }
+    // Not an IP literal. Reject the reserved loopback names — bare `localhost`, the `.localhost` TLD
+    // (RFC 6761), and their trailing-dot FQDN forms — since they resolve to loopback. Other hostnames
+    // are left to the scheme rule; their DNS is not resolved here (a hostname pointed at an internal
+    // IP is the filtering-agent's job, not this string check).
+    return {
+        loopback: /^localhost\.?$|\.localhost\.?$/.test(host.toLowerCase()),
+        linkLocal: false,
+        unspecified: false,
+    };
+}
+function assertSafeTokenEndpoint(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new errors_1.InvalidTokenEndpointError('it is not a valid absolute URL');
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw new errors_1.InvalidTokenEndpointError('it must use http or https');
+    }
+    const { loopback, linkLocal, unspecified } = classify(unbracket(url.hostname));
+    if (unspecified) {
+        throw new errors_1.InvalidTokenEndpointError('it points at the unspecified address (0.0.0.0 / ::)');
+    }
+    if (linkLocal) {
+        throw new errors_1.InvalidTokenEndpointError('it points at a link-local / metadata address');
+    }
+    if (!isRelaxedEnv()) {
+        if (url.protocol !== 'https:') {
+            throw new errors_1.InvalidTokenEndpointError('it must use https');
+        }
+        if (loopback) {
+            throw new errors_1.InvalidTokenEndpointError('it points at the executor host (loopback)');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/oauth/token-service.d.ts

@@ -0,0 +1,34 @@
+import type { RefreshGrantParams, RefreshGrantResult } from './refresh-grant';
+import type CredentialEncryption from '../crypto/credential-encryption';
+import type { Logger } from '../ports/logger-port';
+import type { McpOAuthCredentialsStore } from '../ports/mcp-oauth-credentials-store';
+export interface OAuthTokenServiceOptions {
+    store: McpOAuthCredentialsStore;
+    encryption: CredentialEncryption;
+    logger?: Logger;
+    expirySkewS?: number;
+    refreshAccessToken?: (params: RefreshGrantParams) => Promise<RefreshGrantResult>;
+    now?: () => number;
+}
+export default class OAuthTokenService {
+    private readonly store;
+    private readonly encryption;
+    private readonly logger?;
+    private readonly expirySkewMs;
+    private readonly refreshAccessToken;
+    private readonly now;
+    private readonly cache;
+    private readonly mutex;
+    private readonly evictionEpoch;
+    constructor(options: OAuthTokenServiceOptions);
+    getAccessToken(userId: number, mcpServerId: string, options?: {
+        forceRefresh?: boolean;
+    }): Promise<string>;
+    evict(userId: number, mcpServerId: string): void;
+    private readCache;
+    private refreshAndCache;
+    private runGrantWithRotationRetry;
+    private toGrantParams;
+    private persistRotatedRefreshToken;
+}
+//# sourceMappingURL=token-service.d.ts.map

package/dist/oauth/token-service.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const defaults_1 = require("../defaults");
+const errors_1 = require("../errors");
+const keyed_mutex_1 = __importDefault(require("./keyed-mutex"));
+const refresh_grant_1 = __importDefault(require("./refresh-grant"));
+// Acquires an MCP OAuth access token for a (user, server): serves a cached token until it nears
+// expiry, otherwise runs the refresh-token grant under a per-key mutex (one in-flight refresh per
+// user+server in this process) and recovers from a concurrent refresh-token rotation via a single
+// re-read + retry. A missing credential or a genuinely rejected refresh raises
+// OAuthReauthRequiredError so the step pauses for re-authentication.
+class OAuthTokenService {
+    constructor(options) {
+        this.cache = new Map();
+        this.mutex = new keyed_mutex_1.default();
+        // Bumped on evict() so a refresh already in flight for a key can detect a disconnect that landed
+        // mid-refresh and skip repopulating the cache for the now-deleted credential.
+        this.evictionEpoch = new Map();
+        this.store = options.store;
+        this.encryption = options.encryption;
+        this.logger = options.logger;
+        this.expirySkewMs = (options.expirySkewS ?? defaults_1.DEFAULT_OAUTH_EXPIRY_SKEW_S) * 1000;
+        this.refreshAccessToken = options.refreshAccessToken ?? refresh_grant_1.default;
+        this.now = options.now ?? Date.now;
+    }
+    async getAccessToken(userId, mcpServerId, options) {
+        const key = `${userId}:${mcpServerId}`;
+        const forceRefresh = options?.forceRefresh ?? false;
+        if (!forceRefresh) {
+            const cached = this.readCache(key);
+            if (cached)
+                return cached;
+        }
+        return this.mutex.runExclusive(key, async () => {
+            // Re-check inside the lock: a concurrent caller may have just refreshed for this key.
+            if (!forceRefresh) {
+                const cached = this.readCache(key);
+                if (cached)
+                    return cached;
+            }
+            return this.refreshAndCache(userId, mcpServerId, key);
+        });
+    }
+    // Drop the cached access token for a (user, server). Called on credential delete so a disconnect
+    // takes effect immediately, instead of the executor serving the cached token until it expires.
+    evict(userId, mcpServerId) {
+        const key = `${userId}:${mcpServerId}`;
+        this.cache.delete(key);
+        this.evictionEpoch.set(key, (this.evictionEpoch.get(key) ?? 0) + 1);
+    }
+    readCache(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        if (this.now() >= entry.expiresAtMs - this.expirySkewMs) {
+            // Drop expired entries on read so the cache can't grow without bound across many keys.
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.accessToken;
+    }
+    async refreshAndCache(userId, mcpServerId, key) {
+        const epochAtStart = this.evictionEpoch.get(key) ?? 0;
+        const credential = await this.store.get(userId, mcpServerId);
+        if (!credential)
+            throw new errors_1.OAuthReauthRequiredError(mcpServerId);
+        const { result, credential: grantedCredential } = await this.runGrantWithRotationRetry(credential, userId, mcpServerId);
+        const evictedDuringRefresh = (this.evictionEpoch.get(key) ?? 0) !== epochAtStart;
+        // Skip caching if the credential was disconnected mid-refresh (would serve a token for a deleted
+        // credential) or the grant carried no expiry (never servable); the in-flight caller still gets it.
+        if (!evictedDuringRefresh && result.expiresInS !== undefined) {
+            this.cache.set(key, {
+                accessToken: result.accessToken,
+                expiresAtMs: this.now() + result.expiresInS * 1000,
+            });
+        }
+        else {
+            this.cache.delete(key);
+        }
+        if (result.refreshToken) {
+            await this.persistRotatedRefreshToken(grantedCredential, result.refreshToken);
+        }
+        return result.accessToken;
+    }
+    // On invalid_grant a peer instance likely rotated the refresh token out from under us: re-read the
+    // row and retry once with the current token; a second invalid_grant (or an unchanged token) is a
+    // genuine revocation and forces re-auth. Returns the credential whose token produced the grant so
+    // the caller writes the rotated token back onto that (current) row, not the stale one.
+    async runGrantWithRotationRetry(credential, userId, mcpServerId) {
+        try {
+            const result = await this.refreshAccessToken(this.toGrantParams(credential));
+            return { result, credential };
+        }
+        catch (error) {
+            if (!(error instanceof errors_1.OAuthInvalidGrantError))
+                throw error;
+            // A peer rotated the refresh token iff the stored value changed since we read it.
+            const latest = await this.store.get(userId, mcpServerId);
+            const wasRotated = latest !== null &&
+                latest.refreshTokenEnc.toString('base64') !== credential.refreshTokenEnc.toString('base64');
+            if (!latest || !wasRotated) {
+                throw new errors_1.OAuthReauthRequiredError(mcpServerId);
+            }
+            try {
+                const result = await this.refreshAccessToken(this.toGrantParams(latest));
+                return { result, credential: latest };
+            }
+            catch (retryError) {
+                if (retryError instanceof errors_1.OAuthInvalidGrantError) {
+                    throw new errors_1.OAuthReauthRequiredError(mcpServerId);
+                }
+                throw retryError;
+            }
+        }
+    }
+    // Decrypt happens here. A decrypt failure with the key PRESENT (auth-tag mismatch — the row was
+    // encrypted under a since-rotated/hard-swapped key, or is corrupt) is recoverable: re-consent
+    // re-deposits under the current key, so surface it as needs-oauth-reauth. A missing key
+    // (ExecutorEncryptionKeyMissingError) is an operator misconfig, not re-consent-resolvable, so it
+    // propagates as a terminal error (a re-deposit would just 503 at the deposit endpoint).
+    toGrantParams(credential) {
+        try {
+            return {
+                tokenEndpoint: credential.tokenEndpoint,
+                refreshToken: this.encryption.decrypt(credential.refreshTokenEnc),
+                clientId: credential.clientId,
+                clientSecret: credential.clientSecretEnc
+                    ? this.encryption.decrypt(credential.clientSecretEnc)
+                    : null,
+                tokenEndpointAuthMethod: credential.tokenEndpointAuthMethod,
+                scopes: credential.scopes,
+            };
+        }
+        catch (error) {
+            if (error instanceof errors_1.ExecutorEncryptionKeyMissingError)
+                throw error;
+            throw new errors_1.OAuthReauthRequiredError(credential.mcpServerId);
+        }
+    }
+    async persistRotatedRefreshToken(credential, refreshToken) {
+        try {
+            const encrypted = this.encryption.encrypt(refreshToken);
+            // Id-scoped so a disconnect (or disconnect + re-authorize) after the grant read leaves an
+            // absent or different row — the rotated-token write-back then can't resurrect or clobber it.
+            await this.store.updateIfPresent(credential.id, {
+                userId: credential.userId,
+                mcpServerId: credential.mcpServerId,
+                refreshTokenEnc: encrypted.ciphertext,
+                clientId: credential.clientId,
+                clientSecretEnc: credential.clientSecretEnc,
+                clientSecretExpiresAt: credential.clientSecretExpiresAt,
+                tokenEndpoint: credential.tokenEndpoint,
+                tokenEndpointAuthMethod: credential.tokenEndpointAuthMethod,
+                scopes: credential.scopes,
+            });
+        }
+        catch (error) {
+            // A failed write-back is not fatal: the access token just obtained is valid for this call.
+            // The rotated refresh token is lost, so a later refresh forces re-authentication — the safe
+            // fallback, and better than failing the current operation over a transient write error.
+            this.logger?.('Error', 'Failed to persist rotated MCP OAuth refresh token', {
+                mcpServerId: credential.mcpServerId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}
+exports.default = OAuthTokenService;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ports/agent-port.d.ts

@@ -36,6 +36,7 @@ export type ExecuteActionQuery = {
     action: string;
     id?: Id[];
     values?: Record<string, unknown>;
+    approvalMessage?: string;
 };
 export type GetActionFormQuery = {
     collection: string;

package/dist/ports/ai-model-port.d.ts

@@ -1,4 +1,4 @@
-import type { BaseChatModel, RemoteTool, ToolConfig } from '@forestadmin/ai-proxy';
+import type { BaseChatModel, McpServerLoadFailure, RemoteTool, ToolConfig } from '@forestadmin/ai-proxy';
 export interface GetModelOptions {
     aiConfigName?: string;
     userId?: number;
@@ -6,6 +6,10 @@ export interface GetModelOptions {
 export interface AiModelPort {
     getModel(options?: GetModelOptions): BaseChatModel;
     loadRemoteTools(configs: Record<string, ToolConfig>): Promise<RemoteTool[]>;
+    loadRemoteToolsWithFailures(configs: Record<string, ToolConfig>): Promise<{
+        tools: RemoteTool[];
+        failures: McpServerLoadFailure[];
+    }>;
     closeConnections(): Promise<void>;
 }
 //# sourceMappingURL=ai-model-port.d.ts.map

package/dist/ports/mcp-oauth-credentials-store.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from './logger-port';
+export interface McpOAuthCredentialInput {
+    userId: number;
+    mcpServerId: string;
+    refreshTokenEnc: Buffer;
+    clientId?: string | null;
+    clientSecretEnc?: Buffer | null;
+    clientSecretExpiresAt?: Date | null;
+    tokenEndpoint: string;
+    tokenEndpointAuthMethod?: string | null;
+    scopes?: string | null;
+}
+export interface StoredMcpOAuthCredential extends McpOAuthCredentialInput {
+    id: number;
+}
+export interface McpOAuthCredentialsStore {
+    init(logger?: Logger): Promise<void>;
+    close(logger?: Logger): Promise<void>;
+    get(userId: number, mcpServerId: string): Promise<StoredMcpOAuthCredential | null>;
+    upsert(credential: McpOAuthCredentialInput): Promise<void>;
+    updateIfPresent(id: number, credential: McpOAuthCredentialInput): Promise<void>;
+    delete(userId: number, mcpServerId: string): Promise<void>;
+}
+//# sourceMappingURL=mcp-oauth-credentials-store.d.ts.map

package/dist/ports/mcp-oauth-credentials-store.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWNwLW9hdXRoLWNyZWRlbnRpYWxzLXN0b3JlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3BvcnRzL21jcC1vYXV0aC1jcmVkZW50aWFscy1zdG9yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/ports/run-store.d.ts

@@ -5,5 +5,6 @@ export interface RunStore {
     close(logger?: Logger): Promise<void>;
     getStepExecutions(runId: string): Promise<StepExecutionData[]>;
     saveStepExecution(runId: string, stepExecution: StepExecutionData): Promise<void>;
+    deleteStepExecution(runId: string, stepIndex: number): Promise<void>;
 }
 //# sourceMappingURL=run-store.d.ts.map

package/dist/remote-tool-fetcher.d.ts

@@ -1,3 +1,4 @@
+import type OAuthTokenService from './oauth/token-service';
 import type { AiModelPort } from './ports/ai-model-port';
 import type { Logger } from './ports/logger-port';
 import type { WorkflowPort } from './ports/workflow-port';
@@ -6,13 +7,17 @@ export declare function scopeConfigsToServer(configs: Record<string, ToolConfig>
 export interface FetchRemoteToolsResult {
     tools: RemoteTool[];
     mcpServerName?: string;
+    loadFailed?: boolean;
+    reloadWithFreshAuth?: () => Promise<RemoteTool[]>;
 }
 export default class RemoteToolFetcher {
     private readonly workflowPort;
     private readonly aiModelPort;
     private readonly logger;
-    constructor(workflowPort: WorkflowPort, aiModelPort: AiModelPort, logger: Logger);
-    fetch(mcpServerId: string): Promise<FetchRemoteToolsResult>;
+    private readonly oauthTokenService;
+    constructor(workflowPort: WorkflowPort, aiModelPort: AiModelPort, logger: Logger, oauthTokenService: OAuthTokenService);
+    fetch(mcpServerId: string, userId: number): Promise<FetchRemoteToolsResult>;
+    private fetchOAuthTools;
     private warnMissingTargetServer;
     private errorOnPartialLoadFailure;
 }

package/dist/remote-tool-fetcher.js

@@ -1,26 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scopeConfigsToServer = scopeConfigsToServer;
+const ai_proxy_1 = require("@forestadmin/ai-proxy");
+const errors_1 = require("./errors");
+const OAUTH2_AUTH_TYPE = 'oauth2';
 // Match by config.id, not by Record key: server names can collide across configs.
 function scopeConfigsToServer(configs, mcpServerId) {
     return Object.fromEntries(Object.entries(configs).filter(([, cfg]) => cfg.id === mcpServerId));
 }
+function readAuthType(config) {
+    return config?.authType;
+}
 class RemoteToolFetcher {
-    constructor(workflowPort, aiModelPort, logger) {
+    constructor(workflowPort, aiModelPort, logger, oauthTokenService) {
+        // Fail loudly here instead of a cryptic undefined dereference at the first OAuth fetch —
+        // Runner/RunnerConfig are public API, so a JS caller can bypass the compile-time check.
+        if (!oauthTokenService) {
+            throw new Error('RemoteToolFetcher requires an OAuth token service (mcpOAuthTokenService)');
+        }
         this.workflowPort = workflowPort;
         this.aiModelPort = aiModelPort;
         this.logger = logger;
+        this.oauthTokenService = oauthTokenService;
     }
-    async fetch(mcpServerId) {
+    async fetch(mcpServerId, userId) {
         const configs = await this.workflowPort.getMcpServerConfigs();
         const scoped = scopeConfigsToServer(configs, mcpServerId);
         const [mcpServerName] = Object.keys(scoped);
         this.warnMissingTargetServer(configs, scoped, mcpServerId, mcpServerName);
         if (Object.keys(scoped).length === 0)
             return { tools: [], mcpServerName };
+        if (readAuthType(scoped[mcpServerName]) === OAUTH2_AUTH_TYPE) {
+            return this.fetchOAuthTools(scoped, mcpServerName, mcpServerId, userId);
+        }
         const tools = await this.aiModelPort.loadRemoteTools(scoped);
-        this.errorOnPartialLoadFailure(scoped, tools, mcpServerId, mcpServerName);
-        return { tools, mcpServerName };
+        const loadFailed = this.errorOnPartialLoadFailure(scoped, tools, mcpServerId, mcpServerName);
+        return { tools, mcpServerName, loadFailed };
+    }
+    // OAuth2 path: acquire a per-user access token, inject it as a Bearer header, then list tools.
+    // Tool listing is the first authenticated call, so an auth failure here forces one token refresh
+    // and a single retry; a still-failing load is a genuine re-auth case.
+    async fetchOAuthTools(scoped, mcpServerName, mcpServerId, userId) {
+        const tokenService = this.oauthTokenService;
+        const attemptLoad = async (forceRefresh) => {
+            const token = await tokenService.getAccessToken(userId, mcpServerId, { forceRefresh });
+            const bearer = `Bearer ${token}`;
+            // All scoped configs share this mcpServerId, so inject the token for every one — not just the
+            // first key — or extra same-id servers load unauthenticated and report spurious auth failures.
+            const injected = (0, ai_proxy_1.injectOauthTokens)({
+                configs: scoped,
+                tokensByMcpServerName: Object.fromEntries(Object.keys(scoped).map(name => [name, bearer])),
+            }) ?? scoped;
+            const { tools, failures } = await this.aiModelPort.loadRemoteToolsWithFailures(injected);
+            return { tools, hasAuthFailure: failures.some(failure => failure.kind === 'auth') };
+        };
+        const reloadWithFreshAuth = async () => {
+            const attempt = await attemptLoad(true);
+            if (attempt.hasAuthFailure)
+                throw new errors_1.OAuthReauthRequiredError(mcpServerId);
+            this.errorOnPartialLoadFailure(scoped, attempt.tools, mcpServerId, mcpServerName);
+            return attempt.tools;
+        };
+        const initial = await attemptLoad(false);
+        if (initial.hasAuthFailure) {
+            return { tools: await reloadWithFreshAuth(), mcpServerName, reloadWithFreshAuth };
+        }
+        const loadFailed = this.errorOnPartialLoadFailure(scoped, initial.tools, mcpServerId, mcpServerName);
+        return { tools: initial.tools, mcpServerName, reloadWithFreshAuth, loadFailed };
     }
     // Distinguish "no configs at all" (deployment misconfig) from "configs exist but none match"
     // (orchestrator/executor drift on server id) — both yield zero tools, but ops need to know
@@ -44,13 +90,14 @@ class RemoteToolFetcher {
             .filter(([, cfg]) => !loadedMcpServerIds.has(cfg.id))
             .map(([name]) => name);
         if (failedConfigNames.length === 0)
-            return;
+            return false;
         this.logger('Error', 'MCP servers failed to load tools', {
             requestedMcpServerId: mcpServerId,
             mcpServerName,
             failedConfigNames,
         });
+        return true;
     }
 }
 exports.default = RemoteToolFetcher;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runner.d.ts

@@ -1,3 +1,4 @@
+import type OAuthTokenService from './oauth/token-service';
 import type { ActivityLogPortFactory } from './ports/activity-log-port';
 import type { AgentPort } from './ports/agent-port';
 import type { AiModelPort } from './ports/ai-model-port';
@@ -22,6 +23,7 @@ export interface RunnerConfig {
     stepTimeoutS?: number;
     aiInvokeTimeoutS?: number;
     maxChainDepth?: number;
+    mcpOAuthTokenService: OAuthTokenService;
 }
 export default class Runner {
     private readonly config;

package/dist/runner.js

@@ -20,7 +20,7 @@ class Runner {
         this._state = 'idle';
         this.config = config;
         this.logger = config.logger ?? (0, console_logger_1.default)();
-        this.remoteToolFetcher = new remote_tool_fetcher_1.default(config.workflowPort, config.aiModelPort, this.logger);
+        this.remoteToolFetcher = new remote_tool_fetcher_1.default(config.workflowPort, config.aiModelPort, this.logger, config.mcpOAuthTokenService);
     }
     get state() {
         return this._state;
@@ -216,7 +216,7 @@ class Runner {
         while (true) {
             let result;
             try {
-                const executor = await step_executor_factory_1.default.create(currentStep, this.contextConfig, this.config.activityLogPortFactory.forRun(currentToken), mcpServerId => this.remoteToolFetcher.fetch(mcpServerId), currentIncomingData, currentToken);
+                const executor = await step_executor_factory_1.default.create(currentStep, this.contextConfig, this.config.activityLogPortFactory.forRun(currentToken), (mcpServerId, userId) => this.remoteToolFetcher.fetch(mcpServerId, userId), currentIncomingData, currentToken);
                 result = await executor.execute();
             }
             catch (error) {
@@ -333,4 +333,4 @@ class Runner {
     }
 }
 exports.default = Runner;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runner.js","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runner.js","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"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"}