@cortexkit/pi-magic-context 0.41.0 → 0.41.2

package/dist/historian-calibration-extension.js

@@ -12,13 +12,15 @@ function finiteNumber(value) {
 function calibrateHistorianProviderPayload(payload, temperature, maxOutputTokens) {
   if (typeof payload !== "object" || payload === null || Array.isArray(payload))
     return payload;
+  if (temperature === undefined && maxOutputTokens === undefined)
+    return payload;
   const calibrated = { ...payload };
   const generationConfig = calibrated.generationConfig;
   if (typeof generationConfig === "object" && generationConfig !== null && !Array.isArray(generationConfig)) {
     calibrated.generationConfig = {
       ...generationConfig,
-      temperature,
-      maxOutputTokens
+      ...temperature !== undefined ? { temperature } : {},
+      ...maxOutputTokens !== undefined ? { maxOutputTokens } : {}
     };
     return calibrated;
   }
@@ -26,27 +28,31 @@ function calibrateHistorianProviderPayload(payload, temperature, maxOutputTokens
   if (typeof inferenceConfig === "object" && inferenceConfig !== null && !Array.isArray(inferenceConfig)) {
     calibrated.inferenceConfig = {
       ...inferenceConfig,
-      temperature,
-      maxTokens: maxOutputTokens
+      ...temperature !== undefined ? { temperature } : {},
+      ...maxOutputTokens !== undefined ? { maxTokens: maxOutputTokens } : {}
     };
     return calibrated;
   }
-  calibrated.temperature = temperature;
-  if ("max_output_tokens" in calibrated) {
-    calibrated.max_output_tokens = maxOutputTokens;
-  } else if ("max_completion_tokens" in calibrated) {
-    calibrated.max_completion_tokens = maxOutputTokens;
-  } else if ("max_tokens" in calibrated) {
-    calibrated.max_tokens = maxOutputTokens;
-  } else if ("maxTokens" in calibrated) {
-    calibrated.maxTokens = maxOutputTokens;
+  if (temperature !== undefined) {
+    calibrated.temperature = temperature;
+  }
+  if (maxOutputTokens !== undefined) {
+    if ("max_output_tokens" in calibrated) {
+      calibrated.max_output_tokens = maxOutputTokens;
+    } else if ("max_completion_tokens" in calibrated) {
+      calibrated.max_completion_tokens = maxOutputTokens;
+    } else if ("max_tokens" in calibrated) {
+      calibrated.max_tokens = maxOutputTokens;
+    } else if ("maxTokens" in calibrated) {
+      calibrated.maxTokens = maxOutputTokens;
+    }
   }
   return calibrated;
 }
 function historianCalibrationExtension(pi) {
   const temperature = finiteNumber(process.env[HISTORIAN_TEMPERATURE_ENV]);
   const maxOutputTokens = finiteNumber(process.env[HISTORIAN_MAX_OUTPUT_TOKENS_ENV]);
-  if (temperature === undefined || maxOutputTokens === undefined)
+  if (temperature === undefined && maxOutputTokens === undefined)
     return;
   pi.on("before_provider_request", (event) => calibrateHistorianProviderPayload(event.payload, temperature, maxOutputTokens));
 }

package/dist/{index-3k71e196.js → index-q2vgz0j1.js}

@@ -314,6 +314,11 @@ var buffer = [];
 var flushTimer = null;
 var FLUSH_INTERVAL_MS = 500;
 var BUFFER_SIZE_LIMIT = 50;
+var MAX_LOG_FILE_BYTES = 32 * 1024 * 1024;
+var SIZE_CHECK_INTERVAL_FLUSHES = 64;
+var activeLogFile = null;
+var activeLogSize = null;
+var flushesSinceSizeCheck = 0;
 var swallowedWriteCount = 0;
 var lastErrorMessage = null;
 var lastErrorTime = null;
@@ -327,6 +332,73 @@ function recordSwallowedWrite(error) {
 function ensureDir(filePath) {
   fs.mkdirSync(path2.dirname(filePath), { recursive: true });
 }
+function isMissingFile(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function getCurrentLogSize(logFile) {
+  if (activeLogFile === logFile && activeLogSize !== null && flushesSinceSizeCheck < SIZE_CHECK_INTERVAL_FLUSHES) {
+    return activeLogSize;
+  }
+  try {
+    const stat = fs.statSync(logFile);
+    if (!stat.isFile()) {
+      throw new Error(`Magic Context log path is not a regular file: ${logFile}`);
+    }
+    fs.chmodSync(logFile, 384);
+    activeLogFile = logFile;
+    activeLogSize = stat.size;
+    flushesSinceSizeCheck = 0;
+    return stat.size;
+  } catch (error) {
+    if (!isMissingFile(error))
+      throw error;
+    activeLogFile = logFile;
+    activeLogSize = 0;
+    flushesSinceSizeCheck = 0;
+    return 0;
+  }
+}
+function capLogData(data) {
+  if (Buffer.byteLength(data) <= MAX_LOG_FILE_BYTES)
+    return data;
+  let bounded = Buffer.from(data).subarray(0, MAX_LOG_FILE_BYTES).toString("utf8");
+  while (Buffer.byteLength(bounded) > MAX_LOG_FILE_BYTES) {
+    bounded = bounded.slice(0, -1);
+  }
+  return bounded;
+}
+function writeBoundedPredecessor(logFile, predecessorPath, size) {
+  const predecessorFd = fs.openSync(predecessorPath, "w", 384);
+  try {
+    fs.fchmodSync(predecessorFd, 384);
+    const bytesToCopy = Math.min(size, MAX_LOG_FILE_BYTES);
+    const sourceFd = fs.openSync(logFile, "r");
+    try {
+      const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, bytesToCopy));
+      let remaining = bytesToCopy;
+      let position = Math.max(0, size - bytesToCopy);
+      while (remaining > 0) {
+        const bytesRead = fs.readSync(sourceFd, chunk, 0, Math.min(chunk.length, remaining), position);
+        if (bytesRead === 0)
+          break;
+        fs.writeSync(predecessorFd, chunk, 0, bytesRead);
+        remaining -= bytesRead;
+        position += bytesRead;
+      }
+    } finally {
+      fs.closeSync(sourceFd);
+    }
+  } finally {
+    fs.closeSync(predecessorFd);
+  }
+}
+function rotateLogFile(logFile, size) {
+  const predecessorPath = `${logFile}.1`;
+  writeBoundedPredecessor(logFile, predecessorPath, size);
+  fs.truncateSync(logFile, 0);
+  activeLogSize = 0;
+  flushesSinceSizeCheck = 0;
+}
 function flush() {
   if (flushTimer) {
     clearTimeout(flushTimer);
@@ -334,13 +406,26 @@ function flush() {
   }
   if (buffer.length === 0)
     return;
-  const data = buffer.join("");
+  const bufferedData = buffer.join("");
   buffer = [];
   try {
+    const data = capLogData(bufferedData);
     const logFile = getMagicContextLogPath();
     ensureDir(logFile);
-    fs.appendFileSync(logFile, data);
+    let currentSize = getCurrentLogSize(logFile);
+    const dataSize = Buffer.byteLength(data);
+    if (currentSize > 0 && currentSize + dataSize > MAX_LOG_FILE_BYTES) {
+      rotateLogFile(logFile, currentSize);
+      currentSize = 0;
+    }
+    fs.appendFileSync(logFile, data, { encoding: "utf8", mode: 384 });
+    activeLogFile = logFile;
+    activeLogSize = currentSize + dataSize;
+    flushesSinceSizeCheck++;
   } catch (error) {
+    activeLogFile = null;
+    activeLogSize = null;
+    flushesSinceSizeCheck = 0;
     recordSwallowedWrite(error);
   }
 }