@cortexkit/opencode-magic-context 0.33.1 → 0.34.1

package/dist/{index-63dq2g4d.js → index-ry8rh8cv.js}

@@ -9,11 +9,46 @@ import {
 // src/shared/models-dev-cache.ts
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+
+// src/shared/harness-provider-map.ts
+var PI_TO_CANONICAL_PROVIDER = {
+  "openai-codex": "openai",
+  "google-antigravity": "google"
+};
+function remapProviderPrefix(ref, map) {
+  if (typeof ref !== "string")
+    return ref;
+  const slash = ref.indexOf("/");
+  if (slash <= 0)
+    return ref;
+  const provider = ref.slice(0, slash);
+  const mapped = map[provider];
+  return mapped ? `${mapped}${ref.slice(slash)}` : ref;
+}
+function piModelRefToCanonical(ref) {
+  return remapProviderPrefix(ref, PI_TO_CANONICAL_PROVIDER);
+}
+
+// src/shared/storage-permissions.ts
+var enforcePrivateStoragePermissions = true;
+function setStoragePrivatePermissionEnforcement(enforce) {
+  enforcePrivateStoragePermissions = enforce;
+}
+function shouldEnforcePrivateStoragePermissions() {
+  return enforcePrivateStoragePermissions;
+}
+
+// src/shared/models-dev-cache.ts
 var MIN_SANE_LIMIT = 20000;
 var MAX_SANE_LIMIT = 3000000;
 function isSaneLimit(limit) {
   return typeof limit === "number" && limit >= MIN_SANE_LIMIT && limit <= MAX_SANE_LIMIT;
 }
+var SEPARATE_OUTPUT_QUOTA_PROVIDERS = new Set(["google", "google-antigravity"]);
+var MIN_PLAUSIBLE_CONTEXT_LIMIT = 1024;
+var OUTPUT_RESERVE_CAP_RATIO = 0.25;
+var outputReserveConfig;
+var reserveClampLogSeen = new Set;
 var apiCache = null;
 var apiLoadedAt = 0;
 var persistSeedLoaded = false;
@@ -30,12 +65,16 @@ function loadPersistedApiCacheOnce() {
     const map = new Map;
     for (const [key, persisted] of Object.entries(obj)) {
       const limit = typeof persisted === "number" ? persisted : persisted.limit;
+      const contextLimit = typeof persisted === "number" ? undefined : persisted.contextLimit;
       const inputLimit = typeof persisted === "number" ? undefined : persisted.inputLimit;
+      const outputLimit = typeof persisted === "number" ? undefined : persisted.outputLimit;
       const vision = typeof persisted === "number" ? false : persisted.vision === true;
-      if (isSaneLimit(limit)) {
+      if (isSaneLimit(contextLimit) || isSaneLimit(limit)) {
         map.set(key, {
-          limit,
+          limit: isSaneLimit(limit) ? limit : undefined,
+          contextLimit: isSaneLimit(contextLimit) ? contextLimit : undefined,
           inputLimit: isSaneLimit(inputLimit) ? inputLimit : undefined,
+          outputLimit: isFinitePositive(outputLimit) ? outputLimit : undefined,
           vision
         });
       }
@@ -54,7 +93,9 @@ function persistApiCache() {
     if (isSaneLimit(value.limit)) {
       obj[key] = {
         limit: value.limit,
+        contextLimit: isSaneLimit(value.contextLimit) ? value.contextLimit : undefined,
         inputLimit: isSaneLimit(value.inputLimit) ? value.inputLimit : undefined,
+        outputLimit: isFinitePositive(value.outputLimit) ? value.outputLimit : undefined,
         vision: value.vision === true
       };
     }
@@ -64,30 +105,95 @@ function persistApiCache() {
     mkdirSync(dir, { recursive: true });
     const target = persistFilePath();
     const tmp = `${target}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify(obj), { encoding: "utf-8", mode: 384 });
+    if (shouldEnforcePrivateStoragePermissions()) {
+      writeFileSync(tmp, JSON.stringify(obj), { encoding: "utf-8", mode: 384 });
+    } else {
+      writeFileSync(tmp, JSON.stringify(obj), { encoding: "utf-8" });
+    }
     renameSync(tmp, target);
   } catch {}
 }
-function resolveLimit(limit) {
+function isFinitePositive(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function modelKeyLookupOrder(providerID, modelID) {
+  const full = `${providerID}/${modelID}`;
+  const canonicalFull = piModelRefToCanonical(full);
+  const candidates = [full, canonicalFull, modelID];
+  const colon = modelID.lastIndexOf(":");
+  if (colon > 0) {
+    const bareModel = modelID.slice(0, colon);
+    const providerBare = `${providerID}/${bareModel}`;
+    candidates.push(providerBare, piModelRefToCanonical(providerBare), bareModel);
+  }
+  return [...new Set(candidates)];
+}
+function configuredOutputReserve(config, providerID, modelID) {
+  if (typeof config === "number")
+    return Number.isFinite(config) && config >= 0 ? config : undefined;
+  if (!config)
+    return;
+  for (const candidate of modelKeyLookupOrder(providerID, modelID)) {
+    const value = config[candidate];
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+      return value;
+  }
+  return Number.isFinite(config.default) && config.default >= 0 ? config.default : undefined;
+}
+function logReserveClampOnce(key, message) {
+  if (reserveClampLogSeen.has(key))
+    return;
+  reserveClampLogSeen.add(key);
+  sessionLog("global", `models-dev-cache: ${message}`);
+}
+function setOutputReserveConfig(config) {
+  outputReserveConfig = config;
+}
+function resolveLimit(limit, providerID, modelID, reserveConfig = outputReserveConfig) {
   if (!limit)
     return;
-  if (typeof limit.input === "number" && limit.input > 0)
-    return limit.input;
-  if (typeof limit.context === "number" && limit.context > 0)
-    return limit.context;
-  return;
+  const context = isFinitePositive(limit.context) ? limit.context : undefined;
+  const input = isFinitePositive(limit.input) ? limit.input : undefined;
+  if (input !== undefined && (context === undefined || input < context))
+    return input;
+  if (context === undefined)
+    return;
+  const configuredReserve = configuredOutputReserve(reserveConfig, providerID, modelID);
+  let reserve;
+  if (configuredReserve !== undefined) {
+    reserve = configuredReserve;
+  } else if (SEPARATE_OUTPUT_QUOTA_PROVIDERS.has(providerID)) {
+    reserve = 0;
+  } else {
+    const output = isFinitePositive(limit.output) ? limit.output : 0;
+    const cap = context * OUTPUT_RESERVE_CAP_RATIO;
+    reserve = Math.min(output, cap);
+    if (output > cap) {
+      logReserveClampOnce(`cap|${providerID}/${modelID}|${context}|${output}`, `output reserve capped at 25% for ${providerID}/${modelID}: ${output} → ${cap}`);
+    }
+  }
+  const floor = Math.max(MIN_PLAUSIBLE_CONTEXT_LIMIT, context * 0.5);
+  const maxReserve = Math.max(0, context - floor);
+  if (reserve > maxReserve) {
+    logReserveClampOnce(`floor|${providerID}/${modelID}|${context}|${reserve}`, `output reserve clamped for ${providerID}/${modelID}: ${reserve} → ${maxReserve} (usable floor ${floor})`);
+    reserve = maxReserve;
+  }
+  return Math.floor(context - reserve);
 }
 function setCachedModelMetadata(cache, key, model) {
-  const limit = resolveLimit(model?.limit);
+  const contextLimit = model?.limit?.context;
   const inputLimit = model?.limit?.input;
-  if (!isSaneLimit(limit)) {
+  const outputLimit = model?.limit?.output;
+  const rawLimit = isSaneLimit(contextLimit) ? contextLimit : isSaneLimit(inputLimit) ? inputLimit : undefined;
+  if (rawLimit === undefined)
     return;
-  }
   const values = [model?.capabilities, model?.modalities, model?.input, model?.attachment];
   const vision = values.some((value2) => JSON.stringify(value2 ?? "").toLowerCase().includes("image") || JSON.stringify(value2 ?? "").toLowerCase().includes("vision"));
   const value = {
-    limit,
+    limit: rawLimit,
+    contextLimit: isSaneLimit(contextLimit) ? contextLimit : undefined,
     inputLimit: isSaneLimit(inputLimit) ? inputLimit : undefined,
+    outputLimit: isFinitePositive(outputLimit) ? outputLimit : undefined,
     vision
   };
   cache.set(key, value);
@@ -152,10 +258,21 @@ async function refreshModelLimitsOnce(client) {
     return false;
   }
 }
-function getSdkContextLimit(providerID, modelID) {
+function getSdkContextLimit(providerID, modelID, detectedContextLimit, options) {
   loadPersistedApiCacheOnce();
-  const fromApi = lookupLimitWithTagFallback(apiCache, providerID, modelID);
-  return isSaneLimit(fromApi) ? fromApi : undefined;
+  const metadata = lookupMetadataWithTagFallback(apiCache, providerID, modelID);
+  if (!metadata)
+    return;
+  const rawContext = metadata.contextLimit ?? metadata.limit;
+  const promptOnlyDetected = options?.detectedLimitProvenance === "prompt_only" && isFinitePositive(detectedContextLimit) ? detectedContextLimit : undefined;
+  const context = promptOnlyDetected === undefined && isFinitePositive(detectedContextLimit) && isFinitePositive(rawContext) ? Math.min(rawContext, detectedContextLimit) : promptOnlyDetected === undefined && isFinitePositive(detectedContextLimit) ? detectedContextLimit : rawContext;
+  const inputCandidates = [metadata.inputLimit, promptOnlyDetected].filter(isFinitePositive);
+  const input = inputCandidates.length > 0 ? Math.min(...inputCandidates) : undefined;
+  return resolveLimit({
+    context,
+    input,
+    output: metadata.outputLimit
+  }, providerID, modelID, options?.reservation === "none" ? 0 : undefined);
 }
 function modelSupportsVision(providerID, modelID) {
   loadPersistedApiCacheOnce();
@@ -167,18 +284,15 @@ function modelSupportsVision(providerID, modelID) {
   const colon = modelID.lastIndexOf(":");
   return colon > 0 ? apiCache.get(`${providerID}/${modelID.slice(0, colon)}`)?.vision === true : false;
 }
-function lookupLimitWithTagFallback(cache, providerID, modelID) {
+function lookupMetadataWithTagFallback(cache, providerID, modelID) {
   if (!cache)
     return;
-  const exact = cache.get(`${providerID}/${modelID}`)?.limit;
-  if (typeof exact === "number")
+  const exact = cache.get(`${providerID}/${modelID}`);
+  if (exact)
     return exact;
   const colonIdx = modelID.lastIndexOf(":");
   if (colonIdx > 0) {
-    const baseModel = modelID.slice(0, colonIdx);
-    const fallback = cache.get(`${providerID}/${baseModel}`)?.limit;
-    if (typeof fallback === "number")
-      return fallback;
+    return cache.get(`${providerID}/${modelID.slice(0, colonIdx)}`);
   }
   return;
 }
@@ -224,4 +338,4 @@ function resolveHistorianContextLimit(historianModelOverride) {
   return DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
 }
 
-export { isSaneLimit, refreshModelLimitsFromApi, refreshModelLimitsAfterAuthOnce, getSdkContextLimit, modelSupportsVision, deriveTriggerBudget, deriveHistorianChunkTokens, resolveHistorianContextLimit };
+export { piModelRefToCanonical, setStoragePrivatePermissionEnforcement, shouldEnforcePrivateStoragePermissions, isSaneLimit, setOutputReserveConfig, refreshModelLimitsFromApi, refreshModelLimitsAfterAuthOnce, getSdkContextLimit, modelSupportsVision, deriveTriggerBudget, deriveHistorianChunkTokens, resolveHistorianContextLimit };