@myagentroam/node 0.9.119 → 0.9.120

package/dist/runner/codex-runner.js

@@ -24,13 +24,11 @@ export class CodexRunner extends AbstractRunner {
     fastEnabled = false;
     environmentFingerprint;
     environmentRuns = new Set();
-    profileCache = new Map();
-    profileCacheTimers = new Map();
-    profileRefreshes = new Map();
+    profileCache;
+    profileCacheVersion;
+    profileCacheTimer;
+    profileRefresh;
     profileClients = new Set();
-    profileKeyByEnvironment = new Map();
-    latestProfileCache;
-    selectedProfileKey;
     profileGeneration = 0;
     constructor(client = new CodexAppServerClient(), profileClientFactory = () => new CodexAppServerClient()) {
         super();
@@ -43,40 +41,39 @@ export class CodexRunner extends AbstractRunner {
             claudeCodeAvailable: capabilities.claudeCode.available,
             openCodeAvailable: capabilities.openCode?.available === true
         }).find((profile) => profile.runner === this.name);
-        return { ...base, models: this.latestProfileCache?.profile.models ?? [] };
+        return { ...base, models: this.profileCache?.profile.models ?? [] };
     }
     cachedProfile(capabilities, environment = {}) {
         const base = this.profile(capabilities);
-        const key = codexEnvironmentFingerprint(environment, capabilities.codex.version);
-        const cached = this.profileCache.get(key);
-        return cached === undefined ? { ...base, models: [] } : cached.profile;
+        return this.profileCache === undefined ||
+            this.profileCacheVersion !== capabilities.codex.version
+            ? { ...base, models: [] }
+            : this.profileCache.profile;
     }
     async refreshProfile(capabilities, workspace, environment = {}, waitForRefresh = false) {
         void workspace;
         const base = this.profile(capabilities);
         if (!capabilities.codex.available)
             return { ...base, models: [] };
-        const key = codexEnvironmentFingerprint(environment, capabilities.codex.version);
-        this.profileKeyByEnvironment.set(codexSecretEnvironmentFingerprint(environment), key);
-        this.selectedProfileKey = key;
+        const version = capabilities.codex.version;
         const now = Date.now();
-        const cached = this.profileCache.get(key);
+        const cached = this.profileCacheVersion === version ? this.profileCache : undefined;
         if (cached?.successful === true && now < cached.fetchedAt + CODEX_MODEL_CACHE_MS)
-            return this.selectCachedProfile(key, cached);
+            return cached.profile;
         if (cached?.successful === true) {
             if (now >= cached.retryAt) {
-                const refresh = this.refreshCodexProfile(key, base, environment);
+                const refresh = this.refreshCodexProfile(version, base, environment);
                 if (waitForRefresh)
                     return refresh;
             }
-            return this.selectCachedProfile(key, cached);
+            return cached.profile;
         }
         if (cached !== undefined && now < cached.retryAt)
             return cached.profile;
-        return this.refreshCodexProfile(key, base, environment);
+        return this.refreshCodexProfile(version, base, environment);
     }
-    refreshCodexProfile(key, base, environment) {
-        const existing = this.profileRefreshes.get(key);
+    refreshCodexProfile(version, base, environment) {
+        const existing = this.profileRefresh;
         if (existing !== undefined)
             return existing;
         const generation = this.profileGeneration;
@@ -88,11 +85,8 @@ export class CodexRunner extends AbstractRunner {
                 successful: true,
                 retryAt: 0
             };
-            if (generation === this.profileGeneration) {
-                this.cacheProfile(key, cache);
-                if (this.selectedProfileKey === key)
-                    this.latestProfileCache = cache;
-            }
+            if (generation === this.profileGeneration)
+                this.cacheProfile(version, cache);
             return cache.profile;
         })
             .catch((error) => {
@@ -101,12 +95,12 @@ export class CodexRunner extends AbstractRunner {
             });
             if (generation !== this.profileGeneration)
                 return { ...base, models: [] };
-            const cached = this.profileCache.get(key);
+            const cached = this.profileCacheVersion === version ? this.profileCache : undefined;
             if (cached !== undefined) {
                 cached.retryAt = Date.now() + CODEX_MODEL_FAILURE_RETRY_MS;
                 return cached.profile;
             }
-            this.cacheProfile(key, {
+            this.cacheProfile(version, {
                 profile: { ...base, models: [] },
                 defaultConfiguration: emptyCodexConfiguration(),
                 fetchedAt: 0,
@@ -115,33 +109,24 @@ export class CodexRunner extends AbstractRunner {
             });
             return { ...base, models: [] };
         })
-            .finally(() => this.profileRefreshes.delete(key));
-        this.profileRefreshes.set(key, refresh);
+            .finally(() => {
+            if (this.profileRefresh === refresh)
+                this.profileRefresh = undefined;
+        });
+        this.profileRefresh = refresh;
         return refresh;
     }
-    selectCachedProfile(key, cached) {
-        if (cached.successful && this.selectedProfileKey === key)
-            this.latestProfileCache = cached;
-        return cached.profile;
-    }
-    cacheProfile(key, cache) {
-        const previousTimer = this.profileCacheTimers.get(key);
-        if (previousTimer !== undefined)
-            clearTimeout(previousTimer);
-        this.profileCache.set(key, cache);
-        const timer = setTimeout(() => {
-            this.profileCacheTimers.delete(key);
-            this.profileCache.delete(key);
-            for (const [environmentKey, profileKey] of this.profileKeyByEnvironment)
-                if (profileKey === key)
-                    this.profileKeyByEnvironment.delete(environmentKey);
-            if (this.selectedProfileKey === key) {
-                this.selectedProfileKey = undefined;
-                this.latestProfileCache = undefined;
-            }
+    cacheProfile(version, cache) {
+        if (this.profileCacheTimer !== undefined)
+            clearTimeout(this.profileCacheTimer);
+        this.profileCache = cache;
+        this.profileCacheVersion = version;
+        this.profileCacheTimer = setTimeout(() => {
+            this.profileCacheTimer = undefined;
+            this.profileCache = undefined;
+            this.profileCacheVersion = undefined;
         }, CODEX_PROFILE_ENTRY_TTL_MS);
-        timer.unref();
-        this.profileCacheTimers.set(key, timer);
+        this.profileCacheTimer.unref();
     }
     async fetchCodexProfile(base, environment) {
         const client = this.profileClientFactory();
@@ -306,11 +291,8 @@ export class CodexRunner extends AbstractRunner {
             profile.models.some((model) => model.id === configuration.model && model.supportedEfforts.includes(configuration.effort)) &&
             profile.accessOptions.some((option) => option.id === configuration.access));
     }
-    profileCacheForEnvironment(environment) {
-        if (environment === undefined)
-            return this.latestProfileCache;
-        const key = this.profileKeyByEnvironment.get(codexSecretEnvironmentFingerprint(environment));
-        return key === undefined ? undefined : this.profileCache.get(key);
+    profileCacheForEnvironment(_environment) {
+        return this.profileCache;
     }
     async resumeExternal(external, context) {
         if (external.runner !== this.name ||
@@ -483,13 +465,12 @@ export class CodexRunner extends AbstractRunner {
             this.client.clearEnvironment();
         this.environmentFingerprint = undefined;
         this.environmentRuns.clear();
-        for (const timer of this.profileCacheTimers.values())
-            clearTimeout(timer);
-        this.profileCacheTimers.clear();
-        this.profileCache.clear();
-        this.profileKeyByEnvironment.clear();
-        this.latestProfileCache = undefined;
-        this.selectedProfileKey = undefined;
+        if (this.profileCacheTimer !== undefined)
+            clearTimeout(this.profileCacheTimer);
+        this.profileCacheTimer = undefined;
+        this.profileCache = undefined;
+        this.profileCacheVersion = undefined;
+        this.profileRefresh = undefined;
     }
     request(method, params) {
         return this.client.request(method, params);
@@ -537,19 +518,6 @@ export class CodexRunner extends AbstractRunner {
 function emptyCodexConfiguration() {
     return { runner: 'codex', model: '', effort: '', access: 'on-request' };
 }
-function codexEnvironmentFingerprint(environment, version) {
-    return createHash('sha256')
-        .update(JSON.stringify({
-        environment: Object.entries(environment).sort(([left], [right]) => left.localeCompare(right)),
-        version: version ?? null
-    }))
-        .digest('base64url');
-}
-function codexSecretEnvironmentFingerprint(environment) {
-    return createHash('sha256')
-        .update(JSON.stringify(Object.entries(environment).sort(([left], [right]) => left.localeCompare(right))))
-        .digest('base64url');
-}
 function codexModelPage(value) {
     if (!isPlainRecord(value) || !Array.isArray(value.data))
         throw new Error('CODEX_MODELS_INVALID');

package/dist/runner/opencode-runner.js

@@ -18,9 +18,9 @@ export class OpenCodeRunner extends AbstractRunner {
     discoveryScope = 'WORKSPACE_REQUIRED';
     contextLimits = new Map();
     contextLimitsExpiresAt = 0;
-    profileCache = new Map();
-    profileRetryAt = new Map();
-    profileRefreshes = new Map();
+    profileCache;
+    profileRetryAt = 0;
+    profileRefresh;
     profileGeneration = 0;
     execution = new Map();
     managedTurns = new Map();
@@ -41,7 +41,7 @@ export class OpenCodeRunner extends AbstractRunner {
     }
     cachedProfile(capabilities, environment = {}) {
         this.pruneProfileCaches(Date.now());
-        const cached = this.profileCache.get(this.environmentFingerprint(environment));
+        const cached = this.profileCache;
         return cached === undefined
             ? this.profile(capabilities)
             : { ...this.profile(capabilities), models: cached.models };
@@ -50,10 +50,9 @@ export class OpenCodeRunner extends AbstractRunner {
         if (capabilities.openCode?.available !== true) {
             return this.profile(capabilities);
         }
-        const cacheKey = this.environmentFingerprint(environment);
         const now = Date.now();
         this.pruneProfileCaches(now);
-        const cached = this.profileCache.get(cacheKey);
+        const cached = this.profileCache;
         if (cached !== undefined && cached.expiresAt > now) {
             nodeLog('runner.opencode.profile.cache-hit', {
                 models: cached.models.length,
@@ -63,24 +62,24 @@ export class OpenCodeRunner extends AbstractRunner {
             this.contextLimitsExpiresAt = cached.expiresAt;
             return { ...this.profile(capabilities), models: cached.models };
         }
-        if (now < (this.profileRetryAt.get(cacheKey) ?? 0))
+        if (now < this.profileRetryAt)
             return cached === undefined
                 ? this.profile(capabilities)
                 : { ...this.profile(capabilities), models: cached.models };
-        const current = this.profileRefreshes.get(cacheKey);
+        const current = this.profileRefresh;
         if (current !== undefined) {
             nodeLog('runner.opencode.profile.single-flight-joined', {});
             return current;
         }
         const generation = this.profileGeneration;
-        const refresh = this.fetchProfile(capabilities, environment, cacheKey, generation, cached).finally(() => {
-            if (this.profileRefreshes.get(cacheKey) === refresh)
-                this.profileRefreshes.delete(cacheKey);
+        const refresh = this.fetchProfile(capabilities, environment, generation, cached).finally(() => {
+            if (this.profileRefresh === refresh)
+                this.profileRefresh = undefined;
         });
-        this.profileRefreshes.set(cacheKey, refresh);
+        this.profileRefresh = refresh;
         return refresh;
     }
-    async fetchProfile(capabilities, environment, cacheKey, generation, stale) {
+    async fetchProfile(capabilities, environment, generation, stale) {
         const client = this.managedClient(environment, 'runner-profile');
         const startedAt = performance.now();
         try {
@@ -92,14 +91,13 @@ export class OpenCodeRunner extends AbstractRunner {
                 return this.profile(capabilities);
             this.contextLimits = contextLimits;
             this.contextLimitsExpiresAt = expiresAt;
-            this.profileCache.set(cacheKey, {
+            this.profileCache = {
                 expiresAt,
                 discardAt: Date.now() + PROFILE_STALE_TTL_MS,
-                environmentFingerprint: cacheKey,
                 models,
                 contextLimits
-            });
-            this.profileRetryAt.delete(cacheKey);
+            };
+            this.profileRetryAt = 0;
             nodeLog('runner.opencode.profile.providers.completed', {
                 models: models.length,
                 durationMs: Math.round(performance.now() - startedAt)
@@ -109,7 +107,7 @@ export class OpenCodeRunner extends AbstractRunner {
         catch {
             if (generation !== this.profileGeneration)
                 return this.profile(capabilities);
-            this.profileRetryAt.set(cacheKey, Date.now() + PROFILE_FAILURE_RETRY_MS);
+            this.profileRetryAt = Date.now() + PROFILE_FAILURE_RETRY_MS;
             nodeLog('runner.opencode.profile.providers.failed', {
                 durationMs: Math.round(performance.now() - startedAt)
             });
@@ -121,10 +119,6 @@ export class OpenCodeRunner extends AbstractRunner {
             ? this.profile(capabilities)
             : { ...this.profile(capabilities), models: stale.models };
     }
-    environmentFingerprint(environment) {
-        const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
-        return createHash('sha256').update(JSON.stringify(entries)).digest('hex');
-    }
     available(capabilities) {
         return capabilities.openCode?.available === true;
     }
@@ -160,21 +154,16 @@ export class OpenCodeRunner extends AbstractRunner {
     }
     cachedModels(environment) {
         this.pruneProfileCaches(Date.now());
-        const fingerprint = this.environmentFingerprint(environment);
-        return [...this.profileCache.values()]
-            .filter((entry) => entry.environmentFingerprint === fingerprint)
-            .flatMap((entry) => entry.models);
+        void environment;
+        return this.profileCache?.models ?? [];
     }
     pruneProfileCaches(now) {
-        for (const [key, entry] of this.profileCache) {
-            if (entry.discardAt > now)
-                continue;
-            this.profileCache.delete(key);
-            this.profileRetryAt.delete(key);
-        }
-        for (const [key, retryAt] of this.profileRetryAt)
-            if (retryAt <= now && !this.profileCache.has(key) && !this.profileRefreshes.has(key))
-                this.profileRetryAt.delete(key);
+        if (this.profileCache !== undefined && this.profileCache.discardAt <= now)
+            this.profileCache = undefined;
+        if (this.profileRetryAt <= now &&
+            this.profileCache === undefined &&
+            this.profileRefresh === undefined)
+            this.profileRetryAt = 0;
     }
     mcpConfiguration(raw, secrets) {
         const servers = super.mcpConfiguration(raw, secrets);
@@ -340,9 +329,9 @@ export class OpenCodeRunner extends AbstractRunner {
             execution.abort.abort();
         this.execution.clear();
         this.managedTurns.clear();
-        this.profileCache.clear();
-        this.profileRefreshes.clear();
-        this.profileRetryAt.clear();
+        this.profileCache = undefined;
+        this.profileRefresh = undefined;
+        this.profileRetryAt = 0;
         this.contextLimits = new Map();
         this.contextLimitsExpiresAt = 0;
         const stopping = [

package/dist/runner/runner-registry.js

@@ -41,6 +41,14 @@ export class RunnerRegistry {
             try {
                 return await runner.refreshProfile(capabilities, workspace, environment, waitForRefresh);
             }
+            catch (error) {
+                nodeLog('runner.profile.refresh.failed', {
+                    runner: runner.name,
+                    workspaceId: workspace?.id,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                return runner.cachedProfile(capabilities, environment);
+            }
             finally {
                 const durationMs = Math.round(performance.now() - startedAt);
                 if (durationMs >= 100)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.119",
+  "version": "0.9.120",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -30,9 +30,9 @@
     "npm": "11.12.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/protocol": "0.9.119",
-    "@myagentroam/agent": "0.9.119",
-    "@myagentroam/code-navigation": "0.9.119"
+    "@myagentroam/agent": "0.9.120",
+    "@myagentroam/code-navigation": "0.9.120",
+    "@myagentroam/protocol": "0.9.120"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"