@wrongstack/core 0.8.2 → 0.8.5

package/dist/execution/index.d.ts

@@ -11,7 +11,7 @@ import { J as JournalEntry } from '../goal-store-C7jcumEh.js';
 import { A as AgentFactory } from '../agent-subagent-runner-Cav3yEJM.js';
 import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-IQKrMfXz.js';
 import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-CxuWrsKK.js';
-import { a as WstackPaths } from '../wstack-paths-gCrJ631C.js';
+import { a as WstackPaths } from '../wstack-paths-Bxik3CsK.js';
 import '../retry-policy-OwtKNxo8.js';
 import '../models-registry-BcYJDKLm.js';
 import '../logger-DDd5C--Z.js';
@@ -204,10 +204,16 @@ declare class AutoCompactionMiddleware {
     private readonly failureMode;
     private readonly policyProvider?;
     /**
-     * Overhead factor applied to the rough message-token estimate to produce a
-     * figure comparable to the real API request size (system prompt + tool defs).
-     * Without this factor, raw message tokens undercount real load by 15-50% in
-     * short conversations, causing premature compaction triggers.
+     * Calibration factor applied to the estimator output. The estimator is now
+     * expected to already include messages + system prompt + tool definitions
+     * (see `estimateRequestTokens.total`), so no overhead boost is needed. Kept
+     * as a constant so a future calibration against real provider tokenization
+     * (BPE vs the chars/3.5 rough estimator) can dial this without touching the
+     * threshold-check math.
+     *
+     * Historical note: was 1.3 when the estimator only counted messages — that
+     * double-counted system+tools once the estimator was upgraded, firing
+     * compaction ~30% earlier than intended (e.g. real 56% load showed as 73%).
      */
     private static readonly OVERHEAD_FACTOR;
     /**

package/dist/execution/index.js

@@ -1019,12 +1019,18 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   failureMode;
   policyProvider;
   /**
-   * Overhead factor applied to the rough message-token estimate to produce a
-   * figure comparable to the real API request size (system prompt + tool defs).
-   * Without this factor, raw message tokens undercount real load by 15-50% in
-   * short conversations, causing premature compaction triggers.
+   * Calibration factor applied to the estimator output. The estimator is now
+   * expected to already include messages + system prompt + tool definitions
+   * (see `estimateRequestTokens.total`), so no overhead boost is needed. Kept
+   * as a constant so a future calibration against real provider tokenization
+   * (BPE vs the chars/3.5 rough estimator) can dial this without touching the
+   * threshold-check math.
+   *
+   * Historical note: was 1.3 when the estimator only counted messages — that
+   * double-counted system+tools once the estimator was upgraded, firing
+   * compaction ~30% earlier than intended (e.g. real 56% load showed as 73%).
    */
-  static OVERHEAD_FACTOR = 1.3;
+  static OVERHEAD_FACTOR = 1;
   /**
    * Once a compaction attempt reduces nothing (preserveK protects everything,
    * no oversized tool_results remain to elide), retrying on every iteration
@@ -1234,7 +1240,7 @@ var ToolExecutor = class {
         return { result, tool, durationMs: Date.now() - start };
       }
       if (hasMalformedArguments(use.input)) {
-        const result = this.malformedInputResult(use);
+        const result = this.malformedInputResult(use, extractMalformedRaw(use.input));
         budget = this.decrementBudget(result, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
@@ -1441,11 +1447,18 @@ var ToolExecutor = class {
       is_error: true
     };
   }
-  malformedInputResult(use) {
+  malformedInputResult(use, raw) {
+    let content = `Tool "${use.name}" received arguments that were not a valid JSON object, so they could not be parsed. Re-issue the call with the arguments encoded as a single well-formed JSON object matching the tool's input schema.`;
+    if (raw) {
+      const max = 800;
+      const excerpt = raw.length > max ? `${raw.slice(0, max)}\u2026 (truncated, ${raw.length} chars total)` : raw;
+      content += ` Common cause: a string field (e.g. code in old_string/new_string) contains literal newlines, quotes, or backslashes that must be JSON-escaped, or the payload was cut off mid-stream. The raw arguments received were:
+${excerpt}`;
+    }
     return {
       type: "tool_result",
       tool_use_id: use.id,
-      content: `Tool "${use.name}" received arguments that were not a valid JSON object, so they could not be parsed. Re-issue the call with the arguments encoded as a single well-formed JSON object matching the tool's input schema.`,
+      content,
       is_error: true
     };
   }
@@ -1501,6 +1514,18 @@ function hasMalformedArguments(input) {
   const keys = Object.keys(obj);
   return keys.length === 1 && MALFORMED_ARG_MARKERS.includes(keys[0]);
 }
+function extractMalformedRaw(input) {
+  if (!hasMalformedArguments(input)) return void 0;
+  const obj = input;
+  const value = obj[Object.keys(obj)[0]];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
 
 // src/utils/regex-guard.ts
 var MAX_PATTERN_LEN = 512;