@everworker/oneringai 0.4.1 → 0.4.3

package/dist/index.cjs

@@ -17,7 +17,7 @@ var z = require('zod/v4');
 var spawn = require('cross-spawn');
 var process2 = require('process');
 var stream = require('stream');
-var fs18 = require('fs/promises');
+var fs17 = require('fs/promises');
 var simpleIcons = require('simple-icons');
 var child_process = require('child_process');
 var util = require('util');
@@ -55,7 +55,7 @@ var z4mini__namespace = /*#__PURE__*/_interopNamespace(z4mini);
 var z__namespace = /*#__PURE__*/_interopNamespace(z);
 var spawn__default = /*#__PURE__*/_interopDefault(spawn);
 var process2__default = /*#__PURE__*/_interopDefault(process2);
-var fs18__namespace = /*#__PURE__*/_interopNamespace(fs18);
+var fs17__namespace = /*#__PURE__*/_interopNamespace(fs17);
 var simpleIcons__namespace = /*#__PURE__*/_interopNamespace(simpleIcons);
 var vm__namespace = /*#__PURE__*/_interopNamespace(vm);
 
@@ -195,6 +195,12 @@ var init_MemoryStorage = __esm({
       size() {
         return this.tokens.size;
       }
+      /**
+       * List all storage keys (for account enumeration)
+       */
+      async listKeys() {
+        return Array.from(this.tokens.keys());
+      }
     };
   }
 });
@@ -212,14 +218,23 @@ var init_TokenStore = __esm({
         this.storage = storage || new exports.MemoryStorage();
       }
       /**
-       * Get user-scoped storage key
-       * For multi-user support, keys are scoped per user: "provider:userId"
-       * For single-user (backward compatible), userId is omitted or "default"
+       * Get user-scoped (and optionally account-scoped) storage key
+       *
+       * Key format (backward compatible):
+       * - No userId, no accountId  → baseKey
+       * - userId only              → baseKey:userId
+       * - userId + accountId       → baseKey:userId:accountId
+       * - accountId only           → baseKey:default:accountId
        *
        * @param userId - User identifier (optional, defaults to single-user mode)
-       * @returns Storage key scoped to user
+       * @param accountId - Account alias for multi-account support (optional)
+       * @returns Storage key scoped to user and account
        */
-      getScopedKey(userId) {
+      getScopedKey(userId, accountId) {
+        if (accountId) {
+          const userPart = userId && userId !== "default" ? userId : "default";
+          return `${this.baseStorageKey}:${userPart}:${accountId}`;
+        }
         if (!userId || userId === "default") {
           return this.baseStorageKey;
         }
@@ -229,8 +244,9 @@ var init_TokenStore = __esm({
        * Store token (encrypted by storage layer)
        * @param tokenResponse - Token response from OAuth provider
        * @param userId - Optional user identifier for multi-user support
+       * @param accountId - Optional account alias for multi-account support
        */
-      async storeToken(tokenResponse, userId) {
+      async storeToken(tokenResponse, userId, accountId) {
         if (!tokenResponse.access_token) {
           throw new Error("OAuth response missing required access_token field");
         }
@@ -248,39 +264,46 @@ var init_TokenStore = __esm({
           scope: tokenResponse.scope,
           obtained_at: Date.now()
         };
-        const key = this.getScopedKey(userId);
+        const key = this.getScopedKey(userId, accountId);
         await this.storage.storeToken(key, token);
       }
       /**
        * Get access token
        * @param userId - Optional user identifier for multi-user support
+       * @param accountId - Optional account alias for multi-account support
        */
-      async getAccessToken(userId) {
-        const key = this.getScopedKey(userId);
+      async getAccessToken(userId, accountId) {
+        const key = this.getScopedKey(userId, accountId);
         const token = await this.storage.getToken(key);
         if (!token) {
-          throw new Error(`No token stored for ${userId ? `user: ${userId}` : "default user"}`);
+          const userLabel = userId ? `user: ${userId}` : "default user";
+          const accountLabel = accountId ? `, account: ${accountId}` : "";
+          throw new Error(`No token stored for ${userLabel}${accountLabel}`);
         }
         return token.access_token;
       }
       /**
        * Get refresh token
        * @param userId - Optional user identifier for multi-user support
+       * @param accountId - Optional account alias for multi-account support
        */
-      async getRefreshToken(userId) {
-        const key = this.getScopedKey(userId);
+      async getRefreshToken(userId, accountId) {
+        const key = this.getScopedKey(userId, accountId);
         const token = await this.storage.getToken(key);
         if (!token?.refresh_token) {
-          throw new Error(`No refresh token available for ${userId ? `user: ${userId}` : "default user"}`);
+          const userLabel = userId ? `user: ${userId}` : "default user";
+          const accountLabel = accountId ? `, account: ${accountId}` : "";
+          throw new Error(`No refresh token available for ${userLabel}${accountLabel}`);
         }
         return token.refresh_token;
       }
       /**
        * Check if has refresh token
        * @param userId - Optional user identifier for multi-user support
+       * @param accountId - Optional account alias for multi-account support
        */
-      async hasRefreshToken(userId) {
-        const key = this.getScopedKey(userId);
+      async hasRefreshToken(userId, accountId) {
+        const key = this.getScopedKey(userId, accountId);
         const token = await this.storage.getToken(key);
         return !!token?.refresh_token;
       }
@@ -289,9 +312,10 @@ var init_TokenStore = __esm({
        *
        * @param bufferSeconds - Refresh this many seconds before expiry (default: 300 = 5 min)
        * @param userId - Optional user identifier for multi-user support
+       * @param accountId - Optional account alias for multi-account support
        */
-      async isValid(bufferSeconds = 300, userId) {
-        const key = this.getScopedKey(userId);
+      async isValid(bufferSeconds = 300, userId, accountId) {
+        const key = this.getScopedKey(userId, accountId);
         const token = await this.storage.getToken(key);
         if (!token) {
           return false;
@@ -303,19 +327,46 @@ var init_TokenStore = __esm({
       /**
        * Clear stored token
        * @param userId - Optional user identifier for multi-user support
+       * @param accountId - Optional account alias for multi-account support
        */
-      async clear(userId) {
-        const key = this.getScopedKey(userId);
+      async clear(userId, accountId) {
+        const key = this.getScopedKey(userId, accountId);
         await this.storage.deleteToken(key);
       }
       /**
        * Get full token info
        * @param userId - Optional user identifier for multi-user support
+       * @param accountId - Optional account alias for multi-account support
        */
-      async getTokenInfo(userId) {
-        const key = this.getScopedKey(userId);
+      async getTokenInfo(userId, accountId) {
+        const key = this.getScopedKey(userId, accountId);
         return this.storage.getToken(key);
       }
+      /**
+       * List account aliases for a user on this connector.
+       * Returns account IDs that have stored tokens.
+       *
+       * @param userId - Optional user identifier
+       * @returns Array of account aliases (e.g., ['work', 'personal'])
+       */
+      async listAccounts(userId) {
+        if (!this.storage.listKeys) {
+          return [];
+        }
+        const allKeys = await this.storage.listKeys();
+        const userPart = userId && userId !== "default" ? userId : "default";
+        const prefix = `${this.baseStorageKey}:${userPart}:`;
+        const accounts = [];
+        for (const key of allKeys) {
+          if (key.startsWith(prefix)) {
+            const accountId = key.slice(prefix.length);
+            if (accountId && !accountId.includes(":")) {
+              accounts.push(accountId);
+            }
+          }
+        }
+        return accounts;
+      }
     };
   }
 });
@@ -356,20 +407,28 @@ var init_AuthCodePKCE = __esm({
         this.tokenStore = new TokenStore(storageKey, config.storage);
       }
       tokenStore;
-      // Store PKCE data per user with timestamps for cleanup
+      // Store PKCE data per user+account with timestamps for cleanup
       codeVerifiers = /* @__PURE__ */ new Map();
       states = /* @__PURE__ */ new Map();
-      // Store refresh locks per user to prevent concurrent refresh
+      // Store refresh locks per user+account to prevent concurrent refresh
       refreshLocks = /* @__PURE__ */ new Map();
       // PKCE data TTL: 15 minutes (auth flows should complete within this time)
       PKCE_TTL = 15 * 60 * 1e3;
+      /**
+       * Build a map key from userId and accountId for internal PKCE/state/lock maps.
+       */
+      getMapKey(userId, accountId) {
+        const userPart = userId || "default";
+        return accountId ? `${userPart}:${accountId}` : userPart;
+      }
       /**
        * Generate authorization URL for user to visit
        * Opens browser or redirects user to this URL
        *
        * @param userId - User identifier for multi-user support (optional)
+       * @param accountId - Account alias for multi-account support (optional)
        */
-      async getAuthorizationUrl(userId) {
+      async getAuthorizationUrl(userId, accountId) {
         if (!this.config.authorizationUrl) {
           throw new Error("authorizationUrl is required for authorization_code flow");
         }
@@ -377,11 +436,11 @@ var init_AuthCodePKCE = __esm({
           throw new Error("redirectUri is required for authorization_code flow");
         }
         this.cleanupExpiredPKCE();
-        const userKey = userId || "default";
+        const mapKey = this.getMapKey(userId, accountId);
         const { codeVerifier, codeChallenge } = generatePKCE();
-        this.codeVerifiers.set(userKey, { verifier: codeVerifier, timestamp: Date.now() });
+        this.codeVerifiers.set(mapKey, { verifier: codeVerifier, timestamp: Date.now() });
         const state = generateState();
-        this.states.set(userKey, { state, timestamp: Date.now() });
+        this.states.set(mapKey, { state, timestamp: Date.now() });
         const params = new URLSearchParams({
           response_type: "code",
           client_id: this.config.clientId,
@@ -395,33 +454,48 @@ var init_AuthCodePKCE = __esm({
           params.append("code_challenge", codeChallenge);
           params.append("code_challenge_method", "S256");
         }
-        const stateWithUser = userId ? `${state}::${userId}` : state;
-        params.set("state", stateWithUser);
+        let stateWithMetadata = state;
+        if (userId || accountId) {
+          stateWithMetadata = `${state}::${userId || ""}`;
+          if (accountId) {
+            stateWithMetadata += `::${accountId}`;
+          }
+        }
+        params.set("state", stateWithMetadata);
         return `${this.config.authorizationUrl}?${params.toString()}`;
       }
       /**
        * Exchange authorization code for access token
        *
        * @param code - Authorization code from callback
-       * @param state - State parameter from callback (for CSRF verification, may include userId)
+       * @param state - State parameter from callback (for CSRF verification, may include userId/accountId)
        * @param userId - User identifier (optional, can be extracted from state)
+       * @param accountId - Account alias (optional, can be extracted from state)
        */
-      async exchangeCode(code, state, userId) {
+      async exchangeCode(code, state, userId, accountId) {
         let actualState = state;
         let actualUserId = userId;
+        let actualAccountId = accountId;
         if (state.includes("::")) {
           const parts = state.split("::");
           actualState = parts[0];
-          actualUserId = parts[1];
+          if (!actualUserId && parts[1]) {
+            actualUserId = parts[1];
+          }
+          if (!actualAccountId && parts[2]) {
+            actualAccountId = parts[2];
+          }
         }
-        const userKey = actualUserId || "default";
-        const stateData = this.states.get(userKey);
+        const mapKey = this.getMapKey(actualUserId, actualAccountId);
+        const stateData = this.states.get(mapKey);
         if (!stateData) {
-          throw new Error(`No PKCE state found for user ${actualUserId}. Authorization flow may have expired (15 min TTL).`);
+          const label = actualAccountId ? `user ${actualUserId}, account ${actualAccountId}` : `user ${actualUserId}`;
+          throw new Error(`No PKCE state found for ${label}. Authorization flow may have expired (15 min TTL).`);
         }
         const expectedState = stateData.state;
         if (actualState !== expectedState) {
-          throw new Error(`State mismatch for user ${actualUserId} - possible CSRF attack. Expected: ${expectedState}, Got: ${actualState}`);
+          const label = actualAccountId ? `user ${actualUserId}, account ${actualAccountId}` : `user ${actualUserId}`;
+          throw new Error(`State mismatch for ${label} - possible CSRF attack. Expected: ${expectedState}, Got: ${actualState}`);
         }
         if (!this.config.redirectUri) {
           throw new Error("redirectUri is required");
@@ -435,7 +509,7 @@ var init_AuthCodePKCE = __esm({
         if (this.config.clientSecret) {
           params.append("client_secret", this.config.clientSecret);
         }
-        const verifierData = this.codeVerifiers.get(userKey);
+        const verifierData = this.codeVerifiers.get(mapKey);
         if (this.config.usePKCE !== false && verifierData) {
           params.append("code_verifier", verifierData.verifier);
         }
@@ -469,39 +543,43 @@ var init_AuthCodePKCE = __esm({
           throw new Error(`Token exchange failed: ${response.status} ${response.statusText} - ${error}`);
         }
         const data = await response.json();
-        await this.tokenStore.storeToken(data, actualUserId);
-        this.codeVerifiers.delete(userKey);
-        this.states.delete(userKey);
+        await this.tokenStore.storeToken(data, actualUserId, actualAccountId);
+        this.codeVerifiers.delete(mapKey);
+        this.states.delete(mapKey);
       }
       /**
        * Get valid token (auto-refreshes if needed)
        * @param userId - User identifier for multi-user support
+       * @param accountId - Account alias for multi-account support
        */
-      async getToken(userId) {
-        const key = userId || "default";
-        if (this.refreshLocks.has(key)) {
-          return this.refreshLocks.get(key);
+      async getToken(userId, accountId) {
+        const mapKey = this.getMapKey(userId, accountId);
+        if (this.refreshLocks.has(mapKey)) {
+          return this.refreshLocks.get(mapKey);
         }
-        if (await this.tokenStore.isValid(this.config.refreshBeforeExpiry, userId)) {
-          return this.tokenStore.getAccessToken(userId);
+        if (await this.tokenStore.isValid(this.config.refreshBeforeExpiry, userId, accountId)) {
+          return this.tokenStore.getAccessToken(userId, accountId);
         }
-        if (await this.tokenStore.hasRefreshToken(userId)) {
-          const refreshPromise = this.refreshToken(userId);
-          this.refreshLocks.set(key, refreshPromise);
+        if (await this.tokenStore.hasRefreshToken(userId, accountId)) {
+          const refreshPromise = this.refreshToken(userId, accountId);
+          this.refreshLocks.set(mapKey, refreshPromise);
           try {
             return await refreshPromise;
           } finally {
-            this.refreshLocks.delete(key);
+            this.refreshLocks.delete(mapKey);
           }
         }
-        throw new Error(`No valid token available for ${userId ? `user: ${userId}` : "default user"}. User needs to authorize (call startAuthFlow).`);
+        const userLabel = userId ? `user: ${userId}` : "default user";
+        const accountLabel = accountId ? `, account: ${accountId}` : "";
+        throw new Error(`No valid token available for ${userLabel}${accountLabel}. User needs to authorize (call startAuthFlow).`);
       }
       /**
        * Refresh access token using refresh token
        * @param userId - User identifier for multi-user support
+       * @param accountId - Account alias for multi-account support
        */
-      async refreshToken(userId) {
-        const refreshToken = await this.tokenStore.getRefreshToken(userId);
+      async refreshToken(userId, accountId) {
+        const refreshToken = await this.tokenStore.getRefreshToken(userId, accountId);
         const params = new URLSearchParams({
           grant_type: "refresh_token",
           refresh_token: refreshToken,
@@ -540,28 +618,30 @@ var init_AuthCodePKCE = __esm({
           throw new Error(`Token refresh failed: ${response.status} ${response.statusText} - ${error}`);
         }
         const data = await response.json();
-        await this.tokenStore.storeToken(data, userId);
+        await this.tokenStore.storeToken(data, userId, accountId);
         return data.access_token;
       }
       /**
        * Check if token is valid
        * @param userId - User identifier for multi-user support
+       * @param accountId - Account alias for multi-account support
        */
-      async isTokenValid(userId) {
-        return this.tokenStore.isValid(this.config.refreshBeforeExpiry, userId);
+      async isTokenValid(userId, accountId) {
+        return this.tokenStore.isValid(this.config.refreshBeforeExpiry, userId, accountId);
       }
       /**
        * Revoke token (if supported by provider)
        * @param revocationUrl - Optional revocation endpoint
        * @param userId - User identifier for multi-user support
+       * @param accountId - Account alias for multi-account support
        */
-      async revokeToken(revocationUrl, userId) {
+      async revokeToken(revocationUrl, userId, accountId) {
         if (!revocationUrl) {
-          await this.tokenStore.clear(userId);
+          await this.tokenStore.clear(userId, accountId);
           return;
         }
         try {
-          const token = await this.tokenStore.getAccessToken(userId);
+          const token = await this.tokenStore.getAccessToken(userId, accountId);
           await fetch(revocationUrl, {
             method: "POST",
             headers: {
@@ -573,9 +653,16 @@ var init_AuthCodePKCE = __esm({
             })
           });
         } finally {
-          await this.tokenStore.clear(userId);
+          await this.tokenStore.clear(userId, accountId);
         }
       }
+      /**
+       * List account aliases for a user.
+       * @param userId - User identifier (optional)
+       */
+      async listAccounts(userId) {
+        return this.tokenStore.listAccounts(userId);
+      }
       /**
        * Clean up expired PKCE data to prevent memory leaks
        * Removes verifiers and states older than PKCE_TTL (15 minutes)
@@ -607,17 +694,19 @@ var init_ClientCredentials = __esm({
       tokenStore;
       /**
        * Get token using client credentials
+       * @param userId - User identifier for multi-user support (optional, rarely used for client_credentials)
+       * @param accountId - Account alias for multi-account support (optional)
        */
-      async getToken() {
-        if (await this.tokenStore.isValid(this.config.refreshBeforeExpiry)) {
-          return this.tokenStore.getAccessToken();
+      async getToken(userId, accountId) {
+        if (await this.tokenStore.isValid(this.config.refreshBeforeExpiry, userId, accountId)) {
+          return this.tokenStore.getAccessToken(userId, accountId);
         }
-        return this.requestToken();
+        return this.requestToken(userId, accountId);
       }
       /**
        * Request a new token from the authorization server
        */
-      async requestToken() {
+      async requestToken(userId, accountId) {
         const auth2 = Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString(
           "base64"
         );
@@ -640,22 +729,26 @@ var init_ClientCredentials = __esm({
           throw new Error(`Token request failed: ${response.status} ${response.statusText} - ${error}`);
         }
         const data = await response.json();
-        await this.tokenStore.storeToken(data);
+        await this.tokenStore.storeToken(data, userId, accountId);
         return data.access_token;
       }
       /**
        * Refresh token (client credentials don't use refresh tokens)
        * Just requests a new token
+       * @param userId - User identifier for multi-user support (optional)
+       * @param accountId - Account alias for multi-account support (optional)
        */
-      async refreshToken() {
-        await this.tokenStore.clear();
-        return this.requestToken();
+      async refreshToken(userId, accountId) {
+        await this.tokenStore.clear(userId, accountId);
+        return this.requestToken(userId, accountId);
       }
       /**
        * Check if token is valid
+       * @param userId - User identifier for multi-user support (optional)
+       * @param accountId - Account alias for multi-account support (optional)
        */
-      async isTokenValid() {
-        return this.tokenStore.isValid(this.config.refreshBeforeExpiry);
+      async isTokenValid(userId, accountId) {
+        return this.tokenStore.isValid(this.config.refreshBeforeExpiry, userId, accountId);
       }
     };
   }
@@ -697,17 +790,19 @@ var init_JWTBearer = __esm({
       }
       /**
        * Get token using JWT Bearer assertion
+       * @param userId - User identifier for multi-user support (optional)
+       * @param accountId - Account alias for multi-account support (optional)
        */
-      async getToken() {
-        if (await this.tokenStore.isValid(this.config.refreshBeforeExpiry)) {
-          return this.tokenStore.getAccessToken();
+      async getToken(userId, accountId) {
+        if (await this.tokenStore.isValid(this.config.refreshBeforeExpiry, userId, accountId)) {
+          return this.tokenStore.getAccessToken(userId, accountId);
         }
-        return this.requestToken();
+        return this.requestToken(userId, accountId);
       }
       /**
        * Request token using JWT assertion
        */
-      async requestToken() {
+      async requestToken(userId, accountId) {
         const assertion = await this.generateJWT();
         const params = new URLSearchParams({
           grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
@@ -725,21 +820,25 @@ var init_JWTBearer = __esm({
           throw new Error(`JWT Bearer token request failed: ${response.status} ${response.statusText} - ${error}`);
         }
         const data = await response.json();
-        await this.tokenStore.storeToken(data);
+        await this.tokenStore.storeToken(data, userId, accountId);
         return data.access_token;
       }
       /**
        * Refresh token (generate new JWT and request new token)
+       * @param userId - User identifier for multi-user support (optional)
+       * @param accountId - Account alias for multi-account support (optional)
        */
-      async refreshToken() {
-        await this.tokenStore.clear();
-        return this.requestToken();
+      async refreshToken(userId, accountId) {
+        await this.tokenStore.clear(userId, accountId);
+        return this.requestToken(userId, accountId);
       }
       /**
        * Check if token is valid
+       * @param userId - User identifier for multi-user support (optional)
+       * @param accountId - Account alias for multi-account support (optional)
        */
-      async isTokenValid() {
-        return this.tokenStore.isValid(this.config.refreshBeforeExpiry);
+      async isTokenValid(userId, accountId) {
+        return this.tokenStore.isValid(this.config.refreshBeforeExpiry, userId, accountId);
       }
     };
   }
@@ -819,25 +918,28 @@ var init_OAuthManager = __esm({
        * Automatically refreshes if expired
        *
        * @param userId - User identifier for multi-user support (optional)
+       * @param accountId - Account alias for multi-account support (optional)
        */
-      async getToken(userId) {
-        return this.flow.getToken(userId);
+      async getToken(userId, accountId) {
+        return this.flow.getToken(userId, accountId);
       }
       /**
        * Force refresh the token
        *
        * @param userId - User identifier for multi-user support (optional)
+       * @param accountId - Account alias for multi-account support (optional)
        */
-      async refreshToken(userId) {
-        return this.flow.refreshToken(userId);
+      async refreshToken(userId, accountId) {
+        return this.flow.refreshToken(userId, accountId);
       }
       /**
        * Check if current token is valid
        *
        * @param userId - User identifier for multi-user support (optional)
+       * @param accountId - Account alias for multi-account support (optional)
        */
-      async isTokenValid(userId) {
-        return this.flow.isTokenValid(userId);
+      async isTokenValid(userId, accountId) {
+        return this.flow.isTokenValid(userId, accountId);
       }
       // ==================== Authorization Code Flow Methods ====================
       /**
@@ -845,13 +947,14 @@ var init_OAuthManager = __esm({
        * Returns URL for user to visit
        *
        * @param userId - User identifier for multi-user support (optional)
+       * @param accountId - Account alias for multi-account support (optional)
        * @returns Authorization URL for the user to visit
        */
-      async startAuthFlow(userId) {
+      async startAuthFlow(userId, accountId) {
         if (!(this.flow instanceof AuthCodePKCEFlow)) {
           throw new Error("startAuthFlow() is only available for authorization_code flow");
         }
-        return this.flow.getAuthorizationUrl(userId);
+        return this.flow.getAuthorizationUrl(userId, accountId);
       }
       /**
        * Handle OAuth callback (Authorization Code only)
@@ -859,8 +962,9 @@ var init_OAuthManager = __esm({
        *
        * @param callbackUrl - Full callback URL with code and state parameters
        * @param userId - Optional user identifier (can be extracted from state if embedded)
+       * @param accountId - Optional account alias (can be extracted from state if embedded)
        */
-      async handleCallback(callbackUrl, userId) {
+      async handleCallback(callbackUrl, userId, accountId) {
         if (!(this.flow instanceof AuthCodePKCEFlow)) {
           throw new Error("handleCallback() is only available for authorization_code flow");
         }
@@ -873,21 +977,34 @@ var init_OAuthManager = __esm({
         if (!state) {
           throw new Error("Missing state parameter in callback URL");
         }
-        await this.flow.exchangeCode(code, state, userId);
+        await this.flow.exchangeCode(code, state, userId, accountId);
       }
       /**
        * Revoke token (if supported by provider)
        *
        * @param revocationUrl - Optional revocation endpoint URL
        * @param userId - User identifier for multi-user support (optional)
+       * @param accountId - Account alias for multi-account support (optional)
        */
-      async revokeToken(revocationUrl, userId) {
+      async revokeToken(revocationUrl, userId, accountId) {
         if (this.flow instanceof AuthCodePKCEFlow) {
-          await this.flow.revokeToken(revocationUrl, userId);
+          await this.flow.revokeToken(revocationUrl, userId, accountId);
         } else {
           throw new Error("Token revocation not implemented for this flow");
         }
       }
+      /**
+       * List account aliases for a user (Authorization Code only)
+       *
+       * @param userId - User identifier (optional)
+       * @returns Array of account aliases (e.g., ['work', 'personal'])
+       */
+      async listAccounts(userId) {
+        if (this.flow instanceof AuthCodePKCEFlow) {
+          return this.flow.listAccounts(userId);
+        }
+        return [];
+      }
       // ==================== Validation ====================
       validateConfig(config) {
         if (!config.flow) {
@@ -2093,46 +2210,59 @@ var init_Connector = __esm({
       /**
        * Get the current access token (for OAuth, JWT, or API key)
        * Handles automatic refresh if needed
+       *
+       * @param userId - Optional user identifier for multi-user support
+       * @param accountId - Optional account alias for multi-account support (e.g., 'work', 'personal')
        */
-      async getToken(userId) {
+      async getToken(userId, accountId) {
         if (this.config.auth.type === "api_key") {
           return this.config.auth.apiKey;
         }
         if (!this.oauthManager) {
           throw new Error(`OAuth manager not initialized for connector '${this.name}'`);
         }
-        return this.oauthManager.getToken(userId);
+        return this.oauthManager.getToken(userId, accountId);
       }
       /**
        * Start OAuth authorization flow
        * Returns the URL to redirect the user to
+       *
+       * @param userId - Optional user identifier for multi-user support
+       * @param accountId - Optional account alias for multi-account support (e.g., 'work', 'personal')
        */
-      async startAuth(userId) {
+      async startAuth(userId, accountId) {
         if (!this.oauthManager) {
           throw new Error(`Connector '${this.name}' is not an OAuth connector`);
         }
-        return this.oauthManager.startAuthFlow(userId);
+        return this.oauthManager.startAuthFlow(userId, accountId);
       }
       /**
        * Handle OAuth callback
        * Call this after user is redirected back from OAuth provider
+       *
+       * @param callbackUrl - Full callback URL with code and state parameters
+       * @param userId - Optional user identifier (can be extracted from state if embedded)
+       * @param accountId - Optional account alias (can be extracted from state if embedded)
        */
-      async handleCallback(callbackUrl, userId) {
+      async handleCallback(callbackUrl, userId, accountId) {
         if (!this.oauthManager) {
           throw new Error(`Connector '${this.name}' is not an OAuth connector`);
         }
-        await this.oauthManager.handleCallback(callbackUrl, userId);
+        await this.oauthManager.handleCallback(callbackUrl, userId, accountId);
       }
       /**
        * Check if the connector has a valid token
+       *
+       * @param userId - Optional user identifier for multi-user support
+       * @param accountId - Optional account alias for multi-account support
        */
-      async hasValidToken(userId) {
+      async hasValidToken(userId, accountId) {
         try {
           if (this.config.auth.type === "api_key") {
             return true;
           }
           if (this.oauthManager) {
-            const token = await this.oauthManager.getToken(userId);
+            const token = await this.oauthManager.getToken(userId, accountId);
             return !!token;
           }
           return false;
@@ -2140,6 +2270,19 @@ var init_Connector = __esm({
           return false;
         }
       }
+      /**
+       * List account aliases for a user on this connector.
+       * Only applicable for OAuth connectors with multi-account support.
+       *
+       * @param userId - Optional user identifier
+       * @returns Array of account aliases (e.g., ['work', 'personal'])
+       */
+      async listAccounts(userId) {
+        if (!this.oauthManager) {
+          return [];
+        }
+        return this.oauthManager.listAccounts(userId);
+      }
       /**
        * Get vendor-specific options from config
        */
@@ -2183,9 +2326,10 @@ var init_Connector = __esm({
        * @param endpoint - API endpoint (relative to baseURL) or full URL
        * @param options - Fetch options with connector-specific settings
        * @param userId - Optional user ID for multi-user OAuth
+       * @param accountId - Optional account alias for multi-account OAuth
        * @returns Fetch Response
        */
-      async fetch(endpoint, options, userId) {
+      async fetch(endpoint, options, userId, accountId) {
         if (this.disposed) {
           throw new Error(`Connector '${this.name}' has been disposed`);
         }
@@ -2204,7 +2348,7 @@ var init_Connector = __esm({
           this.logRequest(url2, options);
         }
         const doFetch = async () => {
-          const token = await this.getToken(userId);
+          const token = await this.getToken(userId, accountId);
           const auth2 = this.config.auth;
           let headerName = "Authorization";
           let headerValue = `Bearer ${token}`;
@@ -2316,10 +2460,11 @@ var init_Connector = __esm({
        * @param endpoint - API endpoint (relative to baseURL) or full URL
        * @param options - Fetch options with connector-specific settings
        * @param userId - Optional user ID for multi-user OAuth
+       * @param accountId - Optional account alias for multi-account OAuth
        * @returns Parsed JSON response
        */
-      async fetchJSON(endpoint, options, userId) {
-        const response = await this.fetch(endpoint, options, userId);
+      async fetchJSON(endpoint, options, userId, accountId) {
+        const response = await this.fetch(endpoint, options, userId, accountId);
         const text = await response.text();
         let data;
         try {
@@ -11268,6 +11413,18 @@ var ToolManager = class extends eventemitter3.EventEmitter {
       this.register(tool, options);
     }
   }
+  /**
+   * Register tools produced by a specific connector.
+   * Sets `source: 'connector:<connectorName>'` (or `'connector:<name>:<accountId>'` for identity-bound tools)
+   * so agent-level filtering can restrict which connector tools are visible to a given agent.
+   */
+  registerConnectorTools(connectorName, tools, options = {}) {
+    const { accountId, ...toolOptions } = options;
+    const source = accountId ? `connector:${connectorName}:${accountId}` : `connector:${connectorName}`;
+    for (const tool of tools) {
+      this.register(tool, { ...toolOptions, source });
+    }
+  }
   /**
    * Unregister a tool by name
    */
@@ -11458,6 +11615,14 @@ var ToolManager = class extends eventemitter3.EventEmitter {
   getEnabled() {
     return this.getSortedByPriority().filter((reg) => reg.enabled).map((reg) => reg.tool);
   }
+  /**
+   * Get all enabled registrations (sorted by priority).
+   * Includes full registration metadata (source, namespace, etc.)
+   * for use in connector-aware filtering.
+   */
+  getEnabledRegistrations() {
+    return this.getSortedByPriority().filter((reg) => reg.enabled);
+  }
   /**
    * Get all tools (enabled and disabled)
    */
@@ -11650,6 +11815,13 @@ var ToolManager = class extends eventemitter3.EventEmitter {
     if (!registration.enabled) {
       throw new ToolExecutionError(toolName, "Tool is disabled");
     }
+    if (registration.source?.startsWith("connector:")) {
+      const connName = registration.source.slice("connector:".length);
+      const registry = this._toolContext?.connectorRegistry;
+      if (registry && !registry.has(connName)) {
+        throw new ToolExecutionError(toolName, `Connector '${connName}' is not available to this agent`);
+      }
+    }
     const breaker = this.getOrCreateCircuitBreaker(toolName, registration);
     this.toolLogger.debug({ toolName, args }, "Tool execution started");
     const startTime = Date.now();
@@ -11943,6 +12115,9 @@ var ToolManager = class extends eventemitter3.EventEmitter {
   }
 };
 
+// src/core/context-nextgen/AgentContextNextGen.ts
+init_Logger();
+
 // src/core/Vendor.ts
 var Vendor = {
   OpenAI: "openai",
@@ -13316,6 +13491,7 @@ var ContentType = /* @__PURE__ */ ((ContentType2) => {
   ContentType2["OUTPUT_TEXT"] = "output_text";
   ContentType2["TOOL_USE"] = "tool_use";
   ContentType2["TOOL_RESULT"] = "tool_result";
+  ContentType2["THINKING"] = "thinking";
   return ContentType2;
 })(ContentType || {});
 
@@ -13578,6 +13754,11 @@ var BasePluginNextGen = class {
   }
 };
 
+// src/core/context-nextgen/snapshot.ts
+function formatPluginDisplayName(name) {
+  return name.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
 // src/core/context-nextgen/AgentContextNextGen.ts
 init_Connector();
 
@@ -16256,8 +16437,11 @@ var AlgorithmicCompactionStrategy = class {
    * Emergency compaction when context exceeds threshold.
    *
    * Strategy:
-   * 1. Run consolidate() first to move tool results to memory
+   * 1. Run consolidate() first to move tool results to memory (if working memory available)
    * 2. If still need space, apply rolling window (remove oldest messages)
+   *
+   * Gracefully degrades: if working memory plugin is not registered,
+   * skips step 1 and only uses rolling window compaction.
    */
   async compact(context, targetToFree) {
     const log = [];
@@ -16270,7 +16454,7 @@ var AlgorithmicCompactionStrategy = class {
       tokensFreed += Math.abs(consolidateResult.tokensChanged);
       log.push(...consolidateResult.actions);
     }
-    let remaining = targetToFree - tokensFreed;
+    const remaining = targetToFree - tokensFreed;
     if (remaining > 0 && context.conversation.length > 0) {
       log.push(`Rolling window: need to free ~${remaining} more tokens`);
       const result = await this.applyRollingWindow(context, remaining, log);
@@ -16284,8 +16468,11 @@ var AlgorithmicCompactionStrategy = class {
    * Post-cycle consolidation.
    *
    * 1. Find all tool pairs in conversation
-   * 2. Move large tool results (> threshold) to Working Memory
+   * 2. Move large tool results (> threshold) to Working Memory (if available)
    * 3. Limit remaining tool pairs to maxToolPairs
+   *
+   * Gracefully degrades: if working memory is not available, skips step 2
+   * and only limits tool pairs + removes excess via rolling window.
    */
   async consolidate(context) {
     const log = [];
@@ -16296,23 +16483,25 @@ var AlgorithmicCompactionStrategy = class {
       return { performed: false, tokensChanged: 0, actions: [] };
     }
     const indicesToRemove = [];
-    for (const pair of toolPairs) {
-      if (pair.resultSizeBytes > this.toolResultSizeThreshold) {
-        const key = this.generateKey(pair.toolName, pair.toolUseId);
-        const desc = this.generateDescription(pair.toolName, pair.toolArgs);
-        await memory.store(key, desc, pair.resultContent, {
-          tier: "raw",
-          priority: "normal"
-        });
-        if (!indicesToRemove.includes(pair.toolUseIndex)) {
-          indicesToRemove.push(pair.toolUseIndex);
-        }
-        if (!indicesToRemove.includes(pair.toolResultIndex)) {
-          indicesToRemove.push(pair.toolResultIndex);
+    if (memory) {
+      for (const pair of toolPairs) {
+        if (pair.resultSizeBytes > this.toolResultSizeThreshold) {
+          const key = this.generateKey(pair.toolName, pair.toolUseId);
+          const desc = this.generateDescription(pair.toolName, pair.toolArgs);
+          await memory.store(key, desc, pair.resultContent, {
+            tier: "raw",
+            priority: "normal"
+          });
+          if (!indicesToRemove.includes(pair.toolUseIndex)) {
+            indicesToRemove.push(pair.toolUseIndex);
+          }
+          if (!indicesToRemove.includes(pair.toolResultIndex)) {
+            indicesToRemove.push(pair.toolResultIndex);
+          }
+          log.push(
+            `Moved ${pair.toolName} result (${this.formatBytes(pair.resultSizeBytes)}) to memory: ${key}`
+          );
         }
-        log.push(
-          `Moved ${pair.toolName} result (${this.formatBytes(pair.resultSizeBytes)}) to memory: ${key}`
-        );
       }
     }
     const remainingPairs = toolPairs.filter(
@@ -16341,15 +16530,12 @@ var AlgorithmicCompactionStrategy = class {
     };
   }
   /**
-   * Get the Working Memory plugin from context.
-   * @throws Error if plugin is not available
+   * Get the Working Memory plugin from context, or null if not available.
+   * When null, the strategy degrades gracefully (skips memory operations).
    */
   getWorkingMemory(context) {
     const plugin = context.plugins.find((p) => p.name === "working_memory");
-    if (!plugin) {
-      throw new Error("AlgorithmicCompactionStrategy requires working_memory plugin");
-    }
-    return plugin;
+    return plugin ? plugin : null;
   }
   /**
    * Find all tool_use/tool_result pairs in conversation.
@@ -16728,12 +16914,14 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
   _agentId;
   /** User ID for multi-user scenarios */
   _userId;
-  /** Allowed connector names (when agent is restricted to a subset) */
-  _allowedConnectors;
+  /** Auth identities this agent is scoped to (connector + optional accountId) */
+  _identities;
   /** Storage backend */
   _storage;
   /** Destroyed flag */
   _destroyed = false;
+  /** Last thinking/reasoning content from the most recent assistant response */
+  _lastThinking = null;
   /** Cached budget from last prepare() call */
   _cachedBudget = null;
   /** Callback for beforeCompaction hook (set by Agent) */
@@ -16767,7 +16955,7 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
     this._systemPrompt = config.systemPrompt;
     this._agentId = this._config.agentId;
     this._userId = config.userId;
-    this._allowedConnectors = config.connectors;
+    this._identities = config.identities;
     const sessionFactory = exports.StorageRegistry.get("sessions");
     const storageCtx = exports.StorageRegistry.getContext() ?? (config.userId ? { userId: config.userId } : void 0);
     this._storage = config.storage ?? (sessionFactory ? sessionFactory(this._agentId, storageCtx) : void 0);
@@ -16821,15 +17009,16 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
   }
   /**
    * Validate that a strategy's required plugins are registered.
-   * @throws Error if any required plugin is missing
+   * Logs a warning if required plugins are missing — the strategy should degrade gracefully.
    */
   validateStrategyDependencies(strategy) {
     if (!strategy.requiredPlugins?.length) return;
     const availablePlugins = new Set(this._plugins.keys());
     const missing = strategy.requiredPlugins.filter((name) => !availablePlugins.has(name));
     if (missing.length > 0) {
-      throw new Error(
-        `Strategy '${strategy.name}' requires plugins that are not registered: ${missing.join(", ")}. Available plugins: ${Array.from(availablePlugins).join(", ") || "none"}`
+      exports.logger.warn(
+        { strategy: strategy.name, missing, available: Array.from(availablePlugins) },
+        `Strategy '${strategy.name}' recommends plugins that are not registered: ${missing.join(", ")}. Strategy will degrade gracefully.`
       );
     }
   }
@@ -16838,7 +17027,7 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
    * Merges with existing ToolContext to preserve other fields (memory, signal, taskId).
    *
    * Connector registry resolution order:
-   * 1. If `connectors` (allowed names) is set → filtered view of global registry
+   * 1. If `identities` is set → filtered view showing only identity connectors
    * 2. If access policy + userId → scoped view via Connector.scoped()
    * 3. Otherwise → full global registry
    */
@@ -16848,6 +17037,7 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
       ...existing,
       agentId: this._agentId,
       userId: this._userId,
+      identities: this._identities,
       connectorRegistry: this.buildConnectorRegistry()
     });
   }
@@ -16855,13 +17045,13 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
    * Build the connector registry appropriate for this agent's config.
    */
   buildConnectorRegistry() {
-    if (this._allowedConnectors?.length) {
-      const allowedSet = new Set(this._allowedConnectors);
+    if (this._identities?.length) {
+      const allowedSet = new Set(this._identities.map((id) => id.connector));
       const base = this._userId && exports.Connector.getAccessPolicy() ? exports.Connector.scoped({ userId: this._userId }) : exports.Connector.asRegistry();
       return {
         get: (name) => {
           if (!allowedSet.has(name)) {
-            const available = this._allowedConnectors.filter((n) => base.has(n)).join(", ") || "none";
+            const available = [...allowedSet].filter((n) => base.has(n)).join(", ") || "none";
             throw new Error(`Connector '${name}' not found. Available: ${available}`);
           }
           return base.get(name);
@@ -16913,13 +17103,13 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
     this._userId = value;
     this.syncToolContext();
   }
-  /** Get the allowed connector names (undefined = all visible connectors) */
-  get connectors() {
-    return this._allowedConnectors;
+  /** Get the auth identities this agent is scoped to (undefined = all visible connectors) */
+  get identities() {
+    return this._identities;
   }
-  /** Set allowed connector names. Updates ToolContext.connectorRegistry. */
-  set connectors(value) {
-    this._allowedConnectors = value;
+  /** Set auth identities. Updates ToolContext.connectorRegistry and identity-aware descriptions. */
+  set identities(value) {
+    this._identities = value;
     this.syncToolContext();
   }
   /** Get/set system prompt */
@@ -16945,6 +17135,13 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
   get storage() {
     return this._storage ?? null;
   }
+  /**
+   * Get the last thinking/reasoning content from the most recent assistant response.
+   * Updated on every assistant response, always available regardless of persistence setting.
+   */
+  get lastThinking() {
+    return this._lastThinking;
+  }
   /** Get max context tokens */
   get maxContextTokens() {
     return this._maxContextTokens;
@@ -17126,6 +17323,7 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
     }
     const id = this.generateId();
     const contentArray = [];
+    let thinkingText = null;
     for (const item of output) {
       if (item.type === "message" && "content" in item) {
         const msg = item;
@@ -17137,12 +17335,19 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
             });
           } else if (c.type === "tool_use" /* TOOL_USE */) {
             contentArray.push(c);
+          } else if (c.type === "thinking" /* THINKING */) {
+            const thinking = c;
+            thinkingText = thinking.thinking;
+            if (thinking.persistInHistory) {
+              contentArray.push(c);
+            }
           }
         }
       } else if (item.type === "compaction" || item.type === "reasoning") {
         continue;
       }
     }
+    this._lastThinking = thinkingText;
     if (contentArray.length > 0) {
       const message = {
         type: "message",
@@ -17241,6 +17446,7 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
    */
   async prepare() {
     this.assertNotDestroyed();
+    this._lastThinking = null;
     const compactionLog = [];
     const toolsTokens = this.calculateToolsTokens();
     const availableForContent = this._maxContextTokens - this._config.responseReserve - toolsTokens;
@@ -17453,6 +17659,8 @@ ${content}`);
             total += this._estimateImageTokens();
           }
         }
+      } else if (c.type === "thinking" /* THINKING */) {
+        total += this._estimator.estimateTokens(c.thinking || "");
       } else if (c.type === "input_image_url" /* INPUT_IMAGE_URL */) {
         const imgContent = c;
         const detail = imgContent.image_url?.detail;
@@ -17950,6 +18158,188 @@ ${content}`);
   get strategy() {
     return this._compactionStrategy.name;
   }
+  /**
+   * Get a complete, serializable snapshot of the context state.
+   *
+   * Returns all data needed by UI "Look Inside" panels without reaching
+   * into plugin internals. Plugin data is auto-discovered from the plugin
+   * registry — new/custom plugins appear automatically.
+   *
+   * @param toolStats - Optional tool usage stats (from ToolManager.getStats())
+   * @returns Serializable context snapshot
+   */
+  async getSnapshot(toolStats) {
+    const resolveContents = async (raw) => {
+      const resolved = raw instanceof Promise ? await raw : raw;
+      if (resolved instanceof Map) return Array.from(resolved.values());
+      return resolved;
+    };
+    if (this._destroyed) {
+      const emptyBudget = this._cachedBudget ?? {
+        maxTokens: this._maxContextTokens,
+        responseReserve: this._config.responseReserve,
+        systemMessageTokens: 0,
+        toolsTokens: 0,
+        conversationTokens: 0,
+        currentInputTokens: 0,
+        totalUsed: 0,
+        available: this._maxContextTokens - this._config.responseReserve,
+        utilizationPercent: 0,
+        breakdown: {
+          systemPrompt: 0,
+          persistentInstructions: 0,
+          pluginInstructions: 0,
+          pluginContents: {},
+          tools: 0,
+          conversation: 0,
+          currentInput: 0
+        }
+      };
+      return {
+        available: false,
+        agentId: this._agentId,
+        model: this._config.model,
+        features: this._config.features,
+        budget: emptyBudget,
+        strategy: this._compactionStrategy.name,
+        messagesCount: 0,
+        toolCallsCount: 0,
+        systemPrompt: null,
+        plugins: [],
+        tools: []
+      };
+    }
+    const budget = await this.calculateBudget();
+    const plugins = [];
+    for (const plugin of this._plugins.values()) {
+      let formattedContent = null;
+      try {
+        formattedContent = await plugin.getContent();
+      } catch {
+      }
+      plugins.push({
+        name: plugin.name,
+        displayName: formatPluginDisplayName(plugin.name),
+        enabled: true,
+        tokenSize: plugin.getTokenSize(),
+        instructionsTokenSize: plugin.getInstructionsTokenSize(),
+        compactable: plugin.isCompactable(),
+        contents: await resolveContents(plugin.getContents()),
+        formattedContent
+      });
+    }
+    const usageCounts = /* @__PURE__ */ new Map();
+    if (toolStats?.mostUsed) {
+      for (const { name, count } of toolStats.mostUsed) {
+        usageCounts.set(name, count);
+      }
+    }
+    const tools = [];
+    for (const toolName of this._tools.list()) {
+      const reg = this._tools.getRegistration(toolName);
+      if (!reg) continue;
+      tools.push({
+        name: toolName,
+        description: reg.tool.definition.function.description || "",
+        enabled: reg.enabled,
+        callCount: reg.metadata.usageCount ?? usageCounts.get(toolName) ?? 0,
+        namespace: reg.namespace || void 0
+      });
+    }
+    let toolCallsCount = 0;
+    for (const item of this._conversation) {
+      if (item.type === "message" && item.role === "assistant" /* ASSISTANT */) {
+        for (const c of item.content) {
+          if (c.type === "tool_use" /* TOOL_USE */) toolCallsCount++;
+        }
+      }
+    }
+    return {
+      available: true,
+      agentId: this._agentId,
+      model: this._config.model,
+      features: this._config.features,
+      budget,
+      strategy: this._compactionStrategy.name,
+      messagesCount: this._conversation.length,
+      toolCallsCount,
+      systemPrompt: this._systemPrompt ?? null,
+      plugins,
+      tools
+    };
+  }
+  /**
+   * Get a human-readable breakdown of the prepared context.
+   *
+   * Calls `prepare()` internally, then maps each InputItem to a named
+   * component with content text and token estimate. Used by "View Full Context" UIs.
+   *
+   * @returns View context data with components and raw text for "Copy All"
+   */
+  async getViewContext() {
+    if (this._destroyed) {
+      return { available: false, components: [], totalTokens: 0, rawContext: "" };
+    }
+    const { input, budget } = await this.prepare();
+    const components = [];
+    let rawParts = [];
+    for (const item of input) {
+      if (item.type === "compaction") {
+        components.push({
+          name: "Compaction Block",
+          content: "[Compacted content]",
+          tokenEstimate: 0
+        });
+        continue;
+      }
+      const msg = item;
+      const roleName = msg.role === "developer" /* DEVELOPER */ ? "System Message" : msg.role === "user" /* USER */ ? "User Message" : "Assistant Message";
+      for (const block of msg.content) {
+        let name = roleName;
+        let text = "";
+        switch (block.type) {
+          case "input_text" /* INPUT_TEXT */:
+            text = block.text;
+            break;
+          case "output_text" /* OUTPUT_TEXT */:
+            text = block.text;
+            break;
+          case "tool_use" /* TOOL_USE */:
+            name = `Tool Call: ${block.name}`;
+            text = `${block.name}(${block.arguments})`;
+            break;
+          case "tool_result" /* TOOL_RESULT */:
+            name = `Tool Result: ${block.tool_use_id}`;
+            text = typeof block.content === "string" ? block.content : JSON.stringify(block.content, null, 2);
+            if (block.error) text = `[Error] ${block.error}
+${text}`;
+            break;
+          case "input_image_url" /* INPUT_IMAGE_URL */:
+            name = "Image Input";
+            text = `[Image: ${block.image_url.url.substring(0, 100)}...]`;
+            break;
+          case "input_file" /* INPUT_FILE */:
+            name = "File Input";
+            text = `[File: ${block.file_id}]`;
+            break;
+          case "thinking" /* THINKING */:
+            name = "Thinking";
+            text = block.thinking || "";
+            break;
+        }
+        const tokenEstimate = this._estimator.estimateTokens(text);
+        components.push({ name, content: text, tokenEstimate });
+        rawParts.push(`--- ${name} ---
+${text}`);
+      }
+    }
+    return {
+      available: true,
+      components,
+      totalTokens: budget.totalUsed,
+      rawContext: rawParts.join("\n\n")
+    };
+  }
   // ============================================================================
   // Utilities
   // ============================================================================
@@ -18208,6 +18598,13 @@ var BaseTextProvider = class extends BaseProvider {
     }
     return textParts.join("\n");
   }
+  /**
+   * List available models from the provider's API.
+   * Default returns empty array; providers override when they have SDK support.
+   */
+  async listModels() {
+    return [];
+  }
   /**
    * Clean up provider resources (circuit breaker listeners, etc.)
    * Should be called when the provider is no longer needed.
@@ -18360,12 +18757,21 @@ var OpenAIResponsesConverter = class {
       } else if (item.type === "reasoning") {
         const reasoning = item;
         if (reasoning.summary) {
-          content.push({
-            type: "reasoning",
-            summary: reasoning.summary,
-            // effort field may not exist in all versions
-            ..."effort" in reasoning && { effort: reasoning.effort }
-          });
+          let summaryText;
+          if (typeof reasoning.summary === "string") {
+            summaryText = reasoning.summary;
+          } else if (Array.isArray(reasoning.summary)) {
+            summaryText = reasoning.summary.map((s) => s.text || "").filter(Boolean).join("\n");
+          } else {
+            summaryText = "";
+          }
+          if (summaryText) {
+            content.push({
+              type: "thinking" /* THINKING */,
+              thinking: summaryText,
+              persistInHistory: false
+            });
+          }
         }
       }
     }
@@ -18388,10 +18794,20 @@ var OpenAIResponsesConverter = class {
         }
       ],
       output_text: outputText,
+      // Extract thinking text from content for convenience field
+      ...(() => {
+        const thinkingTexts = content.filter((c) => c.type === "thinking" /* THINKING */).map((c) => c.thinking).filter(Boolean);
+        return thinkingTexts.length > 0 ? { thinking: thinkingTexts.join("\n") } : {};
+      })(),
       usage: {
         input_tokens: response.usage?.input_tokens || 0,
         output_tokens: response.usage?.output_tokens || 0,
-        total_tokens: response.usage?.total_tokens || 0
+        total_tokens: response.usage?.total_tokens || 0,
+        ...response.usage?.output_tokens_details?.reasoning_tokens != null && {
+          output_tokens_details: {
+            reasoning_tokens: response.usage.output_tokens_details.reasoning_tokens
+          }
+        }
       }
     };
   }
@@ -18496,6 +18912,8 @@ var StreamEventType = /* @__PURE__ */ ((StreamEventType2) => {
   StreamEventType2["TOOL_EXECUTION_START"] = "response.tool_execution.start";
   StreamEventType2["TOOL_EXECUTION_DONE"] = "response.tool_execution.done";
   StreamEventType2["ITERATION_COMPLETE"] = "response.iteration.complete";
+  StreamEventType2["REASONING_DELTA"] = "response.reasoning.delta";
+  StreamEventType2["REASONING_DONE"] = "response.reasoning.done";
   StreamEventType2["RESPONSE_COMPLETE"] = "response.complete";
   StreamEventType2["ERROR"] = "response.error";
   return StreamEventType2;
@@ -18515,6 +18933,12 @@ function isToolCallArgumentsDelta(event) {
 function isToolCallArgumentsDone(event) {
   return event.type === "response.tool_call_arguments.done" /* TOOL_CALL_ARGUMENTS_DONE */;
 }
+function isReasoningDelta(event) {
+  return event.type === "response.reasoning.delta" /* REASONING_DELTA */;
+}
+function isReasoningDone(event) {
+  return event.type === "response.reasoning.done" /* REASONING_DONE */;
+}
 function isResponseComplete(event) {
   return event.type === "response.complete" /* RESPONSE_COMPLETE */;
 }
@@ -18532,6 +18956,8 @@ var OpenAIResponsesStreamConverter = class {
     let sequenceNumber = 0;
     const activeItems = /* @__PURE__ */ new Map();
     const toolCallBuffers = /* @__PURE__ */ new Map();
+    const reasoningBuffers = /* @__PURE__ */ new Map();
+    const reasoningDoneEmitted = /* @__PURE__ */ new Set();
     for await (const event of stream) {
       if (process.env.DEBUG_OPENAI) {
         console.error("[DEBUG] Responses API event:", event.type);
@@ -18553,6 +18979,12 @@ var OpenAIResponsesStreamConverter = class {
           activeItems.set(addedEvent.output_index.toString(), {
             type: item.type
           });
+          if (item.type === "reasoning") {
+            activeItems.set(addedEvent.output_index.toString(), {
+              type: "reasoning"
+            });
+            reasoningBuffers.set(addedEvent.output_index.toString(), []);
+          }
           if (item.type === "function_call") {
             const functionCall = item;
             const toolCallId = functionCall.call_id;
@@ -18610,9 +19042,53 @@ var OpenAIResponsesStreamConverter = class {
           }
           break;
         }
+        case "response.reasoning_summary_text.delta":
+        case "response.reasoning_text.delta": {
+          const reasoningEvent = event;
+          const outputIdx = reasoningEvent.output_index?.toString();
+          const buffer = outputIdx ? reasoningBuffers.get(outputIdx) : void 0;
+          if (buffer) {
+            buffer.push(reasoningEvent.delta || "");
+          }
+          yield {
+            type: "response.reasoning.delta" /* REASONING_DELTA */,
+            response_id: responseId,
+            item_id: reasoningEvent.item_id || `reasoning_${responseId}`,
+            delta: reasoningEvent.delta || "",
+            sequence_number: sequenceNumber++
+          };
+          break;
+        }
+        case "response.reasoning_text.done": {
+          const doneEvent = event;
+          const outputIdx = doneEvent.output_index.toString();
+          const rBuf = reasoningBuffers.get(outputIdx);
+          const thinkingText = rBuf ? rBuf.join("") : doneEvent.text || "";
+          reasoningDoneEmitted.add(outputIdx);
+          yield {
+            type: "response.reasoning.done" /* REASONING_DONE */,
+            response_id: responseId,
+            item_id: doneEvent.item_id || `reasoning_${responseId}`,
+            thinking: thinkingText
+          };
+          break;
+        }
         case "response.output_item.done": {
           const doneEvent = event;
           const item = doneEvent.item;
+          if (item.type === "reasoning") {
+            const outputIdx = doneEvent.output_index.toString();
+            if (!reasoningDoneEmitted.has(outputIdx)) {
+              const rBuf = reasoningBuffers.get(outputIdx);
+              const thinkingText = rBuf ? rBuf.join("") : "";
+              yield {
+                type: "response.reasoning.done" /* REASONING_DONE */,
+                response_id: responseId,
+                item_id: item.id || `reasoning_${responseId}`,
+                thinking: thinkingText
+              };
+            }
+          }
           if (item.type === "function_call") {
             const functionCall = item;
             const buffer = toolCallBuffers.get(functionCall.call_id);
@@ -18644,7 +19120,12 @@ var OpenAIResponsesStreamConverter = class {
             usage: {
               input_tokens: response.usage?.input_tokens || 0,
               output_tokens: response.usage?.output_tokens || 0,
-              total_tokens: response.usage?.total_tokens || 0
+              total_tokens: response.usage?.total_tokens || 0,
+              ...response.usage?.output_tokens_details?.reasoning_tokens != null && {
+                output_tokens_details: {
+                  reasoning_tokens: response.usage.output_tokens_details.reasoning_tokens
+                }
+              }
             },
             iterations: 1
           };
@@ -18685,6 +19166,26 @@ function resolveMaxContextTokens(model, fallback) {
   return info ? info.features.input.tokens : fallback;
 }
 
+// src/infrastructure/providers/shared/validateThinkingConfig.ts
+function validateThinkingConfig(thinking) {
+  if (!thinking.enabled) return;
+  if (thinking.budgetTokens !== void 0) {
+    if (typeof thinking.budgetTokens !== "number" || thinking.budgetTokens < 1) {
+      throw new Error(
+        `Invalid thinking budgetTokens: ${thinking.budgetTokens}. Must be a positive number.`
+      );
+    }
+  }
+  if (thinking.effort !== void 0) {
+    const validEfforts = ["low", "medium", "high"];
+    if (!validEfforts.includes(thinking.effort)) {
+      throw new Error(
+        `Invalid thinking effort: '${thinking.effort}'. Must be one of: ${validEfforts.join(", ")}`
+      );
+    }
+  }
+}
+
 // src/infrastructure/providers/openai/OpenAITextProvider.ts
 var OpenAITextProvider = class extends BaseTextProvider {
   name = "openai";
@@ -18752,6 +19253,7 @@ var OpenAITextProvider = class extends BaseTextProvider {
           },
           ...options.metadata && { metadata: options.metadata }
         };
+        this.applyReasoningConfig(params, options);
         const response = await this.client.responses.create(params);
         return this.converter.convertResponse(response);
       } catch (error) {
@@ -18793,6 +19295,7 @@ var OpenAITextProvider = class extends BaseTextProvider {
         ...options.metadata && { metadata: options.metadata },
         stream: true
       };
+      this.applyReasoningConfig(params, options);
       const stream = await this.client.responses.create(params);
       yield* this.streamConverter.convertStream(stream);
     } catch (error) {
@@ -18814,6 +19317,27 @@ var OpenAITextProvider = class extends BaseTextProvider {
       maxOutputTokens: 16384
     });
   }
+  /**
+   * List available models from the OpenAI API
+   */
+  async listModels() {
+    const models = [];
+    for await (const model of this.client.models.list()) {
+      models.push(model.id);
+    }
+    return models.sort();
+  }
+  /**
+   * Apply reasoning config from unified thinking option to request params
+   */
+  applyReasoningConfig(params, options) {
+    if (options.thinking?.enabled) {
+      validateThinkingConfig(options.thinking);
+      params.reasoning = {
+        effort: options.thinking.effort || "medium"
+      };
+    }
+  }
   /**
    * Handle OpenAI-specific errors
    */
@@ -18856,6 +19380,7 @@ function buildLLMResponse(options) {
     }
   ];
   const outputText = extractTextFromContent(content);
+  const thinking = extractThinkingFromContent(content);
   return {
     id: responseId,
     object: "response",
@@ -18864,6 +19389,7 @@ function buildLLMResponse(options) {
     model,
     output,
     output_text: outputText,
+    ...thinking && { thinking },
     usage: {
       input_tokens: usage.inputTokens,
       output_tokens: usage.outputTokens,
@@ -18876,6 +19402,10 @@ function extractTextFromContent(content) {
     (c) => c.type === "output_text" /* OUTPUT_TEXT */
   ).map((c) => c.text).join("\n");
 }
+function extractThinkingFromContent(content) {
+  const thinkingTexts = content.filter((c) => c.type === "thinking" /* THINKING */).map((c) => c.thinking).filter(Boolean);
+  return thinkingTexts.length > 0 ? thinkingTexts.join("\n") : void 0;
+}
 function createTextContent(text) {
   return {
     type: "output_text" /* OUTPUT_TEXT */,
@@ -19125,7 +19655,15 @@ var AnthropicConverter = class extends BaseConverter {
     if (tools && tools.length > 0) {
       params.tools = tools;
     }
-    if (options.temperature !== void 0) {
+    if (options.thinking?.enabled) {
+      validateThinkingConfig(options.thinking);
+      const budgetTokens = options.thinking.budgetTokens || 1e4;
+      params.thinking = {
+        type: "enabled",
+        budget_tokens: budgetTokens
+      };
+      params.temperature = 1;
+    } else if (options.temperature !== void 0) {
       params.temperature = options.temperature;
     }
     return params;
@@ -19171,6 +19709,14 @@ var AnthropicConverter = class extends BaseConverter {
         content.push(this.createText(block.text));
       } else if (block.type === "tool_use") {
         content.push(this.createToolUse(block.id, block.name, block.input));
+      } else if (block.type === "thinking") {
+        const thinkingBlock = block;
+        content.push({
+          type: "thinking" /* THINKING */,
+          thinking: thinkingBlock.thinking || "",
+          signature: thinkingBlock.signature,
+          persistInHistory: true
+        });
       }
     }
     return content;
@@ -19249,6 +19795,17 @@ var AnthropicConverter = class extends BaseConverter {
           });
           break;
         }
+        case "thinking" /* THINKING */: {
+          const thinkingContent = c;
+          if (thinkingContent.signature) {
+            blocks.push({
+              type: "thinking",
+              thinking: thinkingContent.thinking,
+              signature: thinkingContent.signature
+            });
+          }
+          break;
+        }
       }
     }
     if (blocks.length === 1 && blocks[0]?.type === "text") {
@@ -19381,6 +19938,8 @@ var BaseStreamConverter = class {
   usage = { inputTokens: 0, outputTokens: 0 };
   /** Buffers for accumulating tool call arguments */
   toolCallBuffers = /* @__PURE__ */ new Map();
+  /** Buffer for accumulating reasoning/thinking content */
+  reasoningBuffer = "";
   // ==========================================================================
   // Public API
   // ==========================================================================
@@ -19415,6 +19974,7 @@ var BaseStreamConverter = class {
     this.sequenceNumber = 0;
     this.usage = { inputTokens: 0, outputTokens: 0 };
     this.toolCallBuffers.clear();
+    this.reasoningBuffer = "";
   }
   /**
    * Reset converter state for a new stream
@@ -19469,6 +20029,33 @@ var BaseStreamConverter = class {
       sequence_number: this.nextSequence()
     };
   }
+  /**
+   * Create REASONING_DELTA event and accumulate reasoning buffer
+   */
+  emitReasoningDelta(delta, itemId) {
+    this.reasoningBuffer += delta;
+    return {
+      type: "response.reasoning.delta" /* REASONING_DELTA */,
+      response_id: this.responseId,
+      item_id: itemId || `reasoning_${this.responseId}`,
+      delta,
+      sequence_number: this.nextSequence()
+    };
+  }
+  /**
+   * Create REASONING_DONE event with accumulated reasoning
+   */
+  emitReasoningDone(itemId) {
+    const id = itemId || `reasoning_${this.responseId}`;
+    const thinking = this.reasoningBuffer;
+    this.reasoningBuffer = "";
+    return {
+      type: "response.reasoning.done" /* REASONING_DONE */,
+      response_id: this.responseId,
+      item_id: id,
+      thinking
+    };
+  }
   /**
    * Create TOOL_CALL_START event
    */
@@ -19613,7 +20200,10 @@ var AnthropicStreamConverter = class extends BaseStreamConverter {
   handleContentBlockStart(event) {
     const index = event.index;
     const block = event.content_block;
-    if (block.type === "text") {
+    if (block.type === "thinking") {
+      this.contentBlockIndex.set(index, { type: "thinking" });
+      return [];
+    } else if (block.type === "text") {
       this.contentBlockIndex.set(index, { type: "text" });
       return [];
     } else if (block.type === "tool_use") {
@@ -19634,7 +20224,12 @@ var AnthropicStreamConverter = class extends BaseStreamConverter {
     const delta = event.delta;
     const blockInfo = this.contentBlockIndex.get(index);
     if (!blockInfo) return [];
-    if (delta.type === "text_delta") {
+    if (delta.type === "thinking_delta") {
+      const thinkingDelta = delta;
+      return [
+        this.emitReasoningDelta(thinkingDelta.thinking || "", `thinking_${this.responseId}`)
+      ];
+    } else if (delta.type === "text_delta") {
       return [
         this.emitTextDelta(delta.text, {
           itemId: `msg_${this.responseId}`,
@@ -19654,6 +20249,9 @@ var AnthropicStreamConverter = class extends BaseStreamConverter {
     const index = event.index;
     const blockInfo = this.contentBlockIndex.get(index);
     if (!blockInfo) return [];
+    if (blockInfo.type === "thinking") {
+      return [this.emitReasoningDone(`thinking_${this.responseId}`)];
+    }
     if (blockInfo.type === "tool_use") {
       return [this.emitToolCallArgsDone(blockInfo.id || "", blockInfo.name)];
     }
@@ -19752,6 +20350,16 @@ var AnthropicTextProvider = class extends BaseTextProvider {
     caps.supportsJSONSchema = false;
     return caps;
   }
+  /**
+   * List available models from the Anthropic API
+   */
+  async listModels() {
+    const models = [];
+    for await (const model of this.client.models.list()) {
+      models.push(model.id);
+    }
+    return models.sort();
+  }
   /**
    * Handle Anthropic-specific errors
    */
@@ -19930,6 +20538,11 @@ var GoogleConverter = class {
       request.generationConfig.thinkingConfig = {
         thinkingLevel: options.vendorOptions.thinkingLevel
       };
+    } else if (options.thinking?.enabled) {
+      validateThinkingConfig(options.thinking);
+      request.generationConfig.thinkingConfig = {
+        thinkingBudget: options.thinking.budgetTokens || 8192
+      };
     }
     if (tools && tools.length > 0) {
       request.generationConfig.allowCodeExecution = false;
@@ -20145,7 +20758,13 @@ var GoogleConverter = class {
   convertGeminiPartsToContent(parts) {
     const content = [];
     for (const part of parts) {
-      if ("text" in part && part.text) {
+      if ("thought" in part && part.thought === true && "text" in part && part.text) {
+        content.push({
+          type: "thinking" /* THINKING */,
+          thinking: part.text,
+          persistInHistory: false
+        });
+      } else if ("text" in part && part.text) {
         content.push(createTextContent(part.text));
       } else if ("functionCall" in part && part.functionCall) {
         const toolId = generateToolCallId("google");
@@ -20223,6 +20842,8 @@ var GoogleStreamConverter = class {
   isFirst = true;
   toolCallBuffers = /* @__PURE__ */ new Map();
   hadToolCalls = false;
+  reasoningBuffer = "";
+  wasThinking = false;
   // External storage for thought signatures (shared with GoogleConverter)
   thoughtSignatureStorage = null;
   // External storage for tool call ID → name mapping (shared with GoogleConverter)
@@ -20250,6 +20871,8 @@ var GoogleStreamConverter = class {
     this.isFirst = true;
     this.toolCallBuffers.clear();
     this.hadToolCalls = false;
+    this.reasoningBuffer = "";
+    this.wasThinking = false;
     let lastUsage = {
       input_tokens: 0,
       output_tokens: 0,
@@ -20275,6 +20898,16 @@ var GoogleStreamConverter = class {
         yield event;
       }
     }
+    if (this.wasThinking && this.reasoningBuffer) {
+      yield {
+        type: "response.reasoning.done" /* REASONING_DONE */,
+        response_id: this.responseId,
+        item_id: `thinking_${this.responseId}`,
+        thinking: this.reasoningBuffer
+      };
+      this.reasoningBuffer = "";
+      this.wasThinking = false;
+    }
     if (this.toolCallBuffers.size > 0) {
       for (const [toolCallId, buffer] of this.toolCallBuffers) {
         yield {
@@ -20314,7 +20947,28 @@ var GoogleStreamConverter = class {
     const candidate = chunk.candidates?.[0];
     if (!candidate?.content?.parts) return events;
     for (const part of candidate.content.parts) {
-      if (part.text) {
+      const isThought = "thought" in part && part.thought === true;
+      if (isThought && part.text) {
+        this.wasThinking = true;
+        this.reasoningBuffer += part.text;
+        events.push({
+          type: "response.reasoning.delta" /* REASONING_DELTA */,
+          response_id: this.responseId,
+          item_id: `thinking_${this.responseId}`,
+          delta: part.text,
+          sequence_number: this.sequenceNumber++
+        });
+      } else if (part.text) {
+        if (this.wasThinking) {
+          this.wasThinking = false;
+          events.push({
+            type: "response.reasoning.done" /* REASONING_DONE */,
+            response_id: this.responseId,
+            item_id: `thinking_${this.responseId}`,
+            thinking: this.reasoningBuffer
+          });
+          this.reasoningBuffer = "";
+        }
         events.push({
           type: "response.output_text.delta" /* OUTPUT_TEXT_DELTA */,
           response_id: this.responseId,
@@ -20413,6 +21067,8 @@ var GoogleStreamConverter = class {
     this.isFirst = true;
     this.toolCallBuffers.clear();
     this.hadToolCalls = false;
+    this.reasoningBuffer = "";
+    this.wasThinking = false;
   }
   /**
    * Reset converter state for a new stream
@@ -20542,6 +21198,18 @@ var GoogleTextProvider = class extends BaseTextProvider {
       maxOutputTokens: 65536
     });
   }
+  /**
+   * List available models from the Google Gemini API
+   */
+  async listModels() {
+    const models = [];
+    const pager = await this.client.models.list();
+    for await (const model of pager) {
+      const name = model.name?.replace(/^models\//, "") ?? "";
+      if (name) models.push(name);
+    }
+    return models.sort();
+  }
   /**
    * Handle Google-specific errors
    */
@@ -20649,6 +21317,18 @@ var VertexAITextProvider = class extends BaseTextProvider {
       maxOutputTokens: 65536
     });
   }
+  /**
+   * List available models from the Vertex AI API
+   */
+  async listModels() {
+    const models = [];
+    const pager = await this.client.models.list();
+    for await (const model of pager) {
+      const name = model.name?.replace(/^models\//, "") ?? "";
+      if (name) models.push(name);
+    }
+    return models.sort();
+  }
   /**
    * Handle Vertex AI-specific errors
    */
@@ -20694,6 +21374,23 @@ var GenericOpenAIProvider = class extends OpenAITextProvider {
       };
     }
   }
+  /**
+   * Override API key validation for generic providers.
+   * Services like Ollama don't require authentication, so accept any key including mock/placeholder keys.
+   */
+  validateApiKey() {
+    return { isValid: true };
+  }
+  /**
+   * Override listModels for error safety — some OpenAI-compatible APIs may not support /v1/models
+   */
+  async listModels() {
+    try {
+      return await super.listModels();
+    } catch {
+      return [];
+    }
+  }
   /**
    * Override model capabilities for generic providers (registry-driven with conservative defaults)
    */
@@ -20891,7 +21588,7 @@ var BaseAgent = class extends eventemitter3.EventEmitter {
       model: config.model,
       agentId: config.name,
       userId: config.userId,
-      connectors: config.connectors,
+      identities: config.identities,
       // Include storage and sessionId if session config is provided
       storage: config.session?.storage,
       // Thread tool execution timeout to ToolManager
@@ -21061,16 +21758,16 @@ var BaseAgent = class extends eventemitter3.EventEmitter {
     this._agentContext.userId = value;
   }
   /**
-   * Get the allowed connector names (undefined = all visible connectors).
+   * Get the auth identities this agent is scoped to (undefined = all visible connectors).
    */
-  get connectors() {
-    return this._agentContext.connectors;
+  get identities() {
+    return this._agentContext.identities;
   }
   /**
-   * Restrict this agent to a subset of connectors. Updates ToolContext.connectorRegistry.
+   * Set auth identities at runtime. Updates ToolContext.connectorRegistry and tool descriptions.
    */
-  set connectors(value) {
-    this._agentContext.connectors = value;
+  set identities(value) {
+    this._agentContext.identities = value;
   }
   /**
    * Permission management. Returns ToolPermissionManager for approval control.
@@ -21082,9 +21779,12 @@ var BaseAgent = class extends eventemitter3.EventEmitter {
   /**
    * Add a tool to the agent.
    * Tools are registered with AgentContext (single source of truth).
+   *
+   * @param tool - The tool function to register
+   * @param options - Optional registration options (namespace, source, priority, etc.)
    */
-  addTool(tool) {
-    this._agentContext.tools.register(tool);
+  addTool(tool, options) {
+    this._agentContext.tools.register(tool, options);
     if (tool.permission) {
       this._permissionManager.setToolConfig(tool.definition.function.name, tool.permission);
     }
@@ -21124,7 +21824,34 @@ var BaseAgent = class extends eventemitter3.EventEmitter {
    */
   getEnabledToolDefinitions() {
     const toolContext = this._agentContext.tools.getToolContext();
-    return this._agentContext.tools.getEnabled().map((tool) => {
+    const identities = this._agentContext.identities;
+    let allowedSources;
+    let allowedConnectorNames;
+    if (identities) {
+      allowedSources = /* @__PURE__ */ new Set();
+      allowedConnectorNames = /* @__PURE__ */ new Set();
+      for (const id of identities) {
+        allowedConnectorNames.add(id.connector);
+        if (id.accountId) {
+          allowedSources.add(`connector:${id.connector}:${id.accountId}`);
+        } else {
+          allowedSources.add(`connector:${id.connector}`);
+          allowedConnectorNames.add(id.connector);
+        }
+      }
+    }
+    return this._agentContext.tools.getEnabledRegistrations().filter((reg) => {
+      if (!allowedSources) return true;
+      if (!reg.source?.startsWith("connector:")) return true;
+      if (allowedSources.has(reg.source)) return true;
+      const sourceParts = reg.source.slice("connector:".length).split(":");
+      const connectorName = sourceParts[0];
+      if (allowedConnectorNames.has(connectorName) && allowedSources.has(`connector:${connectorName}`)) {
+        return true;
+      }
+      return false;
+    }).map((reg) => {
+      const tool = reg.tool;
       if (tool.descriptionFactory) {
         const dynamicDescription = tool.descriptionFactory(toolContext);
         return {
@@ -21138,6 +21865,34 @@ var BaseAgent = class extends eventemitter3.EventEmitter {
       return tool.definition;
     });
   }
+  // ===== Model Discovery =====
+  /**
+   * List available models from the provider's API.
+   * Useful for discovering models dynamically (e.g., Ollama local models).
+   */
+  async listModels() {
+    return this._provider.listModels();
+  }
+  // ===== Snapshot / Inspection =====
+  /**
+   * Get a complete, serializable snapshot of the agent's context state.
+   *
+   * Convenience method that auto-wires tool usage stats from ToolManager.
+   * Used by UI "Look Inside" panels.
+   */
+  async getSnapshot() {
+    const stats = this._agentContext.tools.getStats();
+    return this._agentContext.getSnapshot({ mostUsed: stats.mostUsed });
+  }
+  /**
+   * Get a human-readable breakdown of the prepared context.
+   *
+   * Convenience method that delegates to AgentContextNextGen.
+   * Used by "View Full Context" UI panels.
+   */
+  async getViewContext() {
+    return this._agentContext.getViewContext();
+  }
   // ===== Direct LLM Access (Bypasses AgentContext) =====
   /**
    * Get the provider for LLM calls.
@@ -21901,6 +22656,8 @@ var StreamState = class {
   createdAt;
   // Text accumulation: item_id -> text chunks
   textBuffers;
+  // Reasoning accumulation: item_id -> reasoning chunks
+  reasoningBuffers;
   // Tool call accumulation: tool_call_id -> buffer
   toolCallBuffers;
   // Completed tool calls
@@ -21922,6 +22679,7 @@ var StreamState = class {
     this.model = model;
     this.createdAt = createdAt || Date.now();
     this.textBuffers = /* @__PURE__ */ new Map();
+    this.reasoningBuffers = /* @__PURE__ */ new Map();
     this.toolCallBuffers = /* @__PURE__ */ new Map();
     this.completedToolCalls = [];
     this.toolResults = /* @__PURE__ */ new Map();
@@ -21965,6 +22723,39 @@ var StreamState = class {
     }
     return allText.join("");
   }
+  /**
+   * Accumulate reasoning delta for a specific item
+   */
+  accumulateReasoningDelta(itemId, delta) {
+    if (!this.reasoningBuffers.has(itemId)) {
+      this.reasoningBuffers.set(itemId, []);
+    }
+    this.reasoningBuffers.get(itemId).push(delta);
+    this.totalChunks++;
+  }
+  /**
+   * Get complete accumulated reasoning for an item
+   */
+  getCompleteReasoning(itemId) {
+    const chunks = this.reasoningBuffers.get(itemId);
+    return chunks ? chunks.join("") : "";
+  }
+  /**
+   * Get all accumulated reasoning (all items concatenated)
+   */
+  getAllReasoning() {
+    const allReasoning = [];
+    for (const chunks of this.reasoningBuffers.values()) {
+      allReasoning.push(chunks.join(""));
+    }
+    return allReasoning.join("");
+  }
+  /**
+   * Check if stream has any accumulated reasoning
+   */
+  hasReasoning() {
+    return this.reasoningBuffers.size > 0;
+  }
   /**
    * Start accumulating tool call arguments
    */
@@ -22133,6 +22924,7 @@ var StreamState = class {
    */
   clear() {
     this.textBuffers.clear();
+    this.reasoningBuffers.clear();
     this.toolCallBuffers.clear();
     this.completedToolCalls = [];
     this.toolResults.clear();
@@ -22146,6 +22938,7 @@ var StreamState = class {
       model: this.model,
       createdAt: this.createdAt,
       textBuffers: new Map(this.textBuffers),
+      reasoningBuffers: new Map(this.reasoningBuffers),
       toolCallBuffers: new Map(this.toolCallBuffers),
       completedToolCalls: [...this.completedToolCalls],
       toolResults: new Map(this.toolResults),
@@ -22575,6 +23368,20 @@ var Agent = class _Agent extends BaseAgent {
   _addStreamingAssistantMessage(streamState, toolCalls) {
     const assistantText = streamState.getAllText();
     const assistantContent = [];
+    if (streamState.hasReasoning()) {
+      const reasoning = streamState.getAllReasoning();
+      if (reasoning) {
+        const isAnthropic = this.connector.vendor === Vendor.Anthropic;
+        assistantContent.push({
+          type: "thinking" /* THINKING */,
+          thinking: reasoning,
+          // Streaming doesn't carry Anthropic signatures, so signature is undefined here.
+          // Non-streaming responses (via convertResponse) capture signatures correctly.
+          signature: void 0,
+          persistInHistory: isAnthropic
+        });
+      }
+    }
     if (assistantText && assistantText.trim()) {
       assistantContent.push({
         type: "output_text" /* OUTPUT_TEXT */,
@@ -22813,6 +23620,7 @@ var Agent = class _Agent extends BaseAgent {
       tools: this.getEnabledToolDefinitions(),
       tool_choice: "auto",
       temperature: this._config.temperature,
+      thinking: this._config.thinking,
       vendorOptions: this._config.vendorOptions
     };
     const beforeLLM = await this.hookManager.executeHooks("before:llm", {
@@ -22878,6 +23686,7 @@ var Agent = class _Agent extends BaseAgent {
       tools: this.getEnabledToolDefinitions(),
       tool_choice: "auto",
       temperature: this._config.temperature,
+      thinking: this._config.thinking,
       vendorOptions: this._config.vendorOptions
     };
     await this.hookManager.executeHooks("before:llm", {
@@ -22895,7 +23704,9 @@ var Agent = class _Agent extends BaseAgent {
     });
     try {
       for await (const event of this._provider.streamGenerate(generateOptions)) {
-        if (event.type === "response.output_text.delta" /* OUTPUT_TEXT_DELTA */) {
+        if (isReasoningDelta(event)) {
+          streamState.accumulateReasoningDelta(event.item_id, event.delta);
+        } else if (event.type === "response.output_text.delta" /* OUTPUT_TEXT_DELTA */) {
           streamState.accumulateTextDelta(event.item_id, event.delta);
         } else if (event.type === "response.tool_call.start" /* TOOL_CALL_START */) {
           streamState.startToolCall(event.tool_call_id, event.tool_name);
@@ -23425,6 +24236,7 @@ function createTask(input) {
     suggestedTools: input.suggestedTools,
     validation: input.validation,
     expectedOutput: input.expectedOutput,
+    controlFlow: input.controlFlow,
     attempts: 0,
     maxAttempts: input.maxAttempts ?? 3,
     createdAt: now,
@@ -23677,6 +24489,7 @@ function createRoutineDefinition(input) {
     instructions: input.instructions,
     concurrency: input.concurrency,
     allowDynamicTasks: input.allowDynamicTasks ?? false,
+    parameters: input.parameters,
     tags: input.tags,
     author: input.author,
     createdAt: now,
@@ -23892,6 +24705,321 @@ function extractNumber(text, patterns = [
 
 // src/core/routineRunner.ts
 init_Logger();
+
+// src/core/routineControlFlow.ts
+init_Logger();
+var HARD_MAX_ITERATIONS = 1e3;
+var ICM_LARGE_THRESHOLD = 5e3;
+var ROUTINE_KEYS = {
+  /** Plan overview with task statuses (ICM) */
+  PLAN: "__routine_plan",
+  /** Dependency results location guide (ICM) */
+  DEPS: "__routine_deps",
+  /** Prefix for per-dependency result keys (ICM/WM) */
+  DEP_RESULT_PREFIX: "__dep_result_",
+  /** Current map/fold item (ICM) */
+  MAP_ITEM: "__map_item",
+  /** Current map/fold index, 0-based (ICM) */
+  MAP_INDEX: "__map_index",
+  /** Total items in map/fold (ICM) */
+  MAP_TOTAL: "__map_total",
+  /** Running fold accumulator (ICM) */
+  FOLD_ACCUMULATOR: "__fold_accumulator",
+  /** Prefix for large dep results stored in WM findings tier */
+  WM_DEP_FINDINGS_PREFIX: "findings/__dep_result_"
+};
+function resolveTemplates(text, inputs, icmPlugin) {
+  return text.replace(/\{\{(\w+)\.(\w+)\}\}/g, (_match, namespace, key) => {
+    let value;
+    if (namespace === "param") {
+      value = inputs[key];
+    } else if (namespace === "map") {
+      const icmKey = `__map_${key}`;
+      value = icmPlugin?.get(icmKey);
+    } else if (namespace === "fold") {
+      const icmKey = `__fold_${key}`;
+      value = icmPlugin?.get(icmKey);
+    } else {
+      return _match;
+    }
+    if (value === void 0) {
+      return _match;
+    }
+    return typeof value === "string" ? value : JSON.stringify(value);
+  });
+}
+function resolveTaskTemplates(task, inputs, icmPlugin) {
+  const resolvedDescription = resolveTemplates(task.description, inputs, icmPlugin);
+  const resolvedExpectedOutput = task.expectedOutput ? resolveTemplates(task.expectedOutput, inputs, icmPlugin) : task.expectedOutput;
+  if (resolvedDescription === task.description && resolvedExpectedOutput === task.expectedOutput) {
+    return task;
+  }
+  return {
+    ...task,
+    description: resolvedDescription,
+    expectedOutput: resolvedExpectedOutput
+  };
+}
+function validateAndResolveInputs(parameters, inputs) {
+  const resolved = { ...inputs ?? {} };
+  if (!parameters || parameters.length === 0) {
+    return resolved;
+  }
+  for (const param of parameters) {
+    if (resolved[param.name] === void 0) {
+      if (param.required) {
+        throw new Error(`Missing required parameter: "${param.name}"`);
+      }
+      if (param.default !== void 0) {
+        resolved[param.name] = param.default;
+      }
+    }
+  }
+  return resolved;
+}
+async function readMemoryValue(key, icmPlugin, wmPlugin) {
+  if (icmPlugin) {
+    const icmValue = icmPlugin.get(key);
+    if (icmValue !== void 0) return icmValue;
+  }
+  if (wmPlugin) {
+    const wmValue = await wmPlugin.retrieve(key);
+    if (wmValue !== void 0) return wmValue;
+  }
+  return void 0;
+}
+async function storeResult(key, description, value, icmPlugin, wmPlugin) {
+  const serialized = typeof value === "string" ? value : JSON.stringify(value);
+  const estimatedTokens = Math.ceil(serialized.length / 4);
+  if (estimatedTokens < ICM_LARGE_THRESHOLD && icmPlugin) {
+    icmPlugin.set(key, description, value, "high");
+  } else if (wmPlugin) {
+    await wmPlugin.store(key, description, serialized, { tier: "findings" });
+  } else if (icmPlugin) {
+    icmPlugin.set(key, description, value, "high");
+  }
+}
+function resolveSubRoutine(spec, parentTaskName) {
+  if (!Array.isArray(spec)) {
+    return spec;
+  }
+  return createRoutineDefinition({
+    name: `${parentTaskName} (sub-routine)`,
+    description: `Sub-routine of ${parentTaskName}`,
+    tasks: spec
+  });
+}
+function getPlugins(agent) {
+  const icmPlugin = agent.context.getPlugin("in_context_memory");
+  const wmPlugin = agent.context.memory;
+  return { icmPlugin, wmPlugin };
+}
+function cleanMapKeys(icmPlugin) {
+  if (!icmPlugin) return;
+  icmPlugin.delete(ROUTINE_KEYS.MAP_ITEM);
+  icmPlugin.delete(ROUTINE_KEYS.MAP_INDEX);
+  icmPlugin.delete(ROUTINE_KEYS.MAP_TOTAL);
+}
+function cleanFoldKeys(icmPlugin) {
+  if (!icmPlugin) return;
+  cleanMapKeys(icmPlugin);
+  icmPlugin.delete(ROUTINE_KEYS.FOLD_ACCUMULATOR);
+}
+async function readSourceArray(flow, flowType, icmPlugin, wmPlugin) {
+  const sourceValue = await readMemoryValue(flow.sourceKey, icmPlugin, wmPlugin);
+  if (!Array.isArray(sourceValue)) {
+    return {
+      completed: false,
+      error: `${flowType} sourceKey "${flow.sourceKey}" is not an array (got ${typeof sourceValue})`
+    };
+  }
+  const maxIter = Math.min(sourceValue.length, flow.maxIterations ?? sourceValue.length, HARD_MAX_ITERATIONS);
+  return { array: sourceValue, maxIter };
+}
+function prepareSubRoutine(tasks, parentTaskName) {
+  const subRoutine = resolveSubRoutine(tasks, parentTaskName);
+  return {
+    augmented: { ...subRoutine },
+    baseInstructions: subRoutine.instructions ?? ""
+  };
+}
+function getSubRoutineOutput(execution) {
+  const tasks = execution.plan.tasks;
+  for (let i = tasks.length - 1; i >= 0; i--) {
+    if (tasks[i].status === "completed") {
+      return tasks[i].result?.output ?? null;
+    }
+  }
+  return null;
+}
+function setIterationKeys(icmPlugin, item, index, total, label) {
+  if (!icmPlugin) return;
+  icmPlugin.set(ROUTINE_KEYS.MAP_ITEM, `Current ${label} item (${index + 1}/${total})`, item, "high");
+  icmPlugin.set(ROUTINE_KEYS.MAP_INDEX, `Current ${label} index (0-based)`, index, "high");
+  icmPlugin.set(ROUTINE_KEYS.MAP_TOTAL, `Total items in ${label}`, total, "high");
+}
+async function withTimeout(promise, timeoutMs, label) {
+  if (!timeoutMs) return promise;
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function handleMap(agent, flow, task, inputs) {
+  const { icmPlugin, wmPlugin } = getPlugins(agent);
+  const log = exports.logger.child({ controlFlow: "map", task: task.name });
+  const sourceResult = await readSourceArray(flow, "Map", icmPlugin, wmPlugin);
+  if ("completed" in sourceResult) return sourceResult;
+  const { array: array3, maxIter } = sourceResult;
+  const results = [];
+  const { augmented, baseInstructions } = prepareSubRoutine(flow.tasks, task.name);
+  log.info({ arrayLength: array3.length, maxIterations: maxIter }, "Starting map iteration");
+  try {
+    for (let i = 0; i < maxIter; i++) {
+      setIterationKeys(icmPlugin, array3[i], i, array3.length, "map");
+      augmented.instructions = [
+        `You are processing item ${i + 1} of ${array3.length} in a map operation.`,
+        "The current item is available in your live context as __map_item.",
+        "Current index (0-based) is in __map_index, total count in __map_total.",
+        "",
+        baseInstructions
+      ].join("\n");
+      const subExecution = await withTimeout(
+        executeRoutine({ definition: augmented, agent, inputs }),
+        flow.iterationTimeoutMs,
+        `Map iteration ${i}`
+      );
+      if (subExecution.status !== "completed") {
+        return {
+          completed: false,
+          error: `Map iteration ${i} failed: ${subExecution.error ?? "sub-routine failed"}`
+        };
+      }
+      results.push(getSubRoutineOutput(subExecution));
+    }
+  } finally {
+    cleanMapKeys(icmPlugin);
+  }
+  if (flow.resultKey) {
+    await storeResult(flow.resultKey, `Map results from "${task.name}"`, results, icmPlugin, wmPlugin);
+  }
+  log.info({ resultCount: results.length }, "Map completed");
+  return { completed: true, result: results };
+}
+async function handleFold(agent, flow, task, inputs) {
+  const { icmPlugin, wmPlugin } = getPlugins(agent);
+  const log = exports.logger.child({ controlFlow: "fold", task: task.name });
+  const sourceResult = await readSourceArray(flow, "Fold", icmPlugin, wmPlugin);
+  if ("completed" in sourceResult) return sourceResult;
+  const { array: array3, maxIter } = sourceResult;
+  let accumulator = flow.initialValue;
+  const { augmented, baseInstructions } = prepareSubRoutine(flow.tasks, task.name);
+  log.info({ arrayLength: array3.length, maxIterations: maxIter }, "Starting fold iteration");
+  try {
+    for (let i = 0; i < maxIter; i++) {
+      setIterationKeys(icmPlugin, array3[i], i, array3.length, "fold");
+      if (icmPlugin) {
+        icmPlugin.set(ROUTINE_KEYS.FOLD_ACCUMULATOR, "Running accumulator \u2014 update via context_set", accumulator, "high");
+      }
+      augmented.instructions = [
+        `You are processing item ${i + 1} of ${array3.length} in a fold/accumulate operation.`,
+        "The current item is in __map_item. The running accumulator is in __fold_accumulator.",
+        "After processing, use context_set to update __fold_accumulator with the new accumulated value.",
+        "Your final text response will also be captured as the result.",
+        "",
+        baseInstructions
+      ].join("\n");
+      const subExecution = await withTimeout(
+        executeRoutine({ definition: augmented, agent, inputs }),
+        flow.iterationTimeoutMs,
+        `Fold iteration ${i}`
+      );
+      if (subExecution.status !== "completed") {
+        return {
+          completed: false,
+          error: `Fold iteration ${i} failed: ${subExecution.error ?? "sub-routine failed"}`
+        };
+      }
+      const taskOutput = getSubRoutineOutput(subExecution);
+      if (taskOutput !== null) {
+        accumulator = taskOutput;
+      } else if (icmPlugin) {
+        const icmAccumulator = icmPlugin.get(ROUTINE_KEYS.FOLD_ACCUMULATOR);
+        if (icmAccumulator !== void 0) {
+          accumulator = icmAccumulator;
+        }
+      }
+    }
+  } finally {
+    cleanFoldKeys(icmPlugin);
+  }
+  await storeResult(flow.resultKey, `Fold result from "${task.name}"`, accumulator, icmPlugin, wmPlugin);
+  log.info("Fold completed");
+  return { completed: true, result: accumulator };
+}
+async function handleUntil(agent, flow, task, inputs) {
+  const { icmPlugin, wmPlugin } = getPlugins(agent);
+  const log = exports.logger.child({ controlFlow: "until", task: task.name });
+  const { augmented, baseInstructions } = prepareSubRoutine(flow.tasks, task.name);
+  log.info({ maxIterations: flow.maxIterations }, "Starting until loop");
+  const memoryAccess = {
+    get: (key) => readMemoryValue(key, icmPlugin, wmPlugin)
+  };
+  try {
+    for (let i = 0; i < flow.maxIterations; i++) {
+      if (flow.iterationKey && icmPlugin) {
+        icmPlugin.set(flow.iterationKey, "Current iteration index", i, "high");
+      }
+      augmented.instructions = [
+        `You are in iteration ${i + 1} of a repeating operation (max ${flow.maxIterations}).`,
+        "Complete the task. The loop will continue until its exit condition is met.",
+        "",
+        baseInstructions
+      ].join("\n");
+      const subExecution = await withTimeout(
+        executeRoutine({ definition: augmented, agent, inputs }),
+        flow.iterationTimeoutMs,
+        `Until iteration ${i}`
+      );
+      if (subExecution.status !== "completed") {
+        return {
+          completed: false,
+          error: `Until iteration ${i} failed: ${subExecution.error ?? "sub-routine failed"}`
+        };
+      }
+      const conditionMet = await evaluateCondition(flow.condition, memoryAccess);
+      if (conditionMet) {
+        log.info({ iteration: i + 1 }, "Until condition met");
+        return { completed: true };
+      }
+    }
+  } finally {
+    if (flow.iterationKey && icmPlugin) {
+      icmPlugin.delete(flow.iterationKey);
+    }
+  }
+  return { completed: false, error: `Until loop: maxIterations (${flow.maxIterations}) exceeded` };
+}
+async function executeControlFlow(agent, task, inputs) {
+  const flow = task.controlFlow;
+  switch (flow.type) {
+    case "map":
+      return handleMap(agent, flow, task, inputs);
+    case "fold":
+      return handleFold(agent, flow, task, inputs);
+    case "until":
+      return handleUntil(agent, flow, task, inputs);
+    default:
+      return { completed: false, error: `Unknown control flow type: ${flow.type}` };
+  }
+}
+
+// src/core/routineRunner.ts
 function defaultSystemPrompt(definition) {
   const parts = [];
   if (definition.instructions) {
@@ -24020,6 +25148,14 @@ async function collectValidationContext(agent, responseText) {
     toolCallLog
   };
 }
+function isTransientError(error) {
+  if (error instanceof ProviderAuthError) return false;
+  if (error instanceof ProviderContextLengthError) return false;
+  if (error instanceof ProviderNotFoundError) return false;
+  if (error instanceof ModelNotSupportedError) return false;
+  if (error instanceof InvalidConfigError) return false;
+  return true;
+}
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
@@ -24063,32 +25199,42 @@ function buildPlanOverview(execution, definition, currentTaskId) {
   }
   return parts.join("\n");
 }
-async function injectRoutineContext(agent, execution, definition, currentTask) {
-  const icmPlugin = agent.context.getPlugin("in_context_memory");
-  const wmPlugin = agent.context.memory;
-  if (!icmPlugin && !wmPlugin) {
-    exports.logger.warn("injectRoutineContext: No ICM or WM plugin available \u2014 skipping context injection");
-    return;
-  }
-  const planOverview = buildPlanOverview(execution, definition, currentTask.id);
-  if (icmPlugin) {
-    icmPlugin.set("__routine_plan", "Routine plan overview with task statuses", planOverview, "high");
-  }
+async function cleanupMemoryKeys(icmPlugin, wmPlugin, config) {
   if (icmPlugin) {
     for (const entry of icmPlugin.list()) {
-      if (entry.key.startsWith("__dep_result_") || entry.key === "__routine_deps") {
-        icmPlugin.delete(entry.key);
-      }
+      const shouldDelete = config.icmPrefixes.some((p) => entry.key.startsWith(p)) || (config.icmExactKeys?.includes(entry.key) ?? false);
+      if (shouldDelete) icmPlugin.delete(entry.key);
     }
   }
   if (wmPlugin) {
     const { entries: wmEntries } = await wmPlugin.query();
     for (const entry of wmEntries) {
-      if (entry.key.startsWith("__dep_result_") || entry.key.startsWith("findings/__dep_result_")) {
+      if (config.wmPrefixes.some((p) => entry.key.startsWith(p))) {
         await wmPlugin.delete(entry.key);
       }
     }
   }
+}
+var DEP_CLEANUP_CONFIG = {
+  icmPrefixes: [ROUTINE_KEYS.DEP_RESULT_PREFIX],
+  icmExactKeys: [ROUTINE_KEYS.DEPS],
+  wmPrefixes: [ROUTINE_KEYS.DEP_RESULT_PREFIX, ROUTINE_KEYS.WM_DEP_FINDINGS_PREFIX]
+};
+var FULL_CLEANUP_CONFIG = {
+  icmPrefixes: ["__routine_", ROUTINE_KEYS.DEP_RESULT_PREFIX, "__map_", "__fold_"],
+  wmPrefixes: [ROUTINE_KEYS.DEP_RESULT_PREFIX, ROUTINE_KEYS.WM_DEP_FINDINGS_PREFIX]
+};
+async function injectRoutineContext(agent, execution, definition, currentTask) {
+  const { icmPlugin, wmPlugin } = getPlugins(agent);
+  if (!icmPlugin && !wmPlugin) {
+    exports.logger.warn("injectRoutineContext: No ICM or WM plugin available \u2014 skipping context injection");
+    return;
+  }
+  const planOverview = buildPlanOverview(execution, definition, currentTask.id);
+  if (icmPlugin) {
+    icmPlugin.set(ROUTINE_KEYS.PLAN, "Routine plan overview with task statuses", planOverview, "high");
+  }
+  await cleanupMemoryKeys(icmPlugin, wmPlugin, DEP_CLEANUP_CONFIG);
   if (currentTask.dependsOn.length === 0) return;
   const inContextDeps = [];
   const workingMemoryDeps = [];
@@ -24097,7 +25243,7 @@ async function injectRoutineContext(agent, execution, definition, currentTask) {
     if (!depTask?.result?.output) continue;
     const output = typeof depTask.result.output === "string" ? depTask.result.output : JSON.stringify(depTask.result.output);
     const tokens = estimateTokens(output);
-    const depKey = `__dep_result_${depId}`;
+    const depKey = `${ROUTINE_KEYS.DEP_RESULT_PREFIX}${depId}`;
     const depLabel = `Result from task "${depTask.name}"`;
     if (tokens < 5e3 && icmPlugin) {
       icmPlugin.set(depKey, depLabel, output, "high");
@@ -24119,27 +25265,12 @@ async function injectRoutineContext(agent, execution, definition, currentTask) {
     if (workingMemoryDeps.length > 0) {
       summaryParts.push(`In working memory (use memory_retrieve): ${workingMemoryDeps.join(", ")}`);
     }
-    icmPlugin.set("__routine_deps", "Dependency results location guide", summaryParts.join("\n"), "high");
+    icmPlugin.set(ROUTINE_KEYS.DEPS, "Dependency results location guide", summaryParts.join("\n"), "high");
   }
 }
 async function cleanupRoutineContext(agent) {
-  const icmPlugin = agent.context.getPlugin("in_context_memory");
-  const wmPlugin = agent.context.memory;
-  if (icmPlugin) {
-    for (const entry of icmPlugin.list()) {
-      if (entry.key.startsWith("__routine_") || entry.key.startsWith("__dep_result_")) {
-        icmPlugin.delete(entry.key);
-      }
-    }
-  }
-  if (wmPlugin) {
-    const { entries: wmEntries } = await wmPlugin.query();
-    for (const entry of wmEntries) {
-      if (entry.key.startsWith("__dep_result_") || entry.key.startsWith("findings/__dep_result_")) {
-        await wmPlugin.delete(entry.key);
-      }
-    }
-  }
+  const { icmPlugin, wmPlugin } = getPlugins(agent);
+  await cleanupMemoryKeys(icmPlugin, wmPlugin, FULL_CLEANUP_CONFIG);
 }
 async function validateTaskCompletion(agent, task, responseText, validationPromptBuilder) {
   const hasExplicitValidation = task.validation?.skipReflection === false && task.validation?.completionCriteria && task.validation.completionCriteria.length > 0;
@@ -24188,11 +25319,13 @@ async function executeRoutine(options) {
     onTaskFailed,
     onTaskValidation,
     hooks,
-    prompts
+    prompts,
+    inputs: rawInputs
   } = options;
   if (!existingAgent && (!connector || !model)) {
     throw new Error("executeRoutine requires either `agent` or both `connector` and `model`");
   }
+  const resolvedInputs = validateAndResolveInputs(definition.parameters, rawInputs);
   const ownsAgent = !existingAgent;
   const log = exports.logger.child({ routine: definition.name });
   const execution = createRoutineExecution(definition);
@@ -24277,7 +25410,7 @@ async function executeRoutine(options) {
       execution.lastUpdatedAt = Date.now();
       onTaskStarted?.(execution.plan.tasks[taskIndex], execution);
       let taskCompleted = false;
-      const maxTaskIterations = task.execution?.maxIterations ?? 15;
+      const maxTaskIterations = task.execution?.maxIterations ?? 50;
       const iterationLimiter = async (ctx) => {
         if (ctx.iteration >= maxTaskIterations) {
           agent.cancel(`Task "${task.name}" exceeded max iterations (${maxTaskIterations})`);
@@ -24285,85 +25418,115 @@ async function executeRoutine(options) {
         return { shouldPause: false };
       };
       agent.registerHook("pause:check", iterationLimiter);
-      const getTask = () => execution.plan.tasks[taskIndex];
-      await injectRoutineContext(agent, execution, definition, getTask());
-      while (!taskCompleted) {
-        try {
-          const taskPrompt = buildTaskPrompt(getTask());
-          const response = await agent.run(taskPrompt);
-          const responseText = response.output_text ?? "";
-          const validationResult = await validateTaskCompletion(
-            agent,
-            getTask(),
-            responseText,
-            buildValidationPrompt
-          );
-          onTaskValidation?.(getTask(), validationResult, execution);
-          if (validationResult.isComplete) {
-            execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "completed");
-            execution.plan.tasks[taskIndex].result = {
-              success: true,
-              output: responseText,
-              validationScore: validationResult.completionScore,
-              validationExplanation: validationResult.explanation
-            };
-            taskCompleted = true;
-            log.info(
-              { taskName: getTask().name, score: validationResult.completionScore },
-              "Task completed"
-            );
-            execution.progress = getRoutineProgress(execution);
-            execution.lastUpdatedAt = Date.now();
-            onTaskComplete?.(execution.plan.tasks[taskIndex], execution);
-          } else {
-            log.warn(
-              {
-                taskName: getTask().name,
-                score: validationResult.completionScore,
-                attempt: getTask().attempts,
-                maxAttempts: getTask().maxAttempts
-              },
-              "Task validation failed"
-            );
-            if (getTask().attempts >= getTask().maxAttempts) {
+      try {
+        const getTask = () => execution.plan.tasks[taskIndex];
+        await injectRoutineContext(agent, execution, definition, getTask());
+        const { icmPlugin } = getPlugins(agent);
+        if (getTask().controlFlow) {
+          try {
+            const cfResult = await executeControlFlow(agent, getTask(), resolvedInputs);
+            if (cfResult.completed) {
+              execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "completed");
+              execution.plan.tasks[taskIndex].result = { success: true, output: cfResult.result };
+              taskCompleted = true;
+              execution.progress = getRoutineProgress(execution);
+              execution.lastUpdatedAt = Date.now();
+              onTaskComplete?.(execution.plan.tasks[taskIndex], execution);
+            } else {
               execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "failed");
-              execution.plan.tasks[taskIndex].result = {
-                success: false,
-                error: validationResult.explanation,
-                validationScore: validationResult.completionScore,
-                validationExplanation: validationResult.explanation
-              };
-              break;
+              execution.plan.tasks[taskIndex].result = { success: false, error: cfResult.error };
             }
-            execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "in_progress");
-          }
-        } catch (error) {
-          const errorMessage = error.message;
-          log.error({ taskName: getTask().name, error: errorMessage }, "Task execution error");
-          if (getTask().attempts >= getTask().maxAttempts) {
+          } catch (error) {
+            const errorMessage = error.message;
+            log.error({ taskName: getTask().name, error: errorMessage }, "Control flow error");
             execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "failed");
-            execution.plan.tasks[taskIndex].result = {
-              success: false,
-              error: errorMessage
-            };
-            break;
+            execution.plan.tasks[taskIndex].result = { success: false, error: errorMessage };
+          }
+        } else {
+          while (!taskCompleted) {
+            try {
+              const resolvedTask = resolveTaskTemplates(getTask(), resolvedInputs, icmPlugin);
+              const taskPrompt = buildTaskPrompt(resolvedTask);
+              const response = await agent.run(taskPrompt);
+              const responseText = response.output_text ?? "";
+              const validationResult = await validateTaskCompletion(
+                agent,
+                getTask(),
+                responseText,
+                buildValidationPrompt
+              );
+              onTaskValidation?.(getTask(), validationResult, execution);
+              if (validationResult.isComplete) {
+                execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "completed");
+                execution.plan.tasks[taskIndex].result = {
+                  success: true,
+                  output: responseText,
+                  validationScore: validationResult.completionScore,
+                  validationExplanation: validationResult.explanation
+                };
+                taskCompleted = true;
+                log.info(
+                  { taskName: getTask().name, score: validationResult.completionScore },
+                  "Task completed"
+                );
+                execution.progress = getRoutineProgress(execution);
+                execution.lastUpdatedAt = Date.now();
+                onTaskComplete?.(execution.plan.tasks[taskIndex], execution);
+              } else {
+                log.warn(
+                  {
+                    taskName: getTask().name,
+                    score: validationResult.completionScore,
+                    attempt: getTask().attempts,
+                    maxAttempts: getTask().maxAttempts
+                  },
+                  "Task validation failed"
+                );
+                if (getTask().attempts >= getTask().maxAttempts) {
+                  execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "failed");
+                  execution.plan.tasks[taskIndex].result = {
+                    success: false,
+                    error: validationResult.explanation,
+                    validationScore: validationResult.completionScore,
+                    validationExplanation: validationResult.explanation
+                  };
+                  break;
+                }
+                execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "in_progress");
+              }
+            } catch (error) {
+              const errorMessage = error.message;
+              log.error({ taskName: getTask().name, error: errorMessage }, "Task execution error");
+              if (!isTransientError(error) || getTask().attempts >= getTask().maxAttempts) {
+                execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "failed");
+                execution.plan.tasks[taskIndex].result = {
+                  success: false,
+                  error: errorMessage
+                };
+                break;
+              }
+              execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "in_progress");
+            }
           }
-          execution.plan.tasks[taskIndex] = updateTaskStatus(getTask(), "in_progress");
         }
-      }
-      if (!taskCompleted) {
-        execution.progress = getRoutineProgress(execution);
-        execution.lastUpdatedAt = Date.now();
-        onTaskFailed?.(execution.plan.tasks[taskIndex], execution);
-        if (failureMode === "fail-fast") {
-          execution.status = "failed";
-          execution.error = `Task "${getTask().name}" failed after ${getTask().attempts} attempt(s)`;
-          execution.completedAt = Date.now();
+        if (!taskCompleted) {
+          execution.progress = getRoutineProgress(execution);
           execution.lastUpdatedAt = Date.now();
-          break;
+          onTaskFailed?.(execution.plan.tasks[taskIndex], execution);
+          if (failureMode === "fail-fast") {
+            execution.status = "failed";
+            execution.error = `Task "${getTask().name}" failed after ${getTask().attempts} attempt(s)`;
+            execution.completedAt = Date.now();
+            execution.lastUpdatedAt = Date.now();
+            break;
+          }
+        }
+      } finally {
+        try {
+          agent.unregisterHook("pause:check", iterationLimiter);
+        } catch {
         }
       }
-      agent.unregisterHook("pause:check", iterationLimiter);
       agent.clearConversation("task-boundary");
       nextTasks = getNextExecutableTasks(execution.plan);
     }
@@ -24391,16 +25554,22 @@ async function executeRoutine(options) {
   } finally {
     try {
       await cleanupRoutineContext(agent);
-    } catch {
+    } catch (e) {
+      log.debug({ error: e.message }, "Failed to clean up routine context");
     }
     for (const { name, hook } of registeredHooks) {
       try {
         agent.unregisterHook(name, hook);
-      } catch {
+      } catch (e) {
+        log.debug({ hookName: name, error: e.message }, "Failed to unregister hook");
       }
     }
     if (ownsAgent) {
-      agent.destroy();
+      try {
+        agent.destroy();
+      } catch (e) {
+        log.debug({ error: e.message }, "Failed to destroy agent");
+      }
     }
   }
 }
@@ -31207,7 +32376,7 @@ var TextToSpeech = class _TextToSpeech {
    */
   async toFile(text, filePath, options) {
     const response = await this.synthesize(text, options);
-    await fs18__namespace.writeFile(filePath, response.audio);
+    await fs17__namespace.writeFile(filePath, response.audio);
   }
   // ======================== Introspection Methods ========================
   /**
@@ -31555,7 +32724,7 @@ var SpeechToText = class _SpeechToText {
    * @param options - Optional transcription parameters
    */
   async transcribeFile(filePath, options) {
-    const audio = await fs18__namespace.readFile(filePath);
+    const audio = await fs17__namespace.readFile(filePath);
     return this.transcribe(audio, options);
   }
   /**
@@ -35701,7 +36870,7 @@ var DocumentReader = class _DocumentReader {
   async resolveSource(source) {
     switch (source.type) {
       case "file": {
-        const buffer = await fs18.readFile(source.path);
+        const buffer = await fs17.readFile(source.path);
         const filename = source.path.split("/").pop() || source.path;
         return { buffer, filename };
       }
@@ -38298,10 +39467,10 @@ var FileMediaStorage = class {
   }
   async save(data, metadata) {
     const dir = metadata.userId ? path2__namespace.join(this.outputDir, metadata.userId) : this.outputDir;
-    await fs18__namespace.mkdir(dir, { recursive: true });
+    await fs17__namespace.mkdir(dir, { recursive: true });
     const filename = metadata.suggestedFilename ?? this.generateFilename(metadata);
     const filePath = path2__namespace.join(dir, filename);
-    await fs18__namespace.writeFile(filePath, data);
+    await fs17__namespace.writeFile(filePath, data);
     const format = metadata.format.toLowerCase();
     const mimeType = MIME_TYPES2[format] ?? "application/octet-stream";
     return {
@@ -38312,7 +39481,7 @@ var FileMediaStorage = class {
   }
   async read(location) {
     try {
-      return await fs18__namespace.readFile(location);
+      return await fs17__namespace.readFile(location);
     } catch (err) {
       if (err.code === "ENOENT") {
         return null;
@@ -38322,7 +39491,7 @@ var FileMediaStorage = class {
   }
   async delete(location) {
     try {
-      await fs18__namespace.unlink(location);
+      await fs17__namespace.unlink(location);
     } catch (err) {
       if (err.code === "ENOENT") {
         return;
@@ -38332,7 +39501,7 @@ var FileMediaStorage = class {
   }
   async exists(location) {
     try {
-      await fs18__namespace.access(location);
+      await fs17__namespace.access(location);
       return true;
     } catch {
       return false;
@@ -38341,11 +39510,11 @@ var FileMediaStorage = class {
   async list(options) {
     await this.ensureDir();
     let entries = [];
-    const files = await fs18__namespace.readdir(this.outputDir);
+    const files = await fs17__namespace.readdir(this.outputDir);
     for (const file of files) {
       const filePath = path2__namespace.join(this.outputDir, file);
       try {
-        const stat6 = await fs18__namespace.stat(filePath);
+        const stat6 = await fs17__namespace.stat(filePath);
         if (!stat6.isFile()) continue;
         const ext = path2__namespace.extname(file).slice(1).toLowerCase();
         const mimeType = MIME_TYPES2[ext] ?? "application/octet-stream";
@@ -38385,7 +39554,7 @@ var FileMediaStorage = class {
   }
   async ensureDir() {
     if (!this.initialized) {
-      await fs18__namespace.mkdir(this.outputDir, { recursive: true });
+      await fs17__namespace.mkdir(this.outputDir, { recursive: true });
       this.initialized = true;
     }
   }
@@ -38920,6 +40089,42 @@ var StreamHelpers = class {
     }
     return chunks.join("");
   }
+  /**
+   * Get only reasoning/thinking deltas from stream
+   * Filters out all other event types
+   */
+  static async *thinkingOnly(stream) {
+    for await (const event of stream) {
+      if (isReasoningDelta(event)) {
+        yield event.delta;
+      }
+    }
+  }
+  /**
+   * Get both text and thinking deltas from stream
+   * Yields tagged objects so consumers can distinguish them
+   */
+  static async *textAndThinking(stream) {
+    for await (const event of stream) {
+      if (isOutputTextDelta(event)) {
+        yield { type: "text", delta: event.delta };
+      } else if (isReasoningDelta(event)) {
+        yield { type: "thinking", delta: event.delta };
+      }
+    }
+  }
+  /**
+   * Accumulate all thinking/reasoning content from stream into a single string
+   */
+  static async accumulateThinking(stream) {
+    const chunks = [];
+    for await (const event of stream) {
+      if (isReasoningDelta(event)) {
+        chunks.push(event.delta);
+      }
+    }
+    return chunks.join("");
+  }
   /**
    * Buffer stream events into batches
    */
@@ -38979,6 +40184,11 @@ var StreamHelpers = class {
       case "response.output_text.delta" /* OUTPUT_TEXT_DELTA */:
         state.accumulateTextDelta(event.item_id, event.delta);
         break;
+      case "response.reasoning.delta" /* REASONING_DELTA */:
+        state.accumulateReasoningDelta(event.item_id, event.delta);
+        break;
+      case "response.reasoning.done" /* REASONING_DONE */:
+        break;
       case "response.tool_call.start" /* TOOL_CALL_START */:
         state.startToolCall(event.tool_call_id, event.tool_name);
         break;
@@ -39009,21 +40219,36 @@ var StreamHelpers = class {
    */
   static reconstructLLMResponse(state) {
     const output = [];
+    const contentParts = [];
+    let thinkingText;
+    if (state.hasReasoning()) {
+      const reasoning = state.getAllReasoning();
+      if (reasoning) {
+        thinkingText = reasoning;
+        contentParts.push({
+          type: "thinking" /* THINKING */,
+          thinking: reasoning,
+          persistInHistory: false
+          // Vendor-agnostic default; caller can adjust
+        });
+      }
+    }
     if (state.hasText()) {
       const textContent = state.getAllText();
       if (textContent) {
-        output.push({
-          type: "message",
-          role: "assistant" /* ASSISTANT */,
-          content: [
-            {
-              type: "output_text" /* OUTPUT_TEXT */,
-              text: textContent
-            }
-          ]
+        contentParts.push({
+          type: "output_text" /* OUTPUT_TEXT */,
+          text: textContent
         });
       }
     }
+    if (contentParts.length > 0) {
+      output.push({
+        type: "message",
+        role: "assistant" /* ASSISTANT */,
+        content: contentParts
+      });
+    }
     const toolCalls = state.getCompletedToolCalls();
     if (toolCalls.length > 0) {
       const toolUseContent = toolCalls.map((tc) => ({
@@ -39052,6 +40277,7 @@ var StreamHelpers = class {
       model: state.model,
       output,
       output_text: outputText,
+      thinking: thinkingText,
       usage: state.usage
     };
   }
@@ -39180,6 +40406,15 @@ var SERVICE_DEFINITIONS = [
     baseURL: "https://api.telegram.org",
     docsURL: "https://core.telegram.org/bots/api"
   },
+  {
+    id: "twitter",
+    name: "X (Twitter)",
+    category: "communication",
+    urlPattern: /api\.x\.com|api\.twitter\.com/i,
+    baseURL: "https://api.x.com/2",
+    docsURL: "https://developer.x.com/en/docs/x-api",
+    commonScopes: ["tweet.read", "tweet.write", "users.read", "offline.access"]
+  },
   // ============ Development & Project Management ============
   {
     id: "github",
@@ -39667,19 +40902,30 @@ var ConnectorTools = class {
    */
   static for(connectorOrName, userId, options) {
     const connector = this.resolveConnector(connectorOrName, options?.registry);
+    const accountId = options?.accountId;
     const tools = [];
+    const namePrefix = accountId ? `${sanitizeToolName(connector.name)}_${sanitizeToolName(accountId)}` : sanitizeToolName(connector.name);
     if (connector.baseURL) {
-      tools.push(this.createGenericAPITool(connector, { userId }));
+      const accountLabel = accountId ? ` (account: ${accountId})` : "";
+      tools.push(this.createGenericAPITool(connector, {
+        userId,
+        accountId,
+        toolName: `${namePrefix}_api`,
+        description: `Make an authenticated API call to ${connector.displayName}${accountLabel}.` + (connector.baseURL ? ` Base URL: ${connector.baseURL}.` : " Provide full URL in endpoint.") + ' IMPORTANT: For POST/PUT/PATCH requests, pass data in the "body" parameter as a JSON object, NOT as query string parameters in the endpoint URL. The body is sent as application/json.'
+      }));
     }
     const serviceType = this.detectService(connector);
     if (serviceType && this.factories.has(serviceType)) {
       const factory = this.factories.get(serviceType);
       const serviceTools = factory(connector, userId);
       for (const tool of serviceTools) {
-        tool.definition.function.name = `${sanitizeToolName(connector.name)}_${tool.definition.function.name}`;
+        tool.definition.function.name = `${namePrefix}_${tool.definition.function.name}`;
       }
       tools.push(...serviceTools);
     }
+    if (accountId) {
+      return tools.map((tool) => this.bindAccountId(tool, accountId));
+    }
     return tools;
   }
   /**
@@ -39829,6 +41075,56 @@ var ConnectorTools = class {
     }
     return connectorOrName;
   }
+  /**
+   * Generate tools for a set of auth identities.
+   * Each identity gets its own tool set with unique name prefixes.
+   *
+   * @param identities - Array of auth identities
+   * @param userId - Optional user ID for multi-user OAuth
+   * @param options - Optional registry for scoped connector lookup
+   * @returns Map of identity key to tool array
+   *
+   * @example
+   * ```typescript
+   * const toolsByIdentity = ConnectorTools.forIdentities([
+   *   { connector: 'microsoft', accountId: 'work' },
+   *   { connector: 'microsoft', accountId: 'personal' },
+   *   { connector: 'github' },
+   * ]);
+   * // Keys: 'microsoft:work', 'microsoft:personal', 'github'
+   * ```
+   */
+  static forIdentities(identities, userId, options) {
+    const result = /* @__PURE__ */ new Map();
+    for (const identity of identities) {
+      const key = identity.accountId ? `${identity.connector}:${identity.accountId}` : identity.connector;
+      try {
+        const tools = this.for(identity.connector, userId, {
+          registry: options?.registry,
+          accountId: identity.accountId
+        });
+        if (tools.length > 0) {
+          result.set(key, tools);
+        }
+      } catch (err) {
+        exports.logger.error(`[ConnectorTools.forIdentities] Error generating tools for identity ${key}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    return result;
+  }
+  /**
+   * Wrap a tool to inject accountId into ToolContext at execute time.
+   * This allows identity-bound tools to use the correct account without
+   * modifying every service tool factory.
+   */
+  static bindAccountId(tool, accountId) {
+    return {
+      ...tool,
+      execute: async (args, context) => {
+        return tool.execute(args, { ...context, accountId });
+      }
+    };
+  }
   static createGenericAPITool(connector, options) {
     const toolName = options?.toolName ?? `${sanitizeToolName(connector.name)}_api`;
     const userId = options?.userId;
@@ -39870,6 +41166,7 @@ var ConnectorTools = class {
       },
       execute: async (args, context) => {
         const effectiveUserId = context?.userId ?? userId;
+        const effectiveAccountId = context?.accountId;
         let url2 = args.endpoint;
         if (args.queryParams && Object.keys(args.queryParams).length > 0) {
           const params = new URLSearchParams();
@@ -39902,7 +41199,8 @@ var ConnectorTools = class {
               },
               body: bodyStr
             },
-            effectiveUserId
+            effectiveUserId,
+            effectiveAccountId
           );
           const text = await response.text();
           let data;
@@ -39963,8 +41261,8 @@ var FileStorage = class {
   }
   async ensureDirectory() {
     try {
-      await fs18__namespace.mkdir(this.directory, { recursive: true });
-      await fs18__namespace.chmod(this.directory, 448);
+      await fs17__namespace.mkdir(this.directory, { recursive: true });
+      await fs17__namespace.chmod(this.directory, 448);
     } catch (error) {
     }
   }
@@ -39978,24 +41276,27 @@ var FileStorage = class {
   async storeToken(key, token) {
     await this.ensureDirectory();
     const filePath = this.getFilePath(key);
-    const plaintext = JSON.stringify(token);
+    const tokenWithKey = { ...token, _storageKey: key };
+    const plaintext = JSON.stringify(tokenWithKey);
     const encrypted = encrypt(plaintext, this.encryptionKey);
-    await fs18__namespace.writeFile(filePath, encrypted, "utf8");
-    await fs18__namespace.chmod(filePath, 384);
+    await fs17__namespace.writeFile(filePath, encrypted, "utf8");
+    await fs17__namespace.chmod(filePath, 384);
   }
   async getToken(key) {
     const filePath = this.getFilePath(key);
     try {
-      const encrypted = await fs18__namespace.readFile(filePath, "utf8");
+      const encrypted = await fs17__namespace.readFile(filePath, "utf8");
       const decrypted = decrypt(encrypted, this.encryptionKey);
-      return JSON.parse(decrypted);
+      const parsed = JSON.parse(decrypted);
+      const { _storageKey, ...token } = parsed;
+      return token;
     } catch (error) {
       if (error.code === "ENOENT") {
         return null;
       }
       console.error("Failed to read/decrypt token file:", error);
       try {
-        await fs18__namespace.unlink(filePath);
+        await fs17__namespace.unlink(filePath);
       } catch {
       }
       return null;
@@ -40004,7 +41305,7 @@ var FileStorage = class {
   async deleteToken(key) {
     const filePath = this.getFilePath(key);
     try {
-      await fs18__namespace.unlink(filePath);
+      await fs17__namespace.unlink(filePath);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -40014,18 +41315,44 @@ var FileStorage = class {
   async hasToken(key) {
     const filePath = this.getFilePath(key);
     try {
-      await fs18__namespace.access(filePath);
+      await fs17__namespace.access(filePath);
       return true;
     } catch {
       return false;
     }
   }
+  /**
+   * List all storage keys by decrypting each token file and reading _storageKey.
+   * Falls back to returning hashed filenames for tokens stored before multi-account support.
+   */
+  async listKeys() {
+    try {
+      const files = await fs17__namespace.readdir(this.directory);
+      const tokenFiles = files.filter((f) => f.endsWith(".token"));
+      const keys = [];
+      for (const file of tokenFiles) {
+        try {
+          const filePath = path2__namespace.join(this.directory, file);
+          const encrypted = await fs17__namespace.readFile(filePath, "utf8");
+          const decrypted = decrypt(encrypted, this.encryptionKey);
+          const parsed = JSON.parse(decrypted);
+          if (parsed._storageKey) {
+            keys.push(parsed._storageKey);
+          }
+        } catch {
+        }
+      }
+      return keys;
+    } catch {
+      return [];
+    }
+  }
   /**
    * List all token keys (for debugging)
    */
   async listTokens() {
     try {
-      const files = await fs18__namespace.readdir(this.directory);
+      const files = await fs17__namespace.readdir(this.directory);
       return files.filter((f) => f.endsWith(".token")).map((f) => f.replace(".token", ""));
     } catch {
       return [];
@@ -40036,10 +41363,10 @@ var FileStorage = class {
    */
   async clearAll() {
     try {
-      const files = await fs18__namespace.readdir(this.directory);
+      const files = await fs17__namespace.readdir(this.directory);
       const tokenFiles = files.filter((f) => f.endsWith(".token"));
       await Promise.all(
-        tokenFiles.map((f) => fs18__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
+        tokenFiles.map((f) => fs17__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
         }))
       );
     } catch {
@@ -40049,14 +41376,14 @@ var FileStorage = class {
 
 // src/connectors/authenticatedFetch.ts
 init_Connector();
-async function authenticatedFetch(url2, options, authProvider, userId) {
+async function authenticatedFetch(url2, options, authProvider, userId, accountId) {
   const connector = exports.Connector.get(authProvider);
-  return connector.fetch(url2.toString(), options, userId);
+  return connector.fetch(url2.toString(), options, userId, accountId);
 }
-function createAuthenticatedFetch(authProvider, userId) {
+function createAuthenticatedFetch(authProvider, userId, accountId) {
   const connector = exports.Connector.get(authProvider);
   return async (url2, options) => {
-    return connector.fetch(url2.toString(), options, userId);
+    return connector.fetch(url2.toString(), options, userId, accountId);
   };
 }
 
@@ -40487,14 +41814,14 @@ var FileConnectorStorage = class {
     await this.ensureDirectory();
     const filePath = this.getFilePath(name);
     const json = JSON.stringify(stored, null, 2);
-    await fs18__namespace.writeFile(filePath, json, "utf8");
-    await fs18__namespace.chmod(filePath, 384);
+    await fs17__namespace.writeFile(filePath, json, "utf8");
+    await fs17__namespace.chmod(filePath, 384);
     await this.updateIndex(name, "add");
   }
   async get(name) {
     const filePath = this.getFilePath(name);
     try {
-      const json = await fs18__namespace.readFile(filePath, "utf8");
+      const json = await fs17__namespace.readFile(filePath, "utf8");
       return JSON.parse(json);
     } catch (error) {
       const err = error;
@@ -40507,7 +41834,7 @@ var FileConnectorStorage = class {
   async delete(name) {
     const filePath = this.getFilePath(name);
     try {
-      await fs18__namespace.unlink(filePath);
+      await fs17__namespace.unlink(filePath);
       await this.updateIndex(name, "remove");
       return true;
     } catch (error) {
@@ -40521,7 +41848,7 @@ var FileConnectorStorage = class {
   async has(name) {
     const filePath = this.getFilePath(name);
     try {
-      await fs18__namespace.access(filePath);
+      await fs17__namespace.access(filePath);
       return true;
     } catch {
       return false;
@@ -40547,13 +41874,13 @@ var FileConnectorStorage = class {
    */
   async clear() {
     try {
-      const files = await fs18__namespace.readdir(this.directory);
+      const files = await fs17__namespace.readdir(this.directory);
       const connectorFiles = files.filter(
         (f) => f.endsWith(".connector.json") || f === "_index.json"
       );
       await Promise.all(
         connectorFiles.map(
-          (f) => fs18__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
+          (f) => fs17__namespace.unlink(path2__namespace.join(this.directory, f)).catch(() => {
           })
         )
       );
@@ -40580,8 +41907,8 @@ var FileConnectorStorage = class {
   async ensureDirectory() {
     if (this.initialized) return;
     try {
-      await fs18__namespace.mkdir(this.directory, { recursive: true });
-      await fs18__namespace.chmod(this.directory, 448);
+      await fs17__namespace.mkdir(this.directory, { recursive: true });
+      await fs17__namespace.chmod(this.directory, 448);
       this.initialized = true;
     } catch {
       this.initialized = true;
@@ -40592,7 +41919,7 @@ var FileConnectorStorage = class {
    */
   async loadIndex() {
     try {
-      const json = await fs18__namespace.readFile(this.indexPath, "utf8");
+      const json = await fs17__namespace.readFile(this.indexPath, "utf8");
       return JSON.parse(json);
     } catch {
       return { connectors: {} };
@@ -40610,8 +41937,8 @@ var FileConnectorStorage = class {
       delete index.connectors[hash];
     }
     const json = JSON.stringify(index, null, 2);
-    await fs18__namespace.writeFile(this.indexPath, json, "utf8");
-    await fs18__namespace.chmod(this.indexPath, 384);
+    await fs17__namespace.writeFile(this.indexPath, json, "utf8");
+    await fs17__namespace.chmod(this.indexPath, 384);
   }
 };
 
@@ -40834,14 +42161,15 @@ var microsoftTemplate = {
       name: "OAuth (Delegated Permissions)",
       type: "oauth",
       flow: "authorization_code",
-      description: "User signs in with Microsoft account. Best for accessing user data (mail, calendar, files)",
-      requiredFields: ["clientId", "clientSecret", "redirectUri", "tenantId"],
-      optionalFields: ["scope"],
+      description: "User signs in with Microsoft account. Best for accessing user data (mail, calendar, files). Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri", "tenantId"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/authorize",
-        tokenUrl: "https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/token"
+        tokenUrl: "https://login.microsoftonline.com/{tenantId}/oauth2/v2.0/token",
+        usePKCE: true
       },
       scopes: [
         "User.Read",
@@ -40927,14 +42255,15 @@ var googleTemplate = {
       name: "OAuth (User Consent)",
       type: "oauth",
       flow: "authorization_code",
-      description: "User logs in with Google account. Best for accessing user data (Drive, Gmail, Calendar)",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "User logs in with Google account. Best for accessing user data (Drive, Gmail, Calendar). Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth",
-        tokenUrl: "https://oauth2.googleapis.com/token"
+        tokenUrl: "https://oauth2.googleapis.com/token",
+        usePKCE: true
       },
       scopes: [
         "https://www.googleapis.com/auth/drive",
@@ -41013,14 +42342,15 @@ var slackTemplate = {
       name: "OAuth (User Token)",
       type: "oauth",
       flow: "authorization_code",
-      description: "Distributed app - users authorize via Slack OAuth",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope", "userScope"],
+      description: "Distributed app - users authorize via Slack OAuth. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope", "userScope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://slack.com/oauth/v2/authorize",
-        tokenUrl: "https://slack.com/api/oauth.v2.access"
+        tokenUrl: "https://slack.com/api/oauth.v2.access",
+        usePKCE: true
       },
       scopes: ["chat:write", "channels:read", "users:read", "im:write", "groups:read", "files:read", "files:write", "reactions:read", "reactions:write", "team:read"],
       scopeDescriptions: {
@@ -41066,14 +42396,15 @@ var discordTemplate = {
       name: "OAuth (User Token)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth2 for user authorization - users grant permissions to your app",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth2 for user authorization - users grant permissions to your app. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://discord.com/api/oauth2/authorize",
-        tokenUrl: "https://discord.com/api/oauth2/token"
+        tokenUrl: "https://discord.com/api/oauth2/token",
+        usePKCE: true
       },
       scopes: ["identify", "email", "guilds", "guilds.members.read", "messages.read", "bot", "connections"],
       scopeDescriptions: {
@@ -41115,6 +42446,92 @@ var telegramTemplate = {
   ]
 };
 
+// src/connectors/vendors/templates/twitter.ts
+var twitterTemplate = {
+  id: "twitter",
+  name: "X (Twitter)",
+  serviceType: "twitter",
+  baseURL: "https://api.x.com/2",
+  docsURL: "https://developer.x.com/en/docs/x-api",
+  credentialsSetupURL: "https://developer.x.com/en/portal/dashboard",
+  category: "communication",
+  notes: "X (formerly Twitter) API v2. OAuth 2.0 with PKCE for user-context actions, Bearer Token for app-only access.",
+  authTemplates: [
+    {
+      id: "oauth-user",
+      name: "OAuth 2.0 (User Context)",
+      type: "oauth",
+      flow: "authorization_code",
+      description: "User authorizes via X login - required for posting tweets, managing likes/follows, and accessing private data. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
+      defaults: {
+        type: "oauth",
+        flow: "authorization_code",
+        authorizationUrl: "https://x.com/i/oauth2/authorize",
+        tokenUrl: "https://api.x.com/2/oauth2/token",
+        usePKCE: true
+      },
+      scopes: [
+        "tweet.read",
+        "tweet.write",
+        "tweet.moderate.write",
+        "users.read",
+        "follows.read",
+        "follows.write",
+        "like.read",
+        "like.write",
+        "bookmark.read",
+        "bookmark.write",
+        "list.read",
+        "list.write",
+        "block.read",
+        "block.write",
+        "mute.read",
+        "mute.write",
+        "space.read",
+        "dm.read",
+        "dm.write",
+        "offline.access"
+      ],
+      scopeDescriptions: {
+        "tweet.read": "Read tweets and timelines",
+        "tweet.write": "Post and delete tweets",
+        "tweet.moderate.write": "Hide and unhide replies",
+        "users.read": "Read user profile information",
+        "follows.read": "Read following/followers lists",
+        "follows.write": "Follow and unfollow users",
+        "like.read": "Read liked tweets",
+        "like.write": "Like and unlike tweets",
+        "bookmark.read": "Read bookmarked tweets",
+        "bookmark.write": "Bookmark and remove bookmarks",
+        "list.read": "Read lists",
+        "list.write": "Create, edit, and delete lists",
+        "block.read": "Read blocked users",
+        "block.write": "Block and unblock users",
+        "mute.read": "Read muted users",
+        "mute.write": "Mute and unmute users",
+        "space.read": "Read Spaces information",
+        "dm.read": "Read direct messages",
+        "dm.write": "Send direct messages",
+        "offline.access": "Stay connected (refresh token)"
+      }
+    },
+    {
+      id: "bearer-token",
+      name: "Bearer Token (App-Only)",
+      type: "api_key",
+      description: "App-only access using Bearer Token from developer portal. Can read public tweets, users, and spaces but cannot post or access private data.",
+      requiredFields: ["apiKey"],
+      defaults: {
+        type: "api_key",
+        headerName: "Authorization",
+        headerPrefix: "Bearer"
+      }
+    }
+  ]
+};
+
 // src/connectors/vendors/templates/github.ts
 var githubTemplate = {
   id: "github",
@@ -41142,14 +42559,15 @@ var githubTemplate = {
       name: "OAuth App (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "User logs in via GitHub and grants permissions to your app",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "User logs in via GitHub and grants permissions to your app. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://github.com/login/oauth/authorize",
-        tokenUrl: "https://github.com/login/oauth/access_token"
+        tokenUrl: "https://github.com/login/oauth/access_token",
+        usePKCE: true
       },
       scopes: ["repo", "read:user", "user:email", "read:org", "workflow", "gist", "notifications", "delete_repo", "admin:org"],
       scopeDescriptions: {
@@ -41208,14 +42626,15 @@ var gitlabTemplate = {
       name: "OAuth (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth2 application for user authorization",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth2 application for user authorization. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://gitlab.com/oauth/authorize",
-        tokenUrl: "https://gitlab.com/oauth/token"
+        tokenUrl: "https://gitlab.com/oauth/token",
+        usePKCE: true
       },
       scopes: ["api", "read_user", "read_repository", "write_repository"],
       scopeDescriptions: {
@@ -41256,14 +42675,15 @@ var jiraTemplate = {
       name: "OAuth 2.0 (3LO)",
       type: "oauth",
       flow: "authorization_code",
-      description: "Three-legged OAuth for user authorization. Create app at developer.atlassian.com",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "Three-legged OAuth for user authorization. Create app at developer.atlassian.com. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://auth.atlassian.com/authorize",
-        tokenUrl: "https://auth.atlassian.com/oauth/token"
+        tokenUrl: "https://auth.atlassian.com/oauth/token",
+        usePKCE: true
       },
       scopes: ["read:jira-work", "write:jira-work", "read:jira-user", "manage:jira-project", "manage:jira-configuration"],
       scopeDescriptions: {
@@ -41303,14 +42723,15 @@ var confluenceTemplate = {
       name: "OAuth 2.0 (3LO)",
       type: "oauth",
       flow: "authorization_code",
-      description: "Three-legged OAuth for user authorization",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "Three-legged OAuth for user authorization. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://auth.atlassian.com/authorize",
-        tokenUrl: "https://auth.atlassian.com/oauth/token"
+        tokenUrl: "https://auth.atlassian.com/oauth/token",
+        usePKCE: true
       },
       scopes: ["read:confluence-content.all", "write:confluence-content", "read:confluence-space.summary", "write:confluence-space", "read:confluence-user"],
       scopeDescriptions: {
@@ -41349,14 +42770,15 @@ var bitbucketTemplate = {
       name: "OAuth Consumer",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth consumer for user authorization. Create at Workspace Settings > OAuth consumers",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth consumer for user authorization. Create at Workspace Settings > OAuth consumers. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://bitbucket.org/site/oauth2/authorize",
-        tokenUrl: "https://bitbucket.org/site/oauth2/access_token"
+        tokenUrl: "https://bitbucket.org/site/oauth2/access_token",
+        usePKCE: true
       },
       scopes: ["repository", "repository:write", "pullrequest", "pullrequest:write", "account", "pipeline", "wiki"],
       scopeDescriptions: {
@@ -41398,14 +42820,15 @@ var trelloTemplate = {
       name: "OAuth 1.0a",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth 1.0a for user authorization (legacy)",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth 1.0a for user authorization (legacy). Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://trello.com/1/authorize",
-        tokenUrl: "https://trello.com/1/OAuthGetAccessToken"
+        tokenUrl: "https://trello.com/1/OAuthGetAccessToken",
+        usePKCE: true
       },
       scopes: ["read", "write", "account"],
       scopeDescriptions: {
@@ -41445,14 +42868,15 @@ var linearTemplate = {
       name: "OAuth (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth application for user authorization. Create at Settings > API > OAuth applications",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth application for user authorization. Create at Settings > API > OAuth applications. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://linear.app/oauth/authorize",
-        tokenUrl: "https://api.linear.app/oauth/token"
+        tokenUrl: "https://api.linear.app/oauth/token",
+        usePKCE: true
       },
       scopes: ["read", "write", "issues:create", "comments:create"]
     }
@@ -41486,14 +42910,15 @@ var asanaTemplate = {
       name: "OAuth (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth application for user authorization. Create at developer console",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth application for user authorization. Create at developer console. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://app.asana.com/-/oauth_authorize",
-        tokenUrl: "https://app.asana.com/-/oauth_token"
+        tokenUrl: "https://app.asana.com/-/oauth_token",
+        usePKCE: true
       },
       scopes: ["default"]
     }
@@ -41527,14 +42952,15 @@ var notionTemplate = {
       name: "Public Integration (OAuth)",
       type: "oauth",
       flow: "authorization_code",
-      description: "Public integration for multi-workspace access",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "Public integration for multi-workspace access. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://api.notion.com/v1/oauth/authorize",
-        tokenUrl: "https://api.notion.com/v1/oauth/token"
+        tokenUrl: "https://api.notion.com/v1/oauth/token",
+        usePKCE: true
       }
     }
   ]
@@ -41567,9 +42993,9 @@ var airtableTemplate = {
       name: "OAuth (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth integration for multi-user access. Register at airtable.com/create/oauth",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth integration for multi-user access. Register at airtable.com/create/oauth. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
@@ -41598,14 +43024,15 @@ var salesforceTemplate = {
       name: "OAuth (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "User logs in via Salesforce. Create Connected App in Setup",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "User logs in via Salesforce. Create Connected App in Setup. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://login.salesforce.com/services/oauth2/authorize",
-        tokenUrl: "https://login.salesforce.com/services/oauth2/token"
+        tokenUrl: "https://login.salesforce.com/services/oauth2/token",
+        usePKCE: true
       },
       scopes: ["api", "refresh_token", "offline_access", "chatter_api", "wave_api", "full"],
       scopeDescriptions: {
@@ -41661,14 +43088,15 @@ var hubspotTemplate = {
       name: "OAuth (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "Public app OAuth for multi-portal access. Create app at developers.hubspot.com",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "Public app OAuth for multi-portal access. Create app at developers.hubspot.com. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://app.hubspot.com/oauth/authorize",
-        tokenUrl: "https://api.hubapi.com/oauth/v1/token"
+        tokenUrl: "https://api.hubapi.com/oauth/v1/token",
+        usePKCE: true
       },
       scopes: [
         "crm.objects.contacts.read",
@@ -41690,6 +43118,22 @@ var hubspotTemplate = {
         "tickets": "Read and write support tickets",
         "e-commerce": "Access e-commerce data (products, line items)"
       }
+    },
+    {
+      id: "oauth-mcp",
+      name: "MCP Auth App (OAuth 2.1)",
+      type: "oauth",
+      flow: "authorization_code",
+      description: "HubSpot MCP Auth app using OAuth 2.1 with PKCE. Scopes are auto-granted based on user permissions at install time. Create app at developers.hubspot.com under MCP Auth Apps.",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret"],
+      defaults: {
+        type: "oauth",
+        flow: "authorization_code",
+        authorizationUrl: "https://mcp.hubspot.com/oauth/authorize/user",
+        tokenUrl: "https://mcp.hubspot.com/oauth/v1/token",
+        usePKCE: true
+      }
     }
   ]
 };
@@ -41721,14 +43165,15 @@ var pipedriveTemplate = {
       name: "OAuth (App Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth app for marketplace distribution. Create at developers.pipedrive.com",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth app for marketplace distribution. Create at developers.pipedrive.com. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://oauth.pipedrive.com/oauth/authorize",
-        tokenUrl: "https://oauth.pipedrive.com/oauth/token"
+        tokenUrl: "https://oauth.pipedrive.com/oauth/token",
+        usePKCE: true
       }
     }
   ]
@@ -41761,14 +43206,15 @@ var stripeTemplate = {
       name: "OAuth (Stripe Connect)",
       type: "oauth",
       flow: "authorization_code",
-      description: "Stripe Connect for marketplace platforms. Requires Connect setup in dashboard",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "Stripe Connect for marketplace platforms. Requires Connect setup in dashboard. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://connect.stripe.com/oauth/authorize",
-        tokenUrl: "https://connect.stripe.com/oauth/token"
+        tokenUrl: "https://connect.stripe.com/oauth/token",
+        usePKCE: true
       },
       scopes: ["read_write"]
     }
@@ -41818,14 +43264,15 @@ var quickbooksTemplate = {
       name: "OAuth (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "Standard OAuth 2.0 flow for accessing QuickBooks on behalf of a user. Create an app at developer.intuit.com",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "Standard OAuth 2.0 flow for accessing QuickBooks on behalf of a user. Create an app at developer.intuit.com. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://appcenter.intuit.com/connect/oauth2",
-        tokenUrl: "https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer"
+        tokenUrl: "https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer",
+        usePKCE: true
       },
       scopes: ["com.intuit.quickbooks.accounting", "com.intuit.quickbooks.payment"]
     }
@@ -41860,14 +43307,15 @@ var rampTemplate = {
       name: "OAuth (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth 2.0 authorization code flow for accessing Ramp on behalf of a user",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth 2.0 authorization code flow for accessing Ramp on behalf of a user. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://app.ramp.com/v1/authorize",
-        tokenUrl: "https://api.ramp.com/developer/v1/token"
+        tokenUrl: "https://api.ramp.com/developer/v1/token",
+        usePKCE: true
       },
       scopes: [
         "transactions:read",
@@ -41924,9 +43372,9 @@ var dropboxTemplate = {
       name: "OAuth (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth app for user authorization. Create app at dropbox.com/developers/apps",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth app for user authorization. Create app at dropbox.com/developers/apps. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
@@ -41963,14 +43411,15 @@ var boxTemplate = {
       name: "OAuth (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth 2.0 for user authorization. Create app at developer.box.com/console",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth 2.0 for user authorization. Create app at developer.box.com/console. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://account.box.com/api/oauth2/authorize",
-        tokenUrl: "https://api.box.com/oauth2/token"
+        tokenUrl: "https://api.box.com/oauth2/token",
+        usePKCE: true
       },
       scopes: ["root_readwrite", "manage_users", "manage_groups", "manage_enterprise"],
       scopeDescriptions: {
@@ -42048,13 +43497,15 @@ var mailchimpTemplate = {
       name: "OAuth (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth for multi-account access. Register app at mailchimp.com/developer",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
+      description: "OAuth for multi-account access. Register app at mailchimp.com/developer. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://login.mailchimp.com/oauth2/authorize",
-        tokenUrl: "https://login.mailchimp.com/oauth2/token"
+        tokenUrl: "https://login.mailchimp.com/oauth2/token",
+        usePKCE: true
       }
     }
   ]
@@ -42146,14 +43597,15 @@ var pagerdutyTemplate = {
       name: "OAuth (App Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth app for multi-account access. Register at developer.pagerduty.com",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth app for multi-account access. Register at developer.pagerduty.com. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://app.pagerduty.com/oauth/authorize",
-        tokenUrl: "https://app.pagerduty.com/oauth/token"
+        tokenUrl: "https://app.pagerduty.com/oauth/token",
+        usePKCE: true
       },
       scopes: ["read", "write"],
       scopeDescriptions: {
@@ -42189,14 +43641,15 @@ var sentryTemplate = {
       name: "OAuth (Integration)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth integration. Create at Organization Settings > Integrations",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
-      optionalFields: ["scope"],
+      description: "OAuth integration. Create at Organization Settings > Integrations. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://sentry.io/oauth/authorize/",
-        tokenUrl: "https://sentry.io/oauth/token/"
+        tokenUrl: "https://sentry.io/oauth/token/",
+        usePKCE: true
       },
       scopes: ["project:read", "project:write", "event:read", "org:read", "member:read"],
       scopeDescriptions: {
@@ -42393,14 +43846,15 @@ var zendeskTemplate = {
       name: "OAuth (User Authorization)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth client for user authorization. Create at Admin > Channels > API > OAuth Clients",
-      requiredFields: ["clientId", "clientSecret", "redirectUri", "subdomain"],
-      optionalFields: ["scope"],
+      description: "OAuth client for user authorization. Create at Admin > Channels > API > OAuth Clients. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri", "subdomain"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://{subdomain}.zendesk.com/oauth/authorizations/new",
-        tokenUrl: "https://{subdomain}.zendesk.com/oauth/tokens"
+        tokenUrl: "https://{subdomain}.zendesk.com/oauth/tokens",
+        usePKCE: true
       },
       scopes: ["read", "write", "tickets:read", "tickets:write"],
       scopeDescriptions: {
@@ -42438,13 +43892,15 @@ var intercomTemplate = {
       name: "OAuth (App Installation)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth for Intercom app marketplace distribution",
-      requiredFields: ["clientId", "clientSecret", "redirectUri"],
+      description: "OAuth for Intercom app marketplace distribution. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri"],
+      optionalFields: ["clientSecret"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://app.intercom.com/oauth",
-        tokenUrl: "https://api.intercom.io/auth/eagle/token"
+        tokenUrl: "https://api.intercom.io/auth/eagle/token",
+        usePKCE: true
       }
     }
   ]
@@ -42477,14 +43933,15 @@ var shopifyTemplate = {
       name: "OAuth (Public/Custom App)",
       type: "oauth",
       flow: "authorization_code",
-      description: "OAuth for public apps or per-store custom apps. Create at partners.shopify.com",
-      requiredFields: ["clientId", "clientSecret", "redirectUri", "subdomain"],
-      optionalFields: ["scope"],
+      description: "OAuth for public apps or per-store custom apps. Create at partners.shopify.com. Provide clientSecret for web apps; omit for native/desktop apps (secured via PKCE).",
+      requiredFields: ["clientId", "redirectUri", "subdomain"],
+      optionalFields: ["clientSecret", "scope"],
       defaults: {
         type: "oauth",
         flow: "authorization_code",
         authorizationUrl: "https://{subdomain}.myshopify.com/admin/oauth/authorize",
-        tokenUrl: "https://{subdomain}.myshopify.com/admin/oauth/access_token"
+        tokenUrl: "https://{subdomain}.myshopify.com/admin/oauth/access_token",
+        usePKCE: true
       },
       scopes: ["read_products", "write_products", "read_orders", "write_orders", "read_customers", "write_customers", "read_inventory", "write_inventory", "read_fulfillments", "write_fulfillments"],
       scopeDescriptions: {
@@ -42512,6 +43969,7 @@ var allVendorTemplates = [
   slackTemplate,
   discordTemplate,
   telegramTemplate,
+  twitterTemplate,
   // Development
   githubTemplate,
   gitlabTemplate,
@@ -42571,6 +44029,7 @@ var VENDOR_ICON_MAP = {
   discord: "discord",
   slack: "slack",
   telegram: "telegram",
+  twitter: "x",
   "microsoft-teams": "microsoftteams",
   // CRM
   salesforce: "salesforce",
@@ -42635,6 +44094,7 @@ var FALLBACK_PLACEHOLDERS = {
   // Communication (trademark removed)
   slack: { color: "#4A154B", letter: "S" },
   "microsoft-teams": { color: "#6264A7", letter: "T" },
+  twitter: { color: "#000000", letter: "X" },
   // CRM (trademark removed)
   salesforce: { color: "#00A1E0", letter: "S" },
   pipedrive: { color: "#1A1F26", letter: "P" },
@@ -43572,7 +45032,7 @@ EXAMPLES:
         };
       }
       try {
-        const stats = await fs18.stat(resolvedPath);
+        const stats = await fs17.stat(resolvedPath);
         if (!stats.isFile()) {
           return {
             success: false,
@@ -43614,7 +45074,7 @@ EXAMPLES:
           } catch {
           }
         }
-        const content = await fs18.readFile(resolvedPath, "utf-8");
+        const content = await fs17.readFile(resolvedPath, "utf-8");
         const allLines = content.split("\n");
         const totalLines = allLines.length;
         const startIndex = Math.max(0, offset - 1);
@@ -43723,9 +45183,9 @@ EXAMPLES:
       try {
         const parentDir = path2.dirname(resolvedPath);
         if (!fs19.existsSync(parentDir)) {
-          await fs18.mkdir(parentDir, { recursive: true });
+          await fs17.mkdir(parentDir, { recursive: true });
         }
-        await fs18.writeFile(resolvedPath, content, "utf-8");
+        await fs17.writeFile(resolvedPath, content, "utf-8");
         return {
           success: true,
           path: file_path,
@@ -43836,7 +45296,7 @@ EXAMPLES:
         };
       }
       try {
-        const content = await fs18.readFile(resolvedPath, "utf-8");
+        const content = await fs17.readFile(resolvedPath, "utf-8");
         let occurrences = 0;
         let searchIndex = 0;
         while (true) {
@@ -43875,7 +45335,7 @@ EXAMPLES:
         } else {
           newContent = content.replace(old_string, new_string);
         }
-        await fs18.writeFile(resolvedPath, newContent, "utf-8");
+        await fs17.writeFile(resolvedPath, newContent, "utf-8");
         const diffPreview = generateDiffPreview(old_string, new_string);
         return {
           success: true,
@@ -43931,7 +45391,7 @@ async function findFiles(dir, pattern, baseDir, config, results = [], depth = 0)
     return results;
   }
   try {
-    const entries = await fs18.readdir(dir, { withFileTypes: true });
+    const entries = await fs17.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (results.length >= config.maxResults) break;
       const fullPath = path2.join(dir, entry.name);
@@ -43945,7 +45405,7 @@ async function findFiles(dir, pattern, baseDir, config, results = [], depth = 0)
       } else if (entry.isFile()) {
         if (matchGlobPattern(pattern, relativePath)) {
           try {
-            const stats = await fs18.stat(fullPath);
+            const stats = await fs17.stat(fullPath);
             results.push({
               path: relativePath,
               mtime: stats.mtimeMs
@@ -44082,7 +45542,7 @@ async function findFilesToSearch(dir, baseDir, config, globPattern, fileType, fi
     return files;
   }
   try {
-    const entries = await fs18.readdir(dir, { withFileTypes: true });
+    const entries = await fs17.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path2.join(dir, entry.name);
       if (entry.isDirectory()) {
@@ -44115,7 +45575,7 @@ async function findFilesToSearch(dir, baseDir, config, globPattern, fileType, fi
 async function searchFile(filePath, regex, contextBefore, contextAfter) {
   const matches = [];
   try {
-    const content = await fs18.readFile(filePath, "utf-8");
+    const content = await fs17.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i] ?? "";
@@ -44272,7 +45732,7 @@ WHEN TO USE:
         };
       }
       try {
-        const stats = await fs18.stat(resolvedPath);
+        const stats = await fs17.stat(resolvedPath);
         let filesToSearch;
         if (stats.isFile()) {
           filesToSearch = [resolvedPath];
@@ -44360,7 +45820,7 @@ async function listDir(dir, baseDir, config, recursive, filter, maxDepth = 3, cu
     return entries;
   }
   try {
-    const dirEntries = await fs18.readdir(dir, { withFileTypes: true });
+    const dirEntries = await fs17.readdir(dir, { withFileTypes: true });
     for (const entry of dirEntries) {
       if (entries.length >= config.maxResults) break;
       const fullPath = path2.join(dir, entry.name);
@@ -44378,7 +45838,7 @@ async function listDir(dir, baseDir, config, recursive, filter, maxDepth = 3, cu
       }
       if (filter === "directories" && !isDir) continue;
       try {
-        const stats = await fs18.stat(fullPath);
+        const stats = await fs17.stat(fullPath);
         const dirEntry = {
           name: entry.name,
           path: relativePath,
@@ -44481,7 +45941,7 @@ EXAMPLES:
         };
       }
       try {
-        const stats = await fs18.stat(resolvedPath);
+        const stats = await fs17.stat(resolvedPath);
         if (!stats.isDirectory()) {
           return {
             success: false,
@@ -45804,21 +47264,53 @@ registerWebTools();
 init_Connector();
 var DEFAULT_TIMEOUT = 1e4;
 var DEFAULT_MAX_TIMEOUT = 3e4;
-function formatConnectorEntry(c) {
+function formatConnectorEntry(c, accountId) {
   const parts = [];
   const serviceOrVendor = c.serviceType ?? c.vendor ?? void 0;
   if (serviceOrVendor) parts.push(`Service: ${serviceOrVendor}`);
+  if (accountId) parts.push(`Account: "${accountId}"`);
   if (c.config.description) parts.push(c.config.description);
   if (c.baseURL) parts.push(`URL: ${c.baseURL}`);
+  const label = accountId ? `"${c.name}" account "${accountId}"` : `"${c.name}"`;
   const details = parts.map((p) => `     ${p}`).join("\n");
-  return `   \u2022 "${c.name}" (${c.displayName})
+  return `   \u2022 ${label} (${c.displayName})
 ${details}`;
 }
-function generateDescription(context, maxTimeout) {
+function buildIdentityList(context) {
+  const identities = context?.identities;
   const registry = context?.connectorRegistry ?? exports.Connector.asRegistry();
+  if (identities?.length) {
+    const entries = [];
+    for (const id of identities) {
+      try {
+        const connector = registry.get(id.connector);
+        entries.push(formatConnectorEntry(connector, id.accountId));
+      } catch {
+        entries.push(`   \u2022 "${id.connector}"${id.accountId ? ` account "${id.accountId}"` : ""} \u2014 not available`);
+      }
+    }
+    return entries.length > 0 ? entries.join("\n\n") : "   No connectors registered.";
+  }
   const connectors = registry.listAll();
-  const connectorList = connectors.length > 0 ? connectors.map(formatConnectorEntry).join("\n\n") : "   No connectors registered.";
+  return connectors.length > 0 ? connectors.map((c) => formatConnectorEntry(c)).join("\n\n") : "   No connectors registered.";
+}
+function hasAccountIds(context) {
+  return !!context?.identities?.some((id) => id.accountId);
+}
+function generateDescription(context, maxTimeout) {
+  const connectorList = buildIdentityList(context);
+  const showAccountId = hasAccountIds(context);
   const timeoutSec = Math.round(maxTimeout / 1e3);
+  const accountIdParam = showAccountId ? `
+     \u2022 accountId (optional): Account alias for multi-account connectors.
+       Required when a connector has multiple accounts (see list below).
+       Example: authenticatedFetch('/v1.0/me', {}, 'microsoft', 'work')` : "";
+  const accountIdExamples = showAccountId ? `
+// Multi-account: specify accountId for connectors with multiple accounts
+const resp = await authenticatedFetch('/v1.0/me', { method: 'GET' }, 'microsoft', 'work');
+const profile = await resp.json();
+output = profile;
+` : "";
   return `Execute JavaScript code in a secure sandbox with authenticated API access to external services.
 
 Use this tool when you need to:
@@ -45829,7 +47321,7 @@ Use this tool when you need to:
 
 SANDBOX API:
 
-1. authenticatedFetch(url, options, connectorName)
+1. authenticatedFetch(url, options, connectorName${showAccountId ? ", accountId?" : ""})
    Makes authenticated HTTP requests using the connector's credentials.
    The current user's identity (userId) is automatically included \u2014 no need to pass it.
    Auth headers are added automatically \u2014 DO NOT set Authorization header manually.
@@ -45840,7 +47332,7 @@ SANDBOX API:
        - Relative: "/user/repos" (resolved against connector's base URL)
      \u2022 options: Standard fetch options { method, headers, body }
        - For POST/PUT: set body to JSON.stringify(data) and headers to { 'Content-Type': 'application/json' }
-     \u2022 connectorName: Name of a registered connector (see list below)
+     \u2022 connectorName: Name of a registered connector (see list below)${accountIdParam}
 
    Returns: Promise<Response>
      \u2022 response.ok \u2014 true if status 200-299
@@ -45876,7 +47368,7 @@ const resp = await authenticatedFetch('/chat.postMessage', {
   body: JSON.stringify({ channel: '#general', text: 'Hello!' })
 }, 'slack');
 output = await resp.json();
-
+${accountIdExamples}
 // Data processing (no API needed)
 const items = input.data;
 output = items.filter(i => i.score > 0.8).sort((a, b) => b.score - a.score);
@@ -45964,9 +47456,10 @@ async function executeInVM(code, input, timeout, logs, userId, registry) {
     },
     // Authenticated fetch — userId auto-injected from ToolContext.
     // Only connectors visible in the scoped registry are accessible.
-    authenticatedFetch: (url2, options, connectorName) => {
+    // Optional 4th param accountId for multi-account OAuth identities.
+    authenticatedFetch: (url2, options, connectorName, accountId) => {
       registry.get(connectorName);
-      return authenticatedFetch(url2, options, connectorName, userId);
+      return authenticatedFetch(url2, options, connectorName, userId, accountId);
     },
     // Standard fetch (no auth)
     fetch: globalThis.fetch,
@@ -46654,7 +48147,8 @@ async function githubFetch(connector, endpoint, options) {
       headers,
       body: options?.body ? JSON.stringify(options.body) : void 0
     },
-    options?.userId
+    options?.userId,
+    options?.accountId
   );
   const text = await response.text();
   let data;
@@ -46736,6 +48230,7 @@ EXAMPLES:
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       const resolved = resolveRepository(args.repository, connector);
       if (!resolved.success) {
         return { success: false, error: resolved.error };
@@ -46747,7 +48242,7 @@ EXAMPLES:
           const repoInfo = await githubFetch(
             connector,
             `/repos/${owner}/${repo}`,
-            { userId: effectiveUserId }
+            { userId: effectiveUserId, accountId: effectiveAccountId }
           );
           ref = repoInfo.default_branch;
         }
@@ -46847,6 +48342,7 @@ EXAMPLES:
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       const resolved = resolveRepository(args.repository, connector);
       if (!resolved.success) {
         return { success: false, error: resolved.error };
@@ -46864,6 +48360,7 @@ EXAMPLES:
           `/search/code`,
           {
             userId: effectiveUserId,
+            accountId: effectiveAccountId,
             // Request text-match fragments
             accept: "application/vnd.github.text-match+json",
             queryParams: { q, per_page: perPage }
@@ -46952,6 +48449,7 @@ NOTE: Files larger than 1MB are fetched via the Git Blob API. Very large files (
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       const resolved = resolveRepository(args.repository, connector);
       if (!resolved.success) {
         return { success: false, error: resolved.error };
@@ -46965,7 +48463,7 @@ NOTE: Files larger than 1MB are fetched via the Git Blob API. Very large files (
         const contentResp = await githubFetch(
           connector,
           `/repos/${owner}/${repo}/contents/${args.path}${refParam}`,
-          { userId: effectiveUserId }
+          { userId: effectiveUserId, accountId: effectiveAccountId }
         );
         if (contentResp.type !== "file") {
           return {
@@ -46982,7 +48480,7 @@ NOTE: Files larger than 1MB are fetched via the Git Blob API. Very large files (
           const blob = await githubFetch(
             connector,
             contentResp.git_url,
-            { userId: effectiveUserId }
+            { userId: effectiveUserId, accountId: effectiveAccountId }
           );
           fileContent = Buffer.from(blob.content, "base64").toString("utf-8");
           fileSize = blob.size;
@@ -47071,6 +48569,7 @@ EXAMPLES:
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       const resolved = resolveRepository(args.repository, connector);
       if (!resolved.success) {
         return { success: false, error: resolved.error };
@@ -47080,7 +48579,7 @@ EXAMPLES:
         const pr = await githubFetch(
           connector,
           `/repos/${owner}/${repo}/pulls/${args.pull_number}`,
-          { userId: effectiveUserId }
+          { userId: effectiveUserId, accountId: effectiveAccountId }
         );
         return {
           success: true,
@@ -47158,6 +48657,7 @@ NOTE: Very large diffs may be truncated by GitHub. Patch content may be absent f
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       const resolved = resolveRepository(args.repository, connector);
       if (!resolved.success) {
         return { success: false, error: resolved.error };
@@ -47169,6 +48669,7 @@ NOTE: Very large diffs may be truncated by GitHub. Patch content may be absent f
           `/repos/${owner}/${repo}/pulls/${args.pull_number}/files`,
           {
             userId: effectiveUserId,
+            accountId: effectiveAccountId,
             queryParams: { per_page: 100 }
           }
         );
@@ -47241,6 +48742,7 @@ EXAMPLES:
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       const resolved = resolveRepository(args.repository, connector);
       if (!resolved.success) {
         return { success: false, error: resolved.error };
@@ -47248,7 +48750,7 @@ EXAMPLES:
       const { owner, repo } = resolved.repo;
       try {
         const basePath = `/repos/${owner}/${repo}`;
-        const queryOpts = { userId: effectiveUserId, queryParams: { per_page: 100 } };
+        const queryOpts = { userId: effectiveUserId, accountId: effectiveAccountId, queryParams: { per_page: 100 } };
         const [reviewComments, reviews, issueComments] = await Promise.all([
           githubFetch(
             connector,
@@ -47377,6 +48879,7 @@ EXAMPLES:
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       const resolved = resolveRepository(args.repository, connector);
       if (!resolved.success) {
         return { success: false, error: resolved.error };
@@ -47389,6 +48892,7 @@ EXAMPLES:
           {
             method: "POST",
             userId: effectiveUserId,
+            accountId: effectiveAccountId,
             body: {
               title: args.title,
               body: args.body,
@@ -47480,7 +48984,8 @@ async function microsoftFetch(connector, endpoint, options) {
       headers,
       body: options?.body ? JSON.stringify(options.body) : void 0
     },
-    options?.userId
+    options?.userId,
+    options?.accountId
   );
   const text = await response.text();
   if (!response.ok) {
@@ -47533,7 +49038,7 @@ function isTeamsMeetingUrl(input) {
     return false;
   }
 }
-async function resolveMeetingId(connector, input, prefix, effectiveUserId) {
+async function resolveMeetingId(connector, input, prefix, effectiveUserId, effectiveAccountId) {
   if (!input || input.trim().length === 0) {
     throw new Error("Meeting ID cannot be empty");
   }
@@ -47546,6 +49051,7 @@ async function resolveMeetingId(connector, input, prefix, effectiveUserId) {
     `${prefix}/onlineMeetings`,
     {
       userId: effectiveUserId,
+      accountId: effectiveAccountId,
       queryParams: { "$filter": `JoinWebUrl eq '${trimmed}'` }
     }
   );
@@ -47624,13 +49130,14 @@ EXAMPLES:
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       try {
         const prefix = getUserPathPrefix(connector, args.targetUser);
         if (args.replyToMessageId) {
           const replyDraft = await microsoftFetch(
             connector,
             `${prefix}/messages/${args.replyToMessageId}/createReply`,
-            { method: "POST", userId: effectiveUserId, body: {} }
+            { method: "POST", userId: effectiveUserId, accountId: effectiveAccountId, body: {} }
           );
           const updated = await microsoftFetch(
             connector,
@@ -47638,6 +49145,7 @@ EXAMPLES:
             {
               method: "PATCH",
               userId: effectiveUserId,
+              accountId: effectiveAccountId,
               body: {
                 subject: args.subject,
                 body: { contentType: "HTML", content: args.body },
@@ -47658,6 +49166,7 @@ EXAMPLES:
           {
             method: "POST",
             userId: effectiveUserId,
+            accountId: effectiveAccountId,
             body: {
               isDraft: true,
               subject: args.subject,
@@ -47746,6 +49255,7 @@ EXAMPLES:
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       try {
         const prefix = getUserPathPrefix(connector, args.targetUser);
         if (args.replyToMessageId) {
@@ -47755,6 +49265,7 @@ EXAMPLES:
             {
               method: "POST",
               userId: effectiveUserId,
+              accountId: effectiveAccountId,
               body: {
                 message: {
                   toRecipients: formatRecipients(args.to),
@@ -47771,6 +49282,7 @@ EXAMPLES:
             {
               method: "POST",
               userId: effectiveUserId,
+              accountId: effectiveAccountId,
               body: {
                 message: {
                   subject: args.subject,
@@ -47870,6 +49382,7 @@ EXAMPLES:
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       try {
         const prefix = getUserPathPrefix(connector, args.targetUser);
         const tz = args.timeZone ?? "UTC";
@@ -47892,7 +49405,7 @@ EXAMPLES:
         const event = await microsoftFetch(
           connector,
           `${prefix}/events`,
-          { method: "POST", userId: effectiveUserId, body: eventBody }
+          { method: "POST", userId: effectiveUserId, accountId: effectiveAccountId, body: eventBody }
         );
         return {
           success: true,
@@ -47996,6 +49509,7 @@ EXAMPLES:
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       try {
         const prefix = getUserPathPrefix(connector, args.targetUser);
         const tz = args.timeZone ?? "UTC";
@@ -48019,7 +49533,7 @@ EXAMPLES:
         const event = await microsoftFetch(
           connector,
           `${prefix}/events/${args.eventId}`,
-          { method: "PATCH", userId: effectiveUserId, body: patchBody }
+          { method: "PATCH", userId: effectiveUserId, accountId: effectiveAccountId, body: patchBody }
         );
         return {
           success: true,
@@ -48092,14 +49606,15 @@ EXAMPLES:
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       try {
         const prefix = getUserPathPrefix(connector, args.targetUser);
-        const resolved = await resolveMeetingId(connector, args.meetingId, prefix, effectiveUserId);
+        const resolved = await resolveMeetingId(connector, args.meetingId, prefix, effectiveUserId, effectiveAccountId);
         const meetingId = resolved.meetingId;
         const transcriptList = await microsoftFetch(
           connector,
           `${prefix}/onlineMeetings/${meetingId}/transcripts`,
-          { userId: effectiveUserId }
+          { userId: effectiveUserId, accountId: effectiveAccountId }
         );
         if (!transcriptList.value || transcriptList.value.length === 0) {
           return {
@@ -48112,7 +49627,8 @@ EXAMPLES:
         const response = await connector.fetch(
           contentUrl + "?$format=text/vtt",
           { method: "GET", headers: { "Accept": "text/vtt" } },
-          effectiveUserId
+          effectiveUserId,
+          effectiveAccountId
         );
         if (!response.ok) {
           const errorText = await response.text();
@@ -48204,6 +49720,7 @@ EXAMPLES:
     },
     execute: async (args, context) => {
       const effectiveUserId = context?.userId ?? userId;
+      const effectiveAccountId = context?.accountId;
       try {
         const prefix = getUserPathPrefix(connector, args.targetUser);
         const tz = args.timeZone ?? "UTC";
@@ -48213,6 +49730,7 @@ EXAMPLES:
           {
             method: "POST",
             userId: effectiveUserId,
+            accountId: effectiveAccountId,
             body: {
               attendees: formatAttendees(args.attendees),
               timeConstraint: {
@@ -49141,27 +50659,42 @@ var customToolDelete = createCustomToolDelete();
 
 // src/tools/custom-tools/sandboxDescription.ts
 init_Connector();
-function formatConnectorEntry2(c) {
+function formatConnectorEntry2(c, accountId) {
   const parts = [];
   const serviceOrVendor = c.serviceType ?? c.vendor ?? void 0;
   if (serviceOrVendor) parts.push(`Service: ${serviceOrVendor}`);
+  if (accountId) parts.push(`Account: "${accountId}"`);
   if (c.config.description) parts.push(c.config.description);
   if (c.baseURL) parts.push(`URL: ${c.baseURL}`);
+  const label = accountId ? `"${c.name}" account "${accountId}"` : `"${c.name}"`;
   const details = parts.map((p) => `     ${p}`).join("\n");
-  return `   \u2022 "${c.name}" (${c.displayName})
+  return `   \u2022 ${label} (${c.displayName})
 ${details}`;
 }
 function buildConnectorList(context) {
+  const identities = context?.identities;
   const registry = context?.connectorRegistry ?? exports.Connector.asRegistry();
+  if (identities?.length) {
+    const entries = [];
+    for (const id of identities) {
+      try {
+        const connector = registry.get(id.connector);
+        entries.push(formatConnectorEntry2(connector, id.accountId));
+      } catch {
+        entries.push(`   \u2022 "${id.connector}"${id.accountId ? ` account "${id.accountId}"` : ""} \u2014 not available`);
+      }
+    }
+    return entries.length > 0 ? entries.join("\n\n") : "   No connectors registered.";
+  }
   const connectors = registry.listAll();
   if (connectors.length === 0) {
     return "   No connectors registered.";
   }
-  return connectors.map(formatConnectorEntry2).join("\n\n");
+  return connectors.map((c) => formatConnectorEntry2(c)).join("\n\n");
 }
 var SANDBOX_API_REFERENCE = `SANDBOX API (available inside custom tool code):
 
-1. authenticatedFetch(url, options, connectorName)
+1. authenticatedFetch(url, options, connectorName, accountId?)
    Makes authenticated HTTP requests using the connector's credentials.
    Auth headers are added automatically \u2014 DO NOT set Authorization header manually.
 
@@ -49172,6 +50705,7 @@ var SANDBOX_API_REFERENCE = `SANDBOX API (available inside custom tool code):
      \u2022 options: Standard fetch options { method, headers, body }
        - For POST/PUT: set body to JSON.stringify(data) and headers to { 'Content-Type': 'application/json' }
      \u2022 connectorName: Name of a registered connector (see REGISTERED CONNECTORS below)
+     \u2022 accountId (optional): Account alias for multi-account connectors (e.g., 'work', 'personal')
 
    Returns: Promise<Response>
      \u2022 response.ok \u2014 true if status 200-299
@@ -50343,6 +51877,7 @@ exports.ProviderError = ProviderError;
 exports.ProviderErrorMapper = ProviderErrorMapper;
 exports.ProviderNotFoundError = ProviderNotFoundError;
 exports.ProviderRateLimitError = ProviderRateLimitError;
+exports.ROUTINE_KEYS = ROUTINE_KEYS;
 exports.RapidAPIProvider = RapidAPIProvider;
 exports.RateLimitError = RateLimitError;
 exports.SERVICE_DEFINITIONS = SERVICE_DEFINITIONS;
@@ -50500,6 +52035,7 @@ exports.findConnectorByServiceTypes = findConnectorByServiceTypes;
 exports.forPlan = forPlan;
 exports.forTasks = forTasks;
 exports.formatAttendees = formatAttendees;
+exports.formatPluginDisplayName = formatPluginDisplayName;
 exports.formatRecipients = formatRecipients;
 exports.generateEncryptionKey = generateEncryptionKey;
 exports.generateSimplePlan = generateSimplePlan;
@@ -50568,6 +52104,8 @@ exports.isErrorEvent = isErrorEvent;
 exports.isExcludedExtension = isExcludedExtension;
 exports.isKnownService = isKnownService;
 exports.isOutputTextDelta = isOutputTextDelta;
+exports.isReasoningDelta = isReasoningDelta;
+exports.isReasoningDone = isReasoningDone;
 exports.isResponseComplete = isResponseComplete;
 exports.isSimpleScope = isSimpleScope;
 exports.isStreamEvent = isStreamEvent;
@@ -50604,6 +52142,7 @@ exports.resolveMaxContextTokens = resolveMaxContextTokens;
 exports.resolveMeetingId = resolveMeetingId;
 exports.resolveModelCapabilities = resolveModelCapabilities;
 exports.resolveRepository = resolveRepository;
+exports.resolveTemplates = resolveTemplates;
 exports.retryWithBackoff = retryWithBackoff;
 exports.sanitizeToolName = sanitizeToolName;
 exports.scopeEquals = scopeEquals;