@rasputin-ai/node 0.5.2 → 0.6.0

package/dist/index.js

@@ -13,14 +13,89 @@ import {
   sourceLocatorFromFile as sourceLocatorFromFile2
 } from "@rasputin-ai/core";
 
-// src/execution-recorder/function-plan.ts
+// ../recorder/src/run-exactly-once.ts
+var runExactlyOnce = function __rasputinHandleRun__(invoke, callback) {
+  let outcome;
+  const wrapped = function __rasputinHandleRun__3() {
+    try {
+      const value = callback();
+      outcome = { kind: "value", value };
+      return value;
+    } catch (caught) {
+      outcome = { kind: "throw", error: caught };
+      throw caught;
+    }
+  };
+  try {
+    invoke(wrapped);
+  } catch {
+  }
+  if (outcome?.kind === "throw") throw outcome.error;
+  if (outcome?.kind === "value") return outcome.value;
+  return callback();
+};
+
+// ../recorder/src/call-handle.ts
+var passthroughHandle = () => ({
+  leave: (value) => value,
+  fail: () => {
+  },
+  end: () => {
+  },
+  run: function __rasputinHandleRun__3(callback) {
+    return runExactlyOnce((invoke) => invoke(), callback);
+  },
+  suspend: (value) => value,
+  resume: (value) => value
+});
+var isolateHandle = (handle) => ({
+  leave: (value) => {
+    try {
+      return handle.leave(value);
+    } catch {
+      return value;
+    }
+  },
+  fail: (error, liveArgs) => {
+    try {
+      handle.fail(error, liveArgs);
+    } catch {
+    }
+  },
+  end: () => {
+    try {
+      handle.end();
+    } catch {
+    }
+  },
+  run: function __rasputinHandleRun__3(callback) {
+    return runExactlyOnce((invoke) => handle.run(invoke), callback);
+  },
+  suspend: (value) => {
+    try {
+      return handle.suspend(value);
+    } catch {
+      return value;
+    }
+  },
+  resume: (value) => {
+    try {
+      return handle.resume(value);
+    } catch {
+      return value;
+    }
+  }
+});
+
+// ../recorder/src/encoded-function-plan.ts
+var encodedPlanOmitsCallValues = (plan) => plan[6] === 1;
+var encodedPlanHasPreBodyParameterEvaluation = (plan) => plan[7] === 1;
+
+// ../recorder/src/function-plan.ts
 import {
   runtimeFunctionId,
   sourceLocatorFromFile
 } from "@rasputin-ai/core";
-var encodedPlanOmitsCallValues = (plan) => plan[6] === 1;
-var encodedPlanHasPreBodyParameterEvaluation = (plan) => plan[7] === 1;
-var EVENT_PAIR_BASE_ESTIMATED_BYTES = 512;
 var definitionFromEncodedPlan = (plan) => {
   const [functionId, name, packageName, packageRelativePath, line, column] = plan;
   const source = packageRelativePath ? {
@@ -36,7 +111,57 @@ var definitionFromEncodedPlan = (plan) => {
     ...encodedPlanHasPreBodyParameterEvaluation(plan) ? { parentAttribution: "pre_body_parameter_evaluation" } : {}
   };
 };
-var estimatedCallBytesFor = (functionId) => EVENT_PAIR_BASE_ESTIMATED_BYTES + Buffer.byteLength(functionId, "utf8") * 2;
+
+// ../recorder/src/runtime-symbol.ts
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v3";
+
+// ../recorder/src/registry.ts
+var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
+var passthroughRun = (_planIndex, _args, callback) => callback();
+var passthroughEnter = () => passthroughHandle();
+var bindPassthrough = (module) => {
+  module.cell.run = passthroughRun;
+  module.cell.enter = passthroughEnter;
+};
+var attachRunner = (cell) => {
+  const run = ((planIndex, args, callback, omitValues) => cell.run(planIndex, args, callback, omitValues));
+  run.enter = (planIndex, args, omitValues, callee) => cell.enter(planIndex, args, omitValues, callee);
+  return run;
+};
+var isCompatibleRegistry = (value) => typeof Reflect.get(value, "register") === "function" && Array.isArray(Reflect.get(value, "runtimes")) && Array.isArray(Reflect.get(value, "modules"));
+var registerModule = (registry, plans, moduleIndex) => {
+  const cell = { run: passthroughRun, enter: passthroughEnter };
+  const module = {
+    plans,
+    cell,
+    ...moduleIndex === void 0 ? {} : { moduleIndex }
+  };
+  registry.modules.push(module);
+  registry.runtimes.at(-1)?.bind(module);
+  return attachRunner(cell);
+};
+var createRegistry = () => {
+  const registry = {
+    runtimes: [],
+    modules: [],
+    register(plans, moduleIndex) {
+      return registerModule(registry, plans, moduleIndex);
+    }
+  };
+  return registry;
+};
+var getAutomaticRuntimeRegistry = () => {
+  const existing = Reflect.get(globalThis, runtimeSymbol);
+  if (existing && typeof existing === "object" && isCompatibleRegistry(existing)) {
+    return existing;
+  }
+  if (existing != null) {
+    return createRegistry();
+  }
+  const registry = createRegistry();
+  Reflect.set(globalThis, runtimeSymbol, registry);
+  return registry;
+};
 
 // src/auto-instrumentation/instrumentation-manifest-registry.ts
 var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v3";
@@ -919,6 +1044,10 @@ var ExecutionJournalPool = class {
   }
 };
 
+// src/execution-recorder/function-plan.ts
+var EVENT_PAIR_BASE_ESTIMATED_BYTES = 512;
+var estimatedCallBytesFor = (functionId) => EVENT_PAIR_BASE_ESTIMATED_BYTES + Buffer.byteLength(functionId, "utf8") * 2;
+
 // src/execution-recorder/recorder-memory-budget.ts
 var EXECUTION_BASE_ESTIMATED_BYTES = 1024;
 var SUMMARY_EVENT_BASE_ESTIMATED_BYTES = 256;
@@ -1054,28 +1183,6 @@ var RecorderMemoryBudget = class {
   }
 };
 
-// src/execution-recorder/run-exactly-once.ts
-var runExactlyOnce = function __rasputinHandleRun__(invoke, callback) {
-  let outcome;
-  const wrapped = function __rasputinHandleRun__3() {
-    try {
-      const value = callback();
-      outcome = { kind: "value", value };
-      return value;
-    } catch (caught) {
-      outcome = { kind: "throw", error: caught };
-      throw caught;
-    }
-  };
-  try {
-    invoke(wrapped);
-  } catch {
-  }
-  if (outcome?.kind === "throw") throw outcome.error;
-  if (outcome?.kind === "value") return outcome.value;
-  return callback();
-};
-
 // src/execution-recorder/runtime-state-size-budget.ts
 import {
   rasputinUnavailable
@@ -1118,6 +1225,7 @@ var dropEventValues = (events) => {
   const marker = () => rasputinUnavailable(VALUE_OMITTED_REASON);
   const bounded = events.map((event) => {
     if (event.type === "function_enter") {
+      if (event.args === void 0) return { ...event };
       dropped += event.args.length;
       return { ...event, args: event.args.map(marker) };
     }
@@ -1301,7 +1409,7 @@ var defaults = {
   maxObjectKeys: 30,
   maxArrayElements: 20,
   maxStringLength: 500,
-  maxSerializedValueBytes: 8 * 1024
+  maxSerializedValueBytes: 16 * 1024
 };
 var compileFreezeLimits = (options) => ({
   maxDepth: options.maxDepth ?? defaults.maxDepth,
@@ -1628,6 +1736,21 @@ var redactUrlUserinfo = (text) => {
 };
 var redactUrlLikeString = (text, redactKeys) => redactSensitiveQuery(redactUrlUserinfo(text), redactKeys);
 var isFrozenAtom = (value) => typeof value === "object" && value !== null && FROZEN in value;
+var isRetainedOverflowChild = (value) => {
+  if (isFrozenAtom(value)) {
+    if (value[FROZEN] === "truncated") return true;
+    return (value[FROZEN] === "Map" || value[FROZEN] === "Set") && value.truncated === true;
+  }
+  if (!Array.isArray(value) || value.length === 0) return false;
+  const last = value[value.length - 1];
+  return isFrozenAtom(last) && last[FROZEN] === "truncated";
+};
+var keepOverflowChild = (child, overflowedOnChild) => {
+  if (!overflowedOnChild) return true;
+  if (child === void 0) return false;
+  return isRetainedOverflowChild(child);
+};
+var BYTE_LIMIT = "max_serialized_value_bytes";
 var createValueFreezer = (options = {}) => {
   const limits = compileFreezeLimits(options);
   const redactKeys = compileRedactKeys(options.redactKeys);
@@ -1760,20 +1883,32 @@ var createValueFreezer = (options = {}) => {
         for (const mapKey of Map.prototype.keys.call(value)) {
           if (counted2 >= limits.maxArrayElements || metrics.oversize) break;
           const key = freezeInner(mapKey, depth + 1, path, metrics);
+          if (!keepOverflowChild(key, metrics.oversize)) break;
           if (typeof mapKey === "string" && keyIsRedacted(mapKey, redactKeys)) {
             add(metrics, stringEstimate(REDACTED));
+            if (metrics.oversize) break;
             entries.push([key, REDACTED]);
           } else {
-            entries.push([
-              key,
-              freezeInner(Map.prototype.get.call(value, mapKey), depth + 1, path, metrics)
-            ]);
+            const mapValue = freezeInner(
+              Map.prototype.get.call(value, mapKey),
+              depth + 1,
+              path,
+              metrics
+            );
+            if (!keepOverflowChild(mapValue, metrics.oversize)) break;
+            entries.push([key, mapValue]);
           }
           counted2++;
         }
+        const hitBytes2 = metrics.oversize && counted2 < Math.min(size, limits.maxArrayElements);
+        const hitCount = size > limits.maxArrayElements;
         return atom("Map", {
           entries,
-          ...size > limits.maxArrayElements ? { truncated: true, reason: "max_array_elements", originalLength: size } : {}
+          ...hitBytes2 || hitCount ? {
+            truncated: true,
+            reason: hitBytes2 ? BYTE_LIMIT : "max_array_elements",
+            originalLength: size
+          } : {}
         });
       }
       if (types.isSet(value)) {
@@ -1784,12 +1919,20 @@ var createValueFreezer = (options = {}) => {
         const size = setSize ? setSize.call(value) : 0;
         for (const item of Set.prototype.values.call(value)) {
           if (counted2 >= limits.maxArrayElements || metrics.oversize) break;
-          values.push(freezeInner(item, depth + 1, path, metrics));
+          const frozen = freezeInner(item, depth + 1, path, metrics);
+          if (!keepOverflowChild(frozen, metrics.oversize)) break;
+          values.push(frozen);
           counted2++;
         }
+        const hitBytes2 = metrics.oversize && counted2 < Math.min(size, limits.maxArrayElements);
+        const hitCount = size > limits.maxArrayElements;
         return atom("Set", {
           values,
-          ...size > limits.maxArrayElements ? { truncated: true, reason: "max_array_elements", originalLength: size } : {}
+          ...hitBytes2 || hitCount ? {
+            truncated: true,
+            reason: hitBytes2 ? BYTE_LIMIT : "max_array_elements",
+            originalLength: size
+          } : {}
         });
       }
       if (Array.isArray(value)) {
@@ -1807,26 +1950,39 @@ var createValueFreezer = (options = {}) => {
           }
           if (!descriptor) {
             add(metrics, NODE + 16);
+            if (metrics.oversize) break;
             items.push(atom("hole"));
             redactNext = false;
             continue;
           }
           if (!("value" in descriptor)) {
             add(metrics, NODE + 16);
+            if (metrics.oversize) break;
             items.push(atom("accessor"));
             redactNext = false;
             continue;
           }
           if (redactNext) {
             add(metrics, stringEstimate(REDACTED));
+            if (metrics.oversize) break;
             items.push(REDACTED);
             redactNext = false;
           } else {
-            items.push(freezeInner(descriptor.value, depth + 1, path, metrics));
+            const frozen = freezeInner(descriptor.value, depth + 1, path, metrics);
+            if (!keepOverflowChild(frozen, metrics.oversize)) break;
+            items.push(frozen);
             redactNext = typeof descriptor.value === "string" && keyIsRedacted(descriptor.value, redactKeys);
           }
         }
-        if (value.length > limits.maxArrayElements) {
+        if (metrics.oversize && items.length < maxItems) {
+          add(metrics, NODE + 32);
+          items.push(
+            atom("truncated", {
+              reason: BYTE_LIMIT,
+              originalLength: value.length
+            })
+          );
+        } else if (value.length > limits.maxArrayElements) {
           add(metrics, NODE + 32);
           items.push(
             atom("truncated", {
@@ -1934,30 +2090,41 @@ var createValueFreezer = (options = {}) => {
       const pairIsSensitive = pairLabel !== void 0 && typeof pairLabel.value === "string" && keyIsRedacted(pairLabel.value, redactKeys);
       const { keys, truncated } = ownEnumerableKeys(value, limits.maxObjectKeys);
       const maxKeys = truncated ? Math.max(0, limits.maxObjectKeys - 1) : keys.length;
+      let kept = 0;
       for (let index = 0; index < maxKeys; index++) {
+        if (metrics.oversize) break;
         const key = keys[index];
-        if (key === void 0 || metrics.oversize) continue;
+        if (key === void 0) continue;
         add(metrics, stringEstimate(key));
+        if (metrics.oversize) break;
         if (keyIsRedacted(key, redactKeys) || key === "value" && pairIsSensitive) {
           add(metrics, stringEstimate(REDACTED));
+          if (metrics.oversize) break;
           assignFrozenField(fields, key, REDACTED);
+          kept++;
           continue;
         }
         const slot = ownData(value, key);
         if (slot) {
           const field = typeof slot.value === "string" && propertyNameLooksLikeUrl(key) ? redactUrlLikeString(slot.value, redactKeys) : slot.value;
-          assignFrozenField(fields, key, freezeInner(field, depth + 1, path, metrics));
+          const frozen = freezeInner(field, depth + 1, path, metrics);
+          if (!keepOverflowChild(frozen, metrics.oversize)) break;
+          assignFrozenField(fields, key, frozen);
+          kept++;
         } else {
           add(metrics, NODE + 16);
+          if (metrics.oversize) break;
           assignFrozenField(fields, key, atom("accessor"));
+          kept++;
         }
       }
-      if (truncated) {
+      const hitBytes = metrics.oversize && kept < maxKeys;
+      if (hitBytes || truncated) {
         return atom("instance", {
           type: typeName,
           value: fields,
           truncated: true,
-          reason: "max_object_keys"
+          reason: hitBytes ? BYTE_LIMIT : "max_object_keys"
         });
       }
       if (typeName) return atom("instance", { type: typeName, value: fields });
@@ -1981,22 +2148,11 @@ var createValueFreezer = (options = {}) => {
     }
     try {
       const frozen = freezeInner(value, 0, path, metrics);
-      if (metrics.oversize) {
-        return {
-          value: atom("truncated", {
-            reason: "max_serialized_value_bytes",
-            serializedBytes: metrics.estimatedBytes
-          }),
-          estimatedBytes: metrics.estimatedBytes,
-          visitedNodes: metrics.visitedNodes,
-          oversize: true
-        };
-      }
       return {
         value: frozen,
         estimatedBytes: metrics.estimatedBytes,
         visitedNodes: metrics.visitedNodes,
-        oversize: false
+        oversize: metrics.oversize
       };
     } catch {
       return {
@@ -2286,14 +2442,18 @@ var encodeFrozen = (value) => {
   }
   return value;
 };
+var isByteBudgetStub = (encoded) => {
+  if (typeof encoded !== "object" || encoded === null || Array.isArray(encoded)) return false;
+  const record = encoded;
+  if (record.__rasputin_truncated !== true || record.__reason !== "max_serialized_value_bytes") {
+    return false;
+  }
+  return Object.keys(record).every((key) => key.startsWith("__"));
+};
 var encodeFrozenWithBytes = (frozen, visitedNodes, maxSerializedValueBytes) => {
   const encoded = encodeFrozen(frozen);
-  if (typeof encoded === "object" && encoded !== null && !Array.isArray(encoded) && encoded.__reason === "max_serialized_value_bytes") {
-    const bytes2 = jsonLiteralUtf8Bytes(encoded);
-    return { value: encoded, bytes: bytes2, visitedNodes };
-  }
   const bytes = jsonLiteralUtf8Bytes(encoded);
-  if (bytes > maxSerializedValueBytes) {
+  if (!isByteBudgetStub(encoded) && bytes > maxSerializedValueBytes) {
     const bounded = truncation("max_serialized_value_bytes", { __serialized_bytes: bytes });
     return { value: bounded, bytes: jsonLiteralUtf8Bytes(bounded), visitedNodes };
   }
@@ -2604,7 +2764,7 @@ var createExecutionRecorder = (options) => {
   const sweepIntervalNs = maxExecutionHoldNs / 4n < 50000000n ? maxExecutionHoldNs / 4n : 50000000n;
   const memoryBudget = new RecorderMemoryBudget(
     maxActiveMemoryBytes,
-    options.maxSerializedValueBytes ?? 8 * 1024
+    options.maxSerializedValueBytes ?? 16 * 1024
   );
   const serializer = createSafeSerializer(options);
   const excludesSource = createSourceExclusionMatcher(options.excludeSources);
@@ -2669,7 +2829,10 @@ var createExecutionRecorder = (options) => {
   };
   const encodeEventValues = (events) => events.map((event) => {
     if (event.type === "function_enter") {
-      return { ...event, args: event.args.map((argument) => serializer.encode(argument)) };
+      return {
+        ...event,
+        ...event.args === void 0 ? {} : { args: event.args.map((argument) => serializer.encode(argument)) }
+      };
     }
     if (event.type === "function_exit") {
       return { ...event, returnValue: serializer.encode(event.returnValue) };
@@ -2716,7 +2879,7 @@ var createExecutionRecorder = (options) => {
   };
   const eventsHaveOmittedValues = (events) => {
     for (const event of events) {
-      if (event.type === "function_enter" && event.args.some((arg) => rasputinTagKind(arg) === "omitted")) {
+      if (event.type === "function_enter" && (event.args ?? []).some((arg) => rasputinTagKind(arg) === "omitted")) {
         return true;
       }
       if (event.type === "function_exit" && rasputinTagKind(event.returnValue) === "omitted") {
@@ -3831,69 +3994,6 @@ var createExecutionRecorder = (options) => {
 };
 
 // src/execution-recorder/automatic-runtime.ts
-var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v3";
-var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
-var passthroughHandle = () => ({
-  leave: (value) => value,
-  fail: () => {
-  },
-  end: () => {
-  },
-  run: function __rasputinHandleRun__3(callback) {
-    return runExactlyOnce((invoke) => invoke(), callback);
-  },
-  suspend: (value) => value,
-  resume: (value) => value
-});
-var isolateHandle = (handle) => ({
-  leave: (value) => {
-    try {
-      return handle.leave(value);
-    } catch {
-      return value;
-    }
-  },
-  fail: (error, liveArgs) => {
-    try {
-      handle.fail(error, liveArgs);
-    } catch {
-    }
-  },
-  end: () => {
-    try {
-      handle.end();
-    } catch {
-    }
-  },
-  run: function __rasputinHandleRun__3(callback) {
-    return runExactlyOnce((invoke) => handle.run(invoke), callback);
-  },
-  suspend: (value) => {
-    try {
-      return handle.suspend(value);
-    } catch {
-      return value;
-    }
-  },
-  resume: (value) => {
-    try {
-      return handle.resume(value);
-    } catch {
-      return value;
-    }
-  }
-});
-var passthroughRun = (_planIndex, _args, callback) => callback();
-var passthroughEnter = () => passthroughHandle();
-var bindPassthrough = (module) => {
-  module.cell.run = passthroughRun;
-  module.cell.enter = passthroughEnter;
-};
-var attachRunner = (cell) => {
-  const run = ((planIndex, args, callback, omitValues) => cell.run(planIndex, args, callback, omitValues));
-  run.enter = (planIndex, args, omitValues) => cell.enter(planIndex, args, omitValues);
-  return run;
-};
 var bindExecution = (execution, module) => {
   const prepared = execution.prepareFunctionPlans(module.plans);
   module.cell.run = (planIndex, args, callback, omitValues) => {
@@ -3904,40 +4004,13 @@ var bindExecution = (execution, module) => {
     try {
       const plan = prepared[planIndex];
       return isolateHandle(
-        plan ? execution.enterPreparedFunction(plan, args, omitValues) : passthroughEnter(planIndex, args, omitValues)
+        plan ? execution.enterPreparedFunction(plan, args, omitValues) : passthroughHandle()
       );
     } catch {
       return passthroughHandle();
     }
   };
 };
-var isRegistry = (value) => Array.isArray(Reflect.get(value, "runtimes")) && Array.isArray(Reflect.get(value, "modules")) && typeof Reflect.get(value, "register") === "function";
-var registerModule = (registry, plans) => {
-  const cell = { run: passthroughRun, enter: passthroughEnter };
-  const module = { plans, cell };
-  registry.modules.push(module);
-  registry.runtimes.at(-1)?.bind(module);
-  return attachRunner(cell);
-};
-var createRegistry = () => {
-  const registry = {
-    runtimes: [],
-    modules: [],
-    register(plans) {
-      return registerModule(registry, plans);
-    }
-  };
-  return registry;
-};
-var getAutomaticRuntimeRegistry = () => {
-  const existing = Reflect.get(globalThis, runtimeSymbol);
-  if (existing && typeof existing === "object" && isRegistry(existing)) {
-    return existing;
-  }
-  const registry = createRegistry();
-  Reflect.set(globalThis, runtimeSymbol, registry);
-  return registry;
-};
 var installAutomaticExecutionRuntime = (execution) => {
   const registry = getAutomaticRuntimeRegistry();
   const runtime = {
@@ -4096,7 +4169,7 @@ var installGlobalHandlers = (client, options = {}) => {
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/node";
-var SDK_VERSION = "0.5.2";
+var SDK_VERSION = "0.6.0";
 
 // src/rasputin-init.ts
 var publicExecution = (runtime) => ({
@@ -4175,7 +4248,7 @@ var RasputinInit = (options) => {
       runtime,
       recorderEnabled,
       {
-        projectApiKey: options.projectApiKey ?? "",
+        projectApiKey: options.projectApiKey,
         release: options.release,
         apiUrl: options.apiUrl,
         enabled,
@@ -4195,7 +4268,7 @@ var RasputinInit = (options) => {
       createExecutionRecorder({ enabled: false }),
       false,
       {
-        projectApiKey: options.projectApiKey ?? "",
+        projectApiKey: options.projectApiKey,
         release: options.release,
         apiUrl: options.apiUrl,
         enabled: false,