pi-condense 2.4.3 → 2.6.0

package/src/thinking-strip.test.ts

@@ -1,257 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { stripOldThinking, computeThinkingBoundary } from "./thinking-strip.js";
-import type { ThinkingStripConfig } from "./types.js";
-
-const cfg = (enabled: boolean, keepLastTurns: number): ThinkingStripConfig => ({ enabled, keepLastTurns });
-
-function userMsg(ts: number): any {
-  return { role: "user", content: [{ type: "text", text: "go" }], timestamp: ts };
-}
-
-function assistantToolsThinking(ts: number, toolCallIds: string[], thinkingBlocks = 1): any {
-  const content: any[] = [];
-  for (let i = 0; i < thinkingBlocks; i++) {
-    content.push({ type: "thinking", thinking: `t${ts}-${i}`, thinkingSignature: `sig${ts}-${i}` });
-  }
-  content.push({ type: "text", text: "working" });
-  for (const id of toolCallIds) content.push({ type: "toolCall", id, name: "bash", arguments: { cmd: "ls" } });
-  return { role: "assistant", content, timestamp: ts, usage: {}, stopReason: "toolUse" };
-}
-
-function assistantTextThinking(ts: number): any {
-  return {
-    role: "assistant",
-    content: [
-      { type: "thinking", thinking: "final reasoning", thinkingSignature: "sigf" },
-      { type: "text", text: "done" },
-    ],
-    timestamp: ts,
-    usage: {},
-    stopReason: "stop",
-  };
-}
-
-function toolResult(ts: number, toolCallId: string): any {
-  return {
-    role: "toolResult",
-    toolCallId,
-    toolName: "bash",
-    content: [{ type: "text", text: "out" }],
-    isError: false,
-    timestamp: ts,
-  };
-}
-
-function hasThinking(msg: any): boolean {
-  return Array.isArray(msg.content) && msg.content.some((c: any) => c.type === "thinking");
-}
-
-function countThinking(msg: any): number {
-  return Array.isArray(msg.content) ? msg.content.filter((c: any) => c.type === "thinking").length : 0;
-}
-
-/** user, then (n-1) tool-using assistant turns each followed by a toolResult, then 1 final text assistant. */
-function convo(nAssistantTurns: number): any[] {
-  const msgs: any[] = [userMsg(1)];
-  let ts = 2;
-  for (let i = 0; i < nAssistantTurns - 1; i++) {
-    const id = `tc${i}`;
-    msgs.push(assistantToolsThinking(ts++, [id]));
-    msgs.push(toolResult(ts++, id));
-  }
-  msgs.push(assistantTextThinking(ts++));
-  return msgs;
-}
-
-describe("stripOldThinking", () => {
-  test("disabled → same reference", () => {
-    const msgs = convo(20);
-    expect(stripOldThinking(msgs, cfg(false, 16))).toBe(msgs);
-  });
-
-  test("fewer assistant turns than keepLastTurns → same reference", () => {
-    const msgs = convo(10);
-    expect(stripOldThinking(msgs, cfg(true, 16))).toBe(msgs);
-  });
-
-  test("exactly keepLastTurns assistant turns → same reference (nothing older)", () => {
-    const msgs = convo(16);
-    expect(stripOldThinking(msgs, cfg(true, 16))).toBe(msgs);
-  });
-
-  test("strips thinking from turns older than the last K, keeps the last K", () => {
-    const msgs = convo(20);
-    const out = stripOldThinking(msgs, cfg(true, 16));
-    expect(out).not.toBe(msgs);
-    const assistants = out.filter((m) => m.role === "assistant");
-    expect(assistants.length).toBe(20);
-    for (const a of assistants.slice(-16)) expect(hasThinking(a)).toBe(true);
-    for (const a of assistants.slice(0, 4)) expect(hasThinking(a)).toBe(false);
-  });
-
-  test("keepLastTurns=1 keeps only the most-recent assistant turn's thinking", () => {
-    const msgs = convo(5);
-    const out = stripOldThinking(msgs, cfg(true, 1));
-    const assistants = out.filter((m) => m.role === "assistant");
-    expect(hasThinking(assistants[assistants.length - 1])).toBe(true);
-    for (const a of assistants.slice(0, -1)) expect(hasThinking(a)).toBe(false);
-  });
-
-  test("keepLastTurns=0 is clamped to 1 (never strips the last assistant turn)", () => {
-    const msgs = convo(5);
-    const out = stripOldThinking(msgs, cfg(true, 0));
-    const assistants = out.filter((m) => m.role === "assistant");
-    expect(hasThinking(assistants[assistants.length - 1])).toBe(true);
-    expect(hasThinking(assistants[0])).toBe(false);
-  });
-
-  test("trailing tool-use assistant awaiting results keeps its thinking", () => {
-    const msgs: any[] = [userMsg(1)];
-    let ts = 2;
-    for (let i = 0; i < 4; i++) {
-      const id = `x${i}`;
-      msgs.push(assistantToolsThinking(ts++, [id]));
-      msgs.push(toolResult(ts++, id));
-    }
-    const out = stripOldThinking(msgs, cfg(true, 1));
-    const assistants = out.filter((m) => m.role === "assistant");
-    const last = assistants[assistants.length - 1];
-    expect(hasThinking(last)).toBe(true);
-    expect(last.content.some((c: any) => c.type === "toolCall")).toBe(true);
-  });
-
-  test("stripped assistant keeps its text and toolCall blocks", () => {
-    const msgs = convo(20);
-    const out = stripOldThinking(msgs, cfg(true, 16));
-    const firstAssistant = out.find((m) => m.role === "assistant");
-    expect(hasThinking(firstAssistant)).toBe(false);
-    expect(firstAssistant.content.some((c: any) => c.type === "text")).toBe(true);
-    expect(firstAssistant.content.some((c: any) => c.type === "toolCall")).toBe(true);
-  });
-
-  test("strips all thinking blocks from a message (all-or-nothing)", () => {
-    const msgs: any[] = [userMsg(1), assistantToolsThinking(2, ["a"], 2), toolResult(3, "a")];
-    let ts = 4;
-    for (let i = 0; i < 3; i++) {
-      const id = `b${i}`;
-      msgs.push(assistantToolsThinking(ts++, [id], 2));
-      msgs.push(toolResult(ts++, id));
-    }
-    msgs.push(assistantTextThinking(ts++));
-    const out = stripOldThinking(msgs, cfg(true, 2));
-    expect(countThinking(out[1])).toBe(0);
-  });
-
-  test("no thinking anywhere → same reference", () => {
-    const msgs: any[] = [userMsg(1)];
-    let ts = 2;
-    for (let i = 0; i < 20; i++) {
-      const id = `n${i}`;
-      msgs.push({
-        role: "assistant",
-        content: [{ type: "text", text: "x" }, { type: "toolCall", id, name: "bash", arguments: {} }],
-        timestamp: ts++,
-        usage: {},
-        stopReason: "toolUse",
-      });
-      msgs.push(toolResult(ts++, id));
-    }
-    expect(stripOldThinking(msgs, cfg(true, 4))).toBe(msgs);
-  });
-
-  test("idempotent: second pass returns same reference", () => {
-    const msgs = convo(20);
-    const once = stripOldThinking(msgs, cfg(true, 16));
-    const twice = stripOldThinking(once, cfg(true, 16));
-    expect(twice).toBe(once);
-  });
-
-  test("preserves message order and length", () => {
-    const msgs = convo(20);
-    const out = stripOldThinking(msgs, cfg(true, 16));
-    expect(out.length).toBe(msgs.length);
-    out.forEach((m, i) => expect(m.role).toBe(msgs[i].role));
-  });
-});
-
-describe("stripOldThinking (boundaryTimestamp path)", () => {
-  test("strips assistants older than boundary, keeps boundary and newer", () => {
-    const msgs = convo(20);
-    const assistantTs = msgs.filter((m) => m.role === "assistant").map((m) => m.timestamp);
-    const boundary = assistantTs[4];
-    const out = stripOldThinking(msgs, cfg(true, 16), boundary);
-    expect(out).not.toBe(msgs);
-    const assistants = out.filter((m) => m.role === "assistant");
-    for (const a of assistants) {
-      if (a.timestamp < boundary) expect(hasThinking(a)).toBe(false);
-      else expect(hasThinking(a)).toBe(true);
-    }
-  });
-
-  test("prefix is byte-stable across a growing tail at a fixed boundary (the AC)", () => {
-    const msgs = convo(20);
-    const boundary = msgs.filter((m) => m.role === "assistant").map((m) => m.timestamp)[4];
-    const first = stripOldThinking(msgs, cfg(true, 16), boundary);
-    const prefixLen = first.length;
-    const grown = [...msgs, assistantToolsThinking(100, ["tcNew"]), toolResult(101, "tcNew")];
-    const second = stripOldThinking(grown, cfg(true, 16), boundary);
-    expect(JSON.stringify(second.slice(0, prefixLen))).toBe(JSON.stringify(first));
-  });
-
-  test("undefined boundary falls back to live-count (same as 2-arg)", () => {
-    const msgs = convo(20);
-    const viaUndefined = stripOldThinking(msgs, cfg(true, 16), undefined);
-    const viaTwoArg = stripOldThinking(msgs, cfg(true, 16));
-    expect(JSON.stringify(viaUndefined)).toBe(JSON.stringify(viaTwoArg));
-  });
-
-  test("assistant without a timestamp is kept, never stripped", () => {
-    const noTs: any = { role: "assistant", content: [{ type: "thinking", thinking: "x", thinkingSignature: "s" }, { type: "text", text: "y" }], usage: {}, stopReason: "stop" };
-    const msgs = [userMsg(1), noTs, ...convo(20).slice(1)];
-    const out = stripOldThinking(msgs, cfg(true, 16), 9999);
-    const kept = out.find((m) => m.role === "assistant" && m.timestamp === undefined);
-    expect(hasThinking(kept)).toBe(true);
-  });
-
-  test("post-chain-drop survivor array: surviving older turns stripped, boundary honored", () => {
-    const full = convo(20);
-    const assistantTs = full.filter((m) => m.role === "assistant").map((m) => m.timestamp);
-    const boundary = assistantTs[10];
-    const survivor = [...full.slice(0, 6), ...full.slice(8)];
-    const out = stripOldThinking(survivor, cfg(true, 16), boundary);
-    for (const a of out.filter((m) => m.role === "assistant")) {
-      if (a.timestamp < boundary) expect(hasThinking(a)).toBe(false);
-    }
-  });
-});
-
-describe("computeThinkingBoundary", () => {
-  const ts = Array.from({ length: 40 }, (_, i) => (i + 1) * 10);
-
-  test("count <= keep returns prev unchanged", () => {
-    expect(computeThinkingBoundary(ts.slice(0, 16), 16, undefined)).toBeUndefined();
-    expect(computeThinkingBoundary(ts.slice(0, 10), 16, 123)).toBe(123);
-  });
-
-  test("count > keep returns the (count-keep)-th timestamp", () => {
-    expect(computeThinkingBoundary(ts.slice(0, 20), 16, undefined)).toBe(ts[4]);
-  });
-
-  test("keepLastTurns=0 is clamped to 1 (no out-of-bounds)", () => {
-    expect(computeThinkingBoundary(ts.slice(0, 20), 0, undefined)).toBe(ts[19]);
-  });
-
-  test("monotonic clamp: never regresses when keepLastTurns increases", () => {
-    const first = computeThinkingBoundary(ts.slice(0, 40), 16, undefined);
-    expect(first).toBe(ts[24]);
-    const second = computeThinkingBoundary(ts.slice(0, 40), 32, first);
-    expect(second).toBe(first);
-  });
-
-  test("an added trailing turn (e.g. closingMessage) advances the boundary by one", () => {
-    const before = computeThinkingBoundary(ts.slice(0, 20), 16, undefined);
-    const after = computeThinkingBoundary(ts.slice(0, 21), 16, before);
-    expect(after).toBe(ts[5]);
-    expect(after).toBeGreaterThan(before as number);
-  });
-});

package/src/thinking-strip.ts

@@ -1,83 +0,0 @@
-import { withoutThinkingBlocks } from "./chain-range-prune.js";
-import type { ThinkingStripConfig } from "./types.js";
-
-/**
- * Rolling main-loop thinking strip.
- *
- * Keeps `thinking` blocks on the last `keepLastTurns` assistant turns and
- * strips them from all older assistant messages, preserving each message's
- * `text` and `toolCall` blocks. "Turn" counts ASSISTANT messages, not
- * user-bounded spans — the target failure mode is a single long open chain
- * (zero subagents, near-zero user turns) where a span-based window keeps
- * everything.
- *
- * Provider safety (Anthropic): during tool use only the LAST assistant turn's
- * thinking is required; prior turns may be omitted, and a message's thinking
- * blocks must be dropped all-or-nothing. `keepLastTurns` is clamped to >= 1 so
- * the most-recent assistant turn always keeps its thinking. Stripping reuses
- * `withoutThinkingBlocks` (drops the whole block incl. signature).
- *
- * Returns the original array reference unchanged when nothing is stripped, so
- * `pruneMessages` can skip reconstruction.
- */
-export function stripOldThinking(
-  messages: any[],
-  config: ThinkingStripConfig,
-  boundaryTimestamp?: number,
-): any[] {
-  if (!config.enabled) return messages;
-
-  // Flush-gated path: strip by the persisted timestamp boundary. Fixed between
-  // flushes, so consecutive renders produce a byte-identical historical prefix.
-  // `!(ts < boundary)` keeps a timestamp-less assistant (undefined < n === false),
-  // which is the provider-safe default (never over-strip an unknown-age turn).
-  if (boundaryTimestamp !== undefined && boundaryTimestamp !== null) {
-    let changed = false;
-    const out = messages.map((msg) => {
-      if (msg?.role !== "assistant" || !(msg.timestamp < boundaryTimestamp)) return msg;
-      if (!Array.isArray(msg.content) || !msg.content.some((c: any) => c.type === "thinking")) return msg;
-      changed = true;
-      return withoutThinkingBlocks(msg);
-    });
-    return changed ? out : messages;
-  }
-
-  // Fallback: live-count window (pre-first-flush / pre-feature sessions).
-  const keep = Math.max(1, config.keepLastTurns);
-
-  const assistantIdx: number[] = [];
-  for (let i = 0; i < messages.length; i++) {
-    if (messages[i]?.role === "assistant") assistantIdx.push(i);
-  }
-  if (assistantIdx.length <= keep) return messages;
-
-  const firstKeptAssistant = assistantIdx[assistantIdx.length - keep];
-  let changed = false;
-  const out = messages.map((msg, i) => {
-    if (i >= firstKeptAssistant || msg?.role !== "assistant") return msg;
-    if (!Array.isArray(msg.content) || !msg.content.some((c: any) => c.type === "thinking")) return msg;
-    changed = true;
-    return withoutThinkingBlocks(msg);
-  });
-  return changed ? out : messages;
-}
-
-/**
- * Flush-time computation of the thinking-strip boundary: the timestamp of the
- * (count - keepLastTurns)-th assistant message, monotonically clamped so the
- * boundary never moves backward (a mid-session `keepLastTurns` increase must not
- * re-add thinking to an already-stripped message). Stateless recompute - no
- * running counter. `keepLastTurns` is clamped to >= 1 to match `stripOldThinking`
- * and avoid an out-of-bounds index.
- */
-export function computeThinkingBoundary(
-  assistantTimestamps: number[],
-  keepLastTurns: number,
-  prev?: number,
-): number | undefined {
-  const keep = Math.max(1, keepLastTurns);
-  const count = assistantTimestamps.length;
-  if (count <= keep) return prev;
-  const candidate = assistantTimestamps[count - keep];
-  return Math.max(prev ?? candidate, candidate);
-}