nolo-cli 0.33.0-alpha.3 → 0.33.0-alpha.31

package/{chunk-X664KVEV.js → chunk-HHBXCRJS.js}

@@ -2,16 +2,16 @@ import {
   getAllServers,
   getIsDesktopApp,
   isAbortError
-} from "./chunk-WJSW43QZ.js";
+} from "./chunk-L3JWI7WX.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
 import {
   asOptionalPositiveFiniteNumber
 } from "./chunk-U6VC4MU4.js";
-import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
 import {
   API_ENDPOINTS,
   SERVERS,
@@ -28,104 +28,27 @@ import {
 } from "./chunk-G3SUCT4W.js";
 
 // node_modules/reselect/dist/reselect.mjs
-var runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {
-  if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {
-    let isInputSameAsOutput = false;
-    try {
-      const emptyObject = {};
-      if (resultFunc(emptyObject) === emptyObject) isInputSameAsOutput = true;
-    } catch {
-    }
-    if (isInputSameAsOutput) {
-      let stack = void 0;
-      try {
-        throw new Error();
-      } catch (e) {
-        ;
-        ({ stack } = e);
-      }
-      console.warn(
-        "The result function returned its own inputs without modification. e.g\n`createSelector([state => state.todos], todos => todos)`\nThis could lead to inefficient memoization and unnecessary re-renders.\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.",
-        { stack }
-      );
-    }
-  }
-};
-var runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {
-  const { memoize, memoizeOptions } = options;
-  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;
-  const createAnEmptyObject = memoize(() => ({}), ...memoizeOptions);
-  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);
-  if (!areInputSelectorResultsEqual) {
-    let stack = void 0;
-    try {
-      throw new Error();
-    } catch (e) {
-      ;
-      ({ stack } = e);
-    }
-    console.warn(
-      "An input selector returned a different result when passed same arguments.\nThis means your output selector will likely run more frequently than intended.\nAvoid returning a new reference inside your input selector, e.g.\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`",
-      {
-        arguments: inputSelectorArgs,
-        firstInputs: inputSelectorResults,
-        secondInputs: inputSelectorResultsCopy,
-        stack
-      }
-    );
-  }
+var CACHE_SIZE_CHECK_THRESHOLD = 1e3;
+var runCacheSizeCheck = (cacheSize, funcName) => {
+  let stack = void 0;
+  try {
+    throw new Error();
+  } catch (e) {
+    ;
+    ({ stack } = e);
+  }
+  console.warn(
+    `A function memoized with weakMapMemoize${funcName ? ` (\`${funcName}\`)` : ""} has seen over ${cacheSize} distinct values for the same primitive argument position.
+Results keyed by primitive arguments are held strongly and are only released by \`clearCache()\`, so this cache will keep growing for as long as the function keeps seeing new values.
+If it is called with ever-changing primitives (ids, offsets, timestamps), pass the \`maxSize\` option to bound the cache, switch to \`lruMemoize\`, or call \`.clearCache()\` at a suitable point.
+See https://reselect.js.org/api/development-only-checks#cachesizecheck for details.`,
+    { stack }
+  );
 };
 var globalDevModeChecks = {
   inputStabilityCheck: "once",
-  identityFunctionCheck: "once"
-};
-function assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {
-  if (typeof func !== "function") {
-    throw new TypeError(errorMessage);
-  }
-}
-function assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {
-  if (!array.every((item) => typeof item === "function")) {
-    const itemTypes = array.map(
-      (item) => typeof item === "function" ? `function ${item.name || "unnamed"}()` : typeof item
-    ).join(", ");
-    throw new TypeError(`${errorMessage}[${itemTypes}]`);
-  }
-}
-var ensureIsArray = (item) => {
-  return Array.isArray(item) ? item : [item];
-};
-function getDependencies(createSelectorArgs) {
-  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;
-  assertIsArrayOfFunctions(
-    dependencies,
-    `createSelector expects all input-selectors to be functions, but received the following types: `
-  );
-  return dependencies;
-}
-function collectInputSelectorResults(dependencies, inputSelectorArgs) {
-  const inputSelectorResults = [];
-  const { length } = dependencies;
-  for (let i = 0; i < length; i++) {
-    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));
-  }
-  return inputSelectorResults;
-}
-var getDevModeChecksExecutionInfo = (firstRun, devModeChecks) => {
-  const { identityFunctionCheck, inputStabilityCheck } = {
-    ...globalDevModeChecks,
-    ...devModeChecks
-  };
-  return {
-    identityFunctionCheck: {
-      shouldRun: identityFunctionCheck === "always" || identityFunctionCheck === "once" && firstRun,
-      run: runIdentityFunctionCheck
-    },
-    inputStabilityCheck: {
-      shouldRun: inputStabilityCheck === "always" || inputStabilityCheck === "once" && firstRun,
-      run: runInputStabilityCheck
-    }
-  };
+  identityFunctionCheck: "once",
+  cacheSizeCheck: "once"
 };
 var StrongRef = class {
   constructor(value) {
@@ -155,9 +78,25 @@ function maybeDeref(r) {
 }
 function weakMapMemoize(func, options = {}) {
   let fnNode = createCacheNode();
-  const { resultEqualityCheck } = options;
+  const { resultEqualityCheck, maxSize } = options;
+  const useGenerations = maxSize !== void 0;
+  if (useGenerations && (!Number.isInteger(maxSize) || maxSize < 1)) {
+    throw new TypeError(
+      `maxSize must be a positive integer, received: ${maxSize}`
+    );
+  }
+  let prevNode = null;
+  let insertionCount = 0;
   let lastResult;
   let resultsCount = 0;
+  let hasWarnedAboutCacheSize = false;
+  function maybeFlipGenerations() {
+    if (insertionCount >= maxSize) {
+      prevNode = fnNode;
+      fnNode = createCacheNode();
+      insertionCount = 0;
+    }
+  }
   function memoized() {
     let cacheNode = fnNode;
     const { length } = arguments;
@@ -184,35 +123,77 @@ function weakMapMemoize(func, options = {}) {
         if (primitiveNode === void 0) {
           cacheNode = createCacheNode();
           primitiveCache.set(arg, cacheNode);
+          insertionCount++;
+          if (process.env.NODE_ENV !== "production") {
+            if (primitiveCache.size > CACHE_SIZE_CHECK_THRESHOLD) {
+              const { cacheSizeCheck } = globalDevModeChecks;
+              if (cacheSizeCheck === "always" || cacheSizeCheck === "once" && !hasWarnedAboutCacheSize) {
+                hasWarnedAboutCacheSize = true;
+                runCacheSizeCheck(primitiveCache.size, func.name);
+              }
+            }
+          }
         } else {
           cacheNode = primitiveNode;
         }
       }
     }
-    const terminatedNode = cacheNode;
-    let result;
     if (cacheNode.s === TERMINATED) {
-      result = cacheNode.v;
-    } else {
-      result = func.apply(null, arguments);
-      resultsCount++;
-      if (resultEqualityCheck) {
-        const lastResultValue = maybeDeref(lastResult);
-        if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {
-          result = lastResultValue;
-          resultsCount !== 0 && resultsCount--;
+      return cacheNode.v;
+    }
+    if (prevNode !== null) {
+      let prevCacheNode = prevNode;
+      for (let i = 0, l = length; i < l; i++) {
+        const arg = arguments[i];
+        let next;
+        if (typeof arg === "function" || typeof arg === "object" && arg !== null) {
+          const prevObjectCache = prevCacheNode.o;
+          next = prevObjectCache !== null ? prevObjectCache.get(arg) : void 0;
+        } else {
+          const prevPrimitiveCache = prevCacheNode.p;
+          next = prevPrimitiveCache !== null ? prevPrimitiveCache.get(arg) : void 0;
+        }
+        if (next === void 0) {
+          prevCacheNode = null;
+          break;
         }
-        const needsWeakRef = typeof result === "object" && result !== null || typeof result === "function";
-        lastResult = needsWeakRef ? /* @__PURE__ */ new Ref(result) : result;
+        prevCacheNode = next;
+      }
+      if (prevCacheNode !== null && prevCacheNode.s === TERMINATED) {
+        const promotedNode = cacheNode;
+        promotedNode.s = TERMINATED;
+        promotedNode.v = prevCacheNode.v;
+        maybeFlipGenerations();
+        return prevCacheNode.v;
       }
     }
+    const terminatedNode = cacheNode;
+    let result = func.apply(null, arguments);
+    resultsCount++;
+    if (resultEqualityCheck) {
+      const lastResultValue = maybeDeref(lastResult);
+      if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {
+        result = lastResultValue;
+        resultsCount !== 0 && resultsCount--;
+      }
+      const needsWeakRef = typeof result === "object" && result !== null || typeof result === "function";
+      lastResult = needsWeakRef ? /* @__PURE__ */ new Ref(result) : result;
+    }
     terminatedNode.s = TERMINATED;
     terminatedNode.v = result;
+    if (useGenerations) {
+      maybeFlipGenerations();
+    }
     return result;
   }
   memoized.clearCache = () => {
     fnNode = createCacheNode();
+    prevNode = null;
+    insertionCount = 0;
     memoized.resetResultsCount();
+    if (process.env.NODE_ENV !== "production") {
+      hasWarnedAboutCacheSize = false;
+    }
   };
   memoized.resultsCount = () => resultsCount;
   memoized.resetResultsCount = () => {
@@ -220,6 +201,98 @@ function weakMapMemoize(func, options = {}) {
   };
   return memoized;
 }
+var runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {
+  if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {
+    let isInputSameAsOutput = false;
+    try {
+      const emptyObject = {};
+      if (resultFunc(emptyObject) === emptyObject) isInputSameAsOutput = true;
+    } catch {
+    }
+    if (isInputSameAsOutput) {
+      let stack = void 0;
+      try {
+        throw new Error();
+      } catch (e) {
+        ;
+        ({ stack } = e);
+      }
+      console.warn(
+        "The result function returned its own inputs without modification. e.g\n`createSelector([state => state.todos], todos => todos)`\nThis could lead to inefficient memoization and unnecessary re-renders.\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.",
+        { stack }
+      );
+    }
+  }
+};
+var withoutResultEqualityCheck = (option) => {
+  if (option === null || typeof option !== "object" || !("resultEqualityCheck" in option)) {
+    return option;
+  }
+  const optionCopy = { ...option };
+  delete optionCopy.resultEqualityCheck;
+  return optionCopy;
+};
+var runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {
+  const { memoize, memoizeOptions } = options;
+  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;
+  const probeMemoizeOptions = [];
+  const { length } = memoizeOptions;
+  for (let i = 0; i < length; i++) {
+    probeMemoizeOptions.push(withoutResultEqualityCheck(memoizeOptions[i]));
+  }
+  const createAnEmptyObject = memoize(() => ({}), ...probeMemoizeOptions);
+  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);
+  if (!areInputSelectorResultsEqual) {
+    let stack = void 0;
+    try {
+      throw new Error();
+    } catch (e) {
+      ;
+      ({ stack } = e);
+    }
+    console.warn(
+      "An input selector returned a different result when passed same arguments.\nThis means your output selector will likely run more frequently than intended.\nAvoid returning a new reference inside your input selector, e.g.\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`",
+      {
+        arguments: inputSelectorArgs,
+        firstInputs: inputSelectorResults,
+        secondInputs: inputSelectorResultsCopy,
+        stack
+      }
+    );
+  }
+};
+function assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {
+  if (typeof func !== "function") {
+    throw new TypeError(errorMessage);
+  }
+}
+function assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {
+  if (!array.every((item) => typeof item === "function")) {
+    const itemTypes = array.map(
+      (item) => typeof item === "function" ? `function ${item.name || "unnamed"}()` : typeof item
+    ).join(", ");
+    throw new TypeError(`${errorMessage}[${itemTypes}]`);
+  }
+}
+var ensureIsArray = (item) => {
+  return Array.isArray(item) ? item : [item];
+};
+function getDependencies(createSelectorArgs) {
+  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;
+  assertIsArrayOfFunctions(
+    dependencies,
+    `createSelector expects all input-selectors to be functions, but received the following types: `
+  );
+  return dependencies;
+}
+function collectInputSelectorResults(dependencies, inputSelectorArgs) {
+  const inputSelectorResults = [];
+  const { length } = dependencies;
+  for (let i = 0; i < length; i++) {
+    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));
+  }
+  return inputSelectorResults;
+}
 function createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {
   const createSelectorCreatorOptions = typeof memoizeOrOptions === "function" ? {
     memoize: memoizeOrOptions,
@@ -262,27 +335,35 @@ function createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {
     let firstRun = true;
     const selector = argsMemoize(function dependenciesChecker() {
       dependencyRecomputations++;
-      const inputSelectorResults = collectInputSelectorResults(
-        dependencies,
-        arguments
-      );
+      const { length } = dependencies;
+      const inputSelectorResults = new Array(length);
+      for (let i = 0; i < length; i++) {
+        inputSelectorResults[i] = dependencies[i].apply(null, arguments);
+      }
       lastResult = memoizedResultFunc.apply(null, inputSelectorResults);
       if (process.env.NODE_ENV !== "production") {
-        const { devModeChecks = {} } = combinedOptions;
-        const { identityFunctionCheck, inputStabilityCheck } = getDevModeChecksExecutionInfo(firstRun, devModeChecks);
-        if (identityFunctionCheck.shouldRun) {
-          identityFunctionCheck.run(
+        const { devModeChecks } = combinedOptions;
+        const identityFunctionCheck = devModeChecks !== void 0 && Object.prototype.hasOwnProperty.call(
+          devModeChecks,
+          "identityFunctionCheck"
+        ) ? devModeChecks.identityFunctionCheck : globalDevModeChecks.identityFunctionCheck;
+        const inputStabilityCheck = devModeChecks !== void 0 && Object.prototype.hasOwnProperty.call(
+          devModeChecks,
+          "inputStabilityCheck"
+        ) ? devModeChecks.inputStabilityCheck : globalDevModeChecks.inputStabilityCheck;
+        if (identityFunctionCheck === "always" || identityFunctionCheck === "once" && firstRun) {
+          runIdentityFunctionCheck(
             resultFunc,
             inputSelectorResults,
             lastResult
           );
         }
-        if (inputStabilityCheck.shouldRun) {
+        if (inputStabilityCheck === "always" || inputStabilityCheck === "once" && firstRun) {
           const inputSelectorResultsCopy = collectInputSelectorResults(
             dependencies,
             arguments
           );
-          inputStabilityCheck.run(
+          runInputStabilityCheck(
             { inputSelectorResults, inputSelectorResultsCopy },
             { memoize, memoizeOptions: finalMemoizeOptions },
             arguments

package/chunk-HJ23CUHW.js

@@ -0,0 +1,109 @@
+import {
+  mergeAvailabilityDeadline
+} from "./chunk-QUK7UZW7.js";
+
+// packages/cli/credentialAvailability.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+var FILE_NAME = "credential-availability.json";
+function resolveNoloHome(env = process.env) {
+  return env.NOLO_HOME?.trim() || join(homedir(), ".nolo");
+}
+function resolveCredentialAvailabilityPath(env = process.env) {
+  return join(resolveNoloHome(env), FILE_NAME);
+}
+function resolveCredentialKey(agent) {
+  if (!agent || typeof agent !== "object") return void 0;
+  for (const field of ["apiKeyRef", "credentialRef"]) {
+    const value = agent[field];
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed) return trimmed;
+    }
+  }
+  return void 0;
+}
+function parseFile(raw) {
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object") return { entries: {} };
+  const entries = parsed.entries;
+  if (!entries || typeof entries !== "object") return { entries: {} };
+  return { entries };
+}
+async function readCredentialAvailability(env = process.env, now = Date.now()) {
+  const path = resolveCredentialAvailabilityPath(env);
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch {
+    return {};
+  }
+  let file;
+  try {
+    file = parseFile(raw);
+  } catch {
+    return {};
+  }
+  const live = {};
+  for (const [key, entry] of Object.entries(file.entries)) {
+    const at = entry?.nextAvailableAt;
+    if (typeof at === "number" && Number.isFinite(at) && at > now) {
+      live[key] = at;
+    }
+  }
+  return live;
+}
+async function writeCredentialAvailability(live, env = process.env) {
+  const path = resolveCredentialAvailabilityPath(env);
+  await mkdir(resolveNoloHome(env), { recursive: true }).catch(() => void 0);
+  const file = {
+    entries: Object.fromEntries(
+      Object.entries(live).map(([key, at]) => [key, { nextAvailableAt: at }])
+    )
+  };
+  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile(tmp, `${JSON.stringify(file, null, 2)}
+`, "utf8");
+  await rename(tmp, path);
+}
+async function markCredentialUnavailable(credentialKey, nextAvailableAt, env = process.env, now = Date.now()) {
+  if (!credentialKey) return;
+  const live = await readCredentialAvailability(env, now);
+  const merged = mergeAvailabilityDeadline(live[credentialKey], nextAvailableAt);
+  if (typeof merged !== "number" || !Number.isFinite(merged)) return;
+  live[credentialKey] = merged;
+  await writeCredentialAvailability(live, env);
+}
+async function clearCredentialAvailability(credentialKey, env = process.env, now = Date.now()) {
+  if (!credentialKey) return;
+  const live = await readCredentialAvailability(env, now);
+  if (!(credentialKey in live)) return;
+  delete live[credentialKey];
+  await writeCredentialAvailability(live, env);
+}
+function applyCredentialAvailability(agents, credentialAvailability) {
+  if (Object.keys(credentialAvailability).length === 0) return agents;
+  return agents.map((agent) => {
+    const key = resolveCredentialKey(agent);
+    if (!key) return agent;
+    const at = credentialAvailability[key];
+    if (typeof at !== "number") return agent;
+    const merged = mergeAvailabilityDeadline(
+      agent.nextAvailableAt,
+      at
+    );
+    if (typeof merged !== "number" || merged === agent.nextAvailableAt) {
+      return agent;
+    }
+    return { ...agent, nextAvailableAt: merged };
+  });
+}
+
+export {
+  resolveCredentialKey,
+  readCredentialAvailability,
+  markCredentialUnavailable,
+  clearCredentialAvailability,
+  applyCredentialAvailability
+};

package/{chunk-RAZOLMJR.js → chunk-HXV5GJFC.js}

@@ -23,7 +23,7 @@ import {
   shouldStripReasoningContentForOutbound,
   toOpenAiCompatibleMessages,
   toResponsesTools
-} from "./chunk-NNWHHCVP.js";
+} from "./chunk-LI6SNQF6.js";
 import {
   buildProviderExecutionPlan,
   canUsePlatformChatProvider,
@@ -32,10 +32,10 @@ import {
   resolvePlatformAuthToken,
   resolvePlatformServerUrl,
   resolveProviderTransportDecision
-} from "./chunk-AFV4FOT2.js";
+} from "./chunk-3GDKZAPT.js";
 import {
   clipCompactText
-} from "./chunk-AOXVOC6D.js";
+} from "./chunk-W2DNU6FK.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
@@ -339,15 +339,22 @@ async function* readSseFrames(response) {
     const { done, value } = await reader.read();
     if (done) break;
     buffer += decoder.decode(value, { stream: true });
-    let boundary = buffer.indexOf("\n\n");
-    while (boundary !== -1) {
-      yield buffer.slice(0, boundary);
-      buffer = buffer.slice(boundary + 2);
-      boundary = buffer.indexOf("\n\n");
+    let boundary = findSseFrameBoundary(buffer);
+    while (boundary) {
+      yield buffer.slice(0, boundary.index);
+      buffer = buffer.slice(boundary.index + boundary.separatorLength);
+      boundary = findSseFrameBoundary(buffer);
     }
   }
   if (buffer.trim()) yield buffer;
 }
+function findSseFrameBoundary(buffer) {
+  const lfLf = buffer.indexOf("\n\n");
+  const crLfCrLf = buffer.indexOf("\r\n\r\n");
+  if (lfLf === -1 && crLfCrLf === -1) return null;
+  const useLf = lfLf !== -1 && (crLfCrLf === -1 || lfLf < crLfCrLf);
+  return useLf ? { index: lfLf, separatorLength: 2 } : { index: crLfCrLf, separatorLength: 4 };
+}
 async function* streamSseDataValues(response, parse) {
   const reader = response.body?.getReader();
   if (!reader) return;