nolo-cli 0.158.0-alpha.1 → 0.158.0

package/{chunk-SUKSWFLP.js → chunk-PIG2IUVZ.js}

@@ -4,7 +4,7 @@ import {
   resolvePlatformHostedCredentialProvider,
   resolvePlatformProxyChatGatewayEndpoint,
   resolvePlatformResponsesEndpoint
-} from "./chunk-I2RMFLLH.js";
+} from "./chunk-V7PCFWX3.js";
 import {
   CLI_PROVIDER_VALUES
 } from "./chunk-5BHQICF2.js";

package/{chunk-6MXDOUMH.js → chunk-R4BMKAR5.js}

@@ -1,7 +1,8 @@
 import {
   mergeAvailabilityDeadline,
+  resolveCredentialCandidateKeys,
   resolveCredentialKeyWithFallback
-} from "./chunk-3MZAGMYY.js";
+} from "./chunk-JLR5NWP2.js";
 
 // packages/agent-runtime/credentialAvailability.ts
 import { homedir } from "node:os";
@@ -66,10 +67,56 @@ async function readCredentialAvailability(env = process.env, now = Date.now()) {
     Object.entries(entries).map(([key, entry]) => [key, entry.nextAvailableAt])
   );
 }
-async function readCredentialEntry(credentialKey, env = process.env, now = Date.now()) {
+async function readEffectiveCredentialEntry(credentialKey, env = process.env, now = Date.now()) {
   if (!credentialKey) return void 0;
+  const candidates = resolveCredentialCandidateKeys(credentialKey);
+  if (candidates.length === 0) return void 0;
   const entries = await readCredentialEntries(env, now);
-  return entries[credentialKey];
+  let effectiveEntry;
+  const activeCandidates = [];
+  for (const key of candidates) {
+    const entry = entries[key];
+    if (!entry || entry.nextAvailableAt <= now) continue;
+    activeCandidates.push({ key, markedAt: entry.markedAt });
+    if (!effectiveEntry) {
+      effectiveEntry = { ...entry, matchedKey: key };
+    } else {
+      const mergedDeadline = mergeAvailabilityDeadline(
+        effectiveEntry.nextAvailableAt,
+        entry.nextAvailableAt
+      );
+      const mergedProbe = effectiveEntry.lastProbeAt !== void 0 || entry.lastProbeAt !== void 0 ? Math.max(effectiveEntry.lastProbeAt ?? 0, entry.lastProbeAt ?? 0) : void 0;
+      const mergedMarkedAt = effectiveEntry.markedAt !== void 0 || entry.markedAt !== void 0 ? Math.max(effectiveEntry.markedAt ?? 0, entry.markedAt ?? 0) : void 0;
+      effectiveEntry = {
+        nextAvailableAt: mergedDeadline ?? entry.nextAvailableAt,
+        ...mergedMarkedAt !== void 0 ? { markedAt: mergedMarkedAt } : {},
+        ...mergedProbe !== void 0 ? { lastProbeAt: mergedProbe } : {},
+        matchedKey: effectiveEntry.matchedKey
+      };
+    }
+  }
+  if (effectiveEntry) {
+    effectiveEntry.candidates = activeCandidates;
+  }
+  return effectiveEntry;
+}
+function resolveEffectiveCredentialCooldown(credentialKey, credentialAvailability, now = 0) {
+  if (!credentialKey) return void 0;
+  const candidates = resolveCredentialCandidateKeys(credentialKey);
+  let effective;
+  for (const key of candidates) {
+    const at = credentialAvailability[key];
+    if (typeof at === "number" && Number.isFinite(at) && (now === 0 || at > now)) {
+      effective = mergeAvailabilityDeadline(effective, at);
+    }
+  }
+  return effective;
+}
+async function readCredentialEntry(credentialKey, env = process.env, now = Date.now()) {
+  const effective = await readEffectiveCredentialEntry(credentialKey, env, now);
+  if (!effective) return void 0;
+  const { matchedKey, candidates, ...entry } = effective;
+  return entry;
 }
 async function writeCredentialAvailability(live, env = process.env) {
   const path = resolveCredentialAvailabilityPath(env);
@@ -106,16 +153,30 @@ async function clearCredentialAvailabilityIfMarkedAt(credentialKey, expectedMark
 async function clearCredentialAvailability(credentialKey, env = process.env, now = Date.now()) {
   if (!credentialKey) return;
   const live = await readCredentialEntries(env, now);
-  if (!(credentialKey in live)) return;
-  delete live[credentialKey];
+  const candidates = resolveCredentialCandidateKeys(credentialKey);
+  let changed = false;
+  for (const key of candidates) {
+    if (key in live) {
+      delete live[key];
+      changed = true;
+    }
+  }
+  if (!changed) return;
   await writeCredentialAvailability(live, env);
 }
 async function recordCredentialProbe(credentialKey, env = process.env, now = Date.now()) {
   if (!credentialKey) return;
   const live = await readCredentialEntries(env, now);
-  const existing = live[credentialKey];
+  let targetKey = credentialKey;
+  if (!(targetKey in live)) {
+    const candidates = resolveCredentialCandidateKeys(credentialKey);
+    const found = candidates.find((k) => k in live);
+    if (!found) return;
+    targetKey = found;
+  }
+  const existing = live[targetKey];
   if (!existing) return;
-  live[credentialKey] = { ...existing, lastProbeAt: now };
+  live[targetKey] = { ...existing, lastProbeAt: now };
   await writeCredentialAvailability(live, env);
 }
 function applyCredentialAvailability(agents, credentialAvailability) {
@@ -123,7 +184,7 @@ function applyCredentialAvailability(agents, credentialAvailability) {
   return agents.map((agent) => {
     const key = resolveCredentialKeyWithFallback(agent);
     if (!key) return agent;
-    const at = credentialAvailability[key];
+    const at = resolveEffectiveCredentialCooldown(key, credentialAvailability);
     if (typeof at !== "number") return agent;
     const merged = mergeAvailabilityDeadline(
       agent.nextAvailableAt,
@@ -138,6 +199,7 @@ function applyCredentialAvailability(agents, credentialAvailability) {
 
 export {
   readCredentialAvailability,
+  readEffectiveCredentialEntry,
   readCredentialEntry,
   markCredentialUnavailable,
   clearCredentialAvailabilityIfMarkedAt,