@wrongstack/core 0.3.1 → 0.3.2

package/dist/{events-CNB9PALO.d.ts → events-BHIQs4o1.d.ts}

@@ -153,6 +153,13 @@ interface EventMap {
         used: number;
         limit: number;
     };
+    'context.repaired': {
+        ctx: Context;
+        changed: boolean;
+        removedToolUses: string[];
+        removedToolResults: string[];
+        removedMessages: number;
+    };
     'compaction.fired': {
         before: number;
         after: number;

package/dist/execution/index.d.ts

@@ -1,10 +1,11 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-DKu4A6nB.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-HsBLGRaA.js';
 import { g as Provider, a0 as Context } from '../context-IovtuTf8.js';
-import { C as Compactor, a as CompactReport } from '../compactor-BUU6Zm_3.js';
+import { a as Compactor, C as CompactReport } from '../compactor-DpJBI1YH.js';
 import { M as MessageSelector } from '../selector-wT2fv9Fg.js';
-import { E as EventBus } from '../events-CNB9PALO.js';
+import { E as EventBus } from '../events-BHIQs4o1.js';
 import { c as MiddlewareHandler } from '../system-prompt-Dk1qm8ey.js';
-import { r as Agent, R as RunResult } from '../index-BDb0cAMP.js';
+import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-D2qvAxVd.js';
+import { r as Agent, R as RunResult } from '../index-hWNybrNZ.js';
 import { D as DoneCondition } from '../multi-agent-B9a6sflH.js';
 import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-C_7znCIC.js';
 import { a as WstackPaths } from '../wstack-paths-BGu2INTm.js';
@@ -12,7 +13,6 @@ import '../models-registry-Y2xbog0E.js';
 import '../logger-BMQgxvdy.js';
 import '../observability-BhnVLBLS.js';
 import '../secret-scrubber-CgG2tV2B.js';
-import '../config-CKLYPkCi.js';
 
 interface SkillLoaderOptions {
     paths: WstackPaths;
@@ -147,6 +147,7 @@ declare class SelectiveCompactor implements Compactor {
     compact(ctx: Context, opts?: {
         aggressive?: boolean;
     }): Promise<CompactReport>;
+    private repairProtocolAdjacency;
     /**
      * Run the LLM selector to decide what to keep vs collapse.
      * Returns the token savings achieved.
@@ -173,9 +174,10 @@ declare class SelectiveCompactor implements Compactor {
 
 type CompactionFailureMode = 'throw' | 'throw_on_hard' | 'continue';
 interface AutoCompactionOptions {
-    aggressiveOn?: 'hard' | 'soft' | 'warn';
+    aggressiveOn?: ContextWindowAggressiveOn;
     events?: EventBus;
     failureMode?: CompactionFailureMode;
+    policyProvider?: (ctx: Context) => Pick<ContextWindowPolicy, 'thresholds' | 'aggressiveOn'> | null | undefined;
 }
 /**
  * Pipeline middleware that monitors context token load and automatically
@@ -193,6 +195,7 @@ declare class AutoCompactionMiddleware {
     private readonly aggressiveOn;
     private readonly events?;
     private readonly failureMode;
+    private readonly policyProvider?;
     /**
      * @param compactor        Compactor to use for compaction.
      * @param maxContext       Provider's max context window in tokens.
@@ -208,7 +211,7 @@ declare class AutoCompactionMiddleware {
         warn: number;
         soft: number;
         hard: number;
-    }, optsOrAggressiveOn?: AutoCompactionOptions | 'hard' | 'soft' | 'warn', events?: EventBus);
+    }, optsOrAggressiveOn?: AutoCompactionOptions | ContextWindowAggressiveOn, events?: EventBus);
     handler(): MiddlewareHandler<Context>;
     private compact;
 }

package/dist/execution/index.js

@@ -35,6 +35,98 @@ function estimateTextTokens(text) {
   return RoughTokenEstimate(text);
 }
 
+// src/utils/message-invariants.ts
+function repairToolUseAdjacency(messages) {
+  const removedToolUses = [];
+  const removedToolResults = [];
+  let removedMessages = 0;
+  let changed = false;
+  const out = [];
+  for (let i = 0; i < messages.length; i++) {
+    const original = messages[i];
+    let msg = original;
+    if (hasToolUse(msg)) {
+      const nextIds = toolResultIds(messages[i + 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_use" && !nextIds.has(block.id)) {
+            removedToolUses.push(block.id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
+        }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (hasToolResult(msg)) {
+      const allowed = toolUseIds(out[out.length - 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_result" && !allowed.has(block.tool_use_id)) {
+            removedToolResults.push(block.tool_use_id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
+        }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (isEmptyMessage(msg)) {
+      removedMessages++;
+      changed = true;
+      continue;
+    }
+    out.push(msg);
+  }
+  return {
+    messages: changed ? out : messages,
+    report: { changed, removedToolUses, removedToolResults, removedMessages }
+  };
+}
+function hasToolUse(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_use");
+}
+function hasToolResult(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_result");
+}
+function toolUseIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!msg || msg.role !== "assistant") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_use") ids.add(block.id);
+  }
+  return ids;
+}
+function toolResultIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!msg || msg.role !== "user") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_result") ids.add(block.tool_use_id);
+  }
+  return ids;
+}
+function contentBlocks(msg) {
+  return msg && Array.isArray(msg.content) ? msg.content : [];
+}
+function mapContent(msg, fn) {
+  if (!Array.isArray(msg.content)) return msg;
+  const next = fn(msg.content);
+  if (next.length === msg.content.length && next.every((b, idx) => b === msg.content[idx])) {
+    return msg;
+  }
+  return { ...msg, content: next };
+}
+function isEmptyMessage(msg) {
+  if (typeof msg.content === "string") return msg.content.trim().length === 0;
+  return msg.content.length === 0;
+}
+
 // src/execution/compactor.ts
 var HybridCompactor = class {
   preserveK;
@@ -48,20 +140,36 @@ var HybridCompactor = class {
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateMessages(ctx.messages);
     const reductions = [];
-    const phase1Saved = this.eliseOldToolResults(ctx);
+    const policy = readContextWindowPolicy(ctx);
+    const preserveK = policy?.preserveK ?? this.preserveK;
+    const eliseThreshold = policy?.eliseThreshold ?? this.eliseThreshold;
+    const phase1Saved = this.eliseOldToolResults(ctx, preserveK, eliseThreshold);
     if (phase1Saved > 0) reductions.push({ phase: "elision", saved: phase1Saved });
     if (opts.aggressive) {
-      const phase2Saved = this.collapseAncientTurns(ctx);
+      const phase2Saved = this.collapseAncientTurns(ctx, preserveK);
       if (phase2Saved > 0) reductions.push({ phase: "summary", saved: phase2Saved });
     }
+    const repaired = repairToolUseAdjacency(ctx.messages);
+    if (repaired.report.changed) {
+      ctx.state.replaceMessages(repaired.messages);
+    }
     const afterTokens = this.estimateMessages(ctx.messages);
-    return { before: beforeTokens, after: afterTokens, reductions };
+    return {
+      before: beforeTokens,
+      after: afterTokens,
+      reductions,
+      repaired: repaired.report.changed ? {
+        removedToolUses: repaired.report.removedToolUses,
+        removedToolResults: repaired.report.removedToolResults,
+        removedMessages: repaired.report.removedMessages
+      } : void 0
+    };
   }
-  eliseOldToolResults(ctx) {
+  eliseOldToolResults(ctx, preserveK = this.preserveK, eliseThreshold = this.eliseThreshold) {
     const messages = ctx.messages;
     let pairCount = 0;
     let preserveStart = messages.length;
-    for (let i = messages.length - 1; i >= 0 && pairCount < this.preserveK; i--) {
+    for (let i = messages.length - 1; i >= 0 && pairCount < preserveK; i--) {
       const m = messages[i];
       if (!m) continue;
       if (m.role === "user" || m.role === "assistant") {
@@ -85,7 +193,7 @@ var HybridCompactor = class {
       const newContent = msg.content.map((b) => {
         if (b.type !== "tool_result") return b;
         const tokens = estimateToolResultTokens(b.content);
-        if (tokens < this.eliseThreshold) return b;
+        if (tokens < eliseThreshold) return b;
         saved += tokens;
         const elided = {
           type: "tool_result",
@@ -105,9 +213,9 @@ var HybridCompactor = class {
     if (changed) ctx.state.replaceMessages(nextMessages);
     return saved;
   }
-  collapseAncientTurns(ctx) {
+  collapseAncientTurns(ctx, preserveK = this.preserveK) {
     const messages = ctx.messages;
-    const cutTarget = Math.max(0, messages.length - this.preserveK * 2);
+    const cutTarget = Math.max(0, messages.length - preserveK * 2);
     if (cutTarget <= 0) return 0;
     let boundary = -1;
     for (let i = cutTarget; i < messages.length; i++) {
@@ -148,6 +256,15 @@ var HybridCompactor = class {
     return total;
   }
 };
+function readContextWindowPolicy(ctx) {
+  const policy = ctx.meta?.["contextWindowPolicy"];
+  if (!policy || typeof policy !== "object") return null;
+  const candidate = policy;
+  if (typeof candidate.preserveK !== "number" || typeof candidate.eliseThreshold !== "number") {
+    return null;
+  }
+  return candidate;
+}
 function hasTextContent(m) {
   if (typeof m.content === "string") return m.content.trim().length > 0;
   return m.content.some((b) => b.type === "text" && b.text.trim().length > 0);
@@ -194,8 +311,19 @@ var IntelligentCompactor = class {
       const saved2 = this.lightweightCompact(ctx);
       if (saved2 > 0) reductions.push({ phase: "elision", saved: saved2 });
     }
+    const repaired = repairToolUseAdjacency(ctx.messages);
+    if (repaired.report.changed) ctx.state.replaceMessages(repaired.messages);
     const afterTokens = this.estimateTokens(ctx.messages);
-    return { before: beforeTokens, after: afterTokens, reductions };
+    return {
+      before: beforeTokens,
+      after: afterTokens,
+      reductions,
+      repaired: repaired.report.changed ? {
+        removedToolUses: repaired.report.removedToolUses,
+        removedToolResults: repaired.report.removedToolResults,
+        removedMessages: repaired.report.removedMessages
+      } : void 0
+    };
   }
   async summarizeAncientTurns(ctx) {
     const messages = ctx.messages;
@@ -235,8 +363,8 @@ var IntelligentCompactor = class {
       const m = messages[i];
       if (!m) continue;
       if (m.role === "assistant") {
-        const hasToolUse = Array.isArray(m.content) ? m.content.some((b) => b.type === "tool_use") : false;
-        if (!hasToolUse) {
+        const hasToolUse2 = Array.isArray(m.content) ? m.content.some((b) => b.type === "tool_use") : false;
+        if (!hasToolUse2) {
           return i + 1;
         }
       } else if (m.role !== "user") ; else {
@@ -542,8 +670,9 @@ var SelectiveCompactor = class {
     if (!shouldCompact) {
       const saved = this.eliseOldToolResults(ctx);
       if (saved > 0) reductions.push({ phase: "elision", saved });
+      const repair2 = this.repairProtocolAdjacency(ctx);
       const afterTokens2 = this.estimateTokens(ctx.messages);
-      return { before: beforeTokens, after: afterTokens2, reductions };
+      return { before: beforeTokens, after: afterTokens2, reductions, repaired: repair2 };
     }
     const savedElision = this.eliseOldToolResults(ctx);
     if (savedElision > 0) reductions.push({ phase: "elision", saved: savedElision });
@@ -553,8 +682,18 @@ var SelectiveCompactor = class {
       const savedSelective = await this.runSelector(ctx, targetBudget);
       if (savedSelective > 0) reductions.push({ phase: "selective", saved: savedSelective });
     }
+    const repair = this.repairProtocolAdjacency(ctx);
     const afterTokens = this.estimateTokens(ctx.messages);
-    return { before: beforeTokens, after: afterTokens, reductions };
+    return { before: beforeTokens, after: afterTokens, reductions, repaired: repair };
+  }
+  repairProtocolAdjacency(ctx) {
+    const repaired = repairToolUseAdjacency(ctx.messages);
+    if (repaired.report.changed) ctx.state.replaceMessages(repaired.messages);
+    return repaired.report.changed ? {
+      removedToolUses: repaired.report.removedToolUses,
+      removedToolResults: repaired.report.removedToolResults,
+      removedMessages: repaired.report.removedMessages
+    } : void 0;
   }
   /**
    * Run the LLM selector to decide what to keep vs collapse.
@@ -795,6 +934,7 @@ var AutoCompactionMiddleware = class {
   aggressiveOn;
   events;
   failureMode;
+  policyProvider;
   /**
    * @param compactor        Compactor to use for compaction.
    * @param maxContext       Provider's max context window in tokens.
@@ -817,17 +957,25 @@ var AutoCompactionMiddleware = class {
     this.aggressiveOn = opts.aggressiveOn ?? "soft";
     this.events = opts.events;
     this.failureMode = opts.failureMode ?? "throw_on_hard";
+    this.policyProvider = opts.policyProvider;
   }
   handler() {
     return async (ctx, next) => {
       const tokens = this.estimator(ctx);
       const load = tokens / this.maxContext;
-      if (load >= this.hardThreshold) {
+      const policy = this.policyProvider?.(ctx);
+      const thresholds = policy?.thresholds ?? {
+        warn: this.warnThreshold,
+        soft: this.softThreshold,
+        hard: this.hardThreshold
+      };
+      const aggressiveOn = policy?.aggressiveOn ?? this.aggressiveOn;
+      if (load >= thresholds.hard) {
         await this.compact(ctx, true, { level: "hard", tokens, load });
-      } else if (load >= this.softThreshold) {
-        await this.compact(ctx, this.aggressiveOn !== "hard", { level: "soft", tokens, load });
-      } else if (load >= this.warnThreshold) {
-        await this.compact(ctx, false, { level: "warn", tokens, load });
+      } else if (load >= thresholds.soft) {
+        await this.compact(ctx, aggressiveOn !== "hard", { level: "soft", tokens, load });
+      } else if (load >= thresholds.warn) {
+        await this.compact(ctx, aggressiveOn === "warn", { level: "warn", tokens, load });
       }
       return next(ctx);
     };