@alexlikevibe/pi-jev 0.2.0

package/src/commands/menu.ts

@@ -0,0 +1,291 @@
+import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import { defineMenu, runMenu } from '@narumitw/pi-tui-kit';
+import {
+  CONFIG_KEYS,
+  configFromEnv,
+  mergeConfigFiles,
+  readConfigFile,
+  type ConfigKeyMeta,
+  type JevFileConfig,
+} from '../shared/config.js';
+import { coerce, keyMeta, readOrInit, saveFile, setPath, valueAt } from '../cli/main.js';
+import { VALUE_OPTIONS } from './completions.js';
+import { THINKING_LEVELS, type ModelOption } from './models.js';
+
+export type MenuScreenId = 'main' | 'general' | 'compaction' | 'routing' | 'chooseValue' | 'chooseModel' | 'chooseThinking' | 'inputValue';
+export type MenuActionId =
+  | 'toggleScope'
+  | 'editKey'
+  | 'setEnum'
+  | 'setValue'
+  | 'pickModel'
+  | 'pickThinking'
+  | 'showResolved';
+
+export interface EditorState {
+  scope: 'global' | 'project';
+  editingKey: string;
+  /** Model picked in chooseModel, awaiting an optional thinking level. */
+  selectedModelRef?: string;
+  /** Whether the selected model supports thinking. */
+  selectedModelReasoning?: boolean;
+}
+
+export interface MenuPaths {
+  globalPath: string;
+  projectPath: string;
+}
+
+function readFileTolerant(path: string): JevFileConfig | undefined {
+  try {
+    return readConfigFile(path);
+  } catch {
+    return undefined;
+  }
+}
+
+function merged(paths: MenuPaths): JevFileConfig | undefined {
+  return mergeConfigFiles(readFileTolerant(paths.globalPath), readFileTolerant(paths.projectPath));
+}
+
+/** Effective value of a key, tagged with where it comes from. */
+function displayValue(meta: ConfigKeyMeta, paths: MenuPaths): string {
+  const config = configFromEnv(process.env, merged(paths));
+  const raw = valueAt(config, meta.path);
+  if (raw === undefined) return 'unset';
+  const fromEnv = meta.env ? (process.env[meta.env] ?? '').trim() : '';
+  return `${String(raw)}${fromEnv ? ' [env]' : ''}`;
+}
+
+function groupKeys(prefix: string): ConfigKeyMeta[] {
+  return CONFIG_KEYS.filter((meta) =>
+    prefix === '' ? !meta.path.includes('.') : meta.path.startsWith(`${prefix}.`),
+  );
+}
+
+function groupScreen(
+  screenId: 'general' | 'compaction' | 'routing',
+  title: string,
+  paths: MenuPaths,
+): { kind: 'settings'; title: string; items: { id: string; label: string; description?: string; currentValue: string; action: MenuActionId }[] } {
+  const prefix = screenId === 'general' ? '' : screenId;
+  const action: MenuActionId = 'editKey';
+  return {
+    kind: 'settings',
+    title,
+    items: groupKeys(prefix).map((meta) => ({
+      id: meta.path,
+      label: meta.path,
+      description: meta.description,
+      currentValue: displayValue(meta, paths),
+      action,
+    })),
+  };
+}
+
+function writeKey(paths: MenuPaths, scope: 'global' | 'project', keyPath: string, value: string): void {
+  const meta = keyMeta(keyPath);
+  if (!meta) throw new Error(`unknown key "${keyPath}"`);
+  const targetPath = scope === 'project' ? paths.projectPath : paths.globalPath;
+  const file = readOrInit(targetPath);
+  setPath(file, meta.path, coerce(meta, value));
+  saveFile(targetPath, file);
+}
+
+/**
+ * Builds the interactive `/jev` settings menu on top of `@narumitw/pi-tui-kit`.
+ * `state` is mutated by actions (scope toggle, key being edited).
+ */
+export function buildJevMenu(
+  paths: MenuPaths,
+  state: EditorState,
+  io: { out(text: string): void },
+  models: readonly ModelOption[] = [],
+) {
+  return defineMenu<EditorState, MenuScreenId, MenuActionId, ExtensionCommandContext>({
+    start: 'main',
+    screens: {
+      main: () => {
+        const config = configFromEnv(process.env, merged(paths));
+        const scopePath = state.scope === 'project' ? paths.projectPath : paths.globalPath;
+        return {
+          kind: 'actions',
+          title: 'pi-jev',
+          lines: [`Scope: ${state.scope} (${scopePath}) — 'toggle scope' switches it`],
+          items: [
+            {
+              id: 'toggleScope',
+              label: `Toggle scope (currently ${state.scope})`,
+              action: 'toggleScope',
+            },
+            {
+              id: 'general',
+              label: `General (provider ${config.provider})`,
+              to: 'general',
+            },
+            {
+              id: 'compaction',
+              label: 'Compaction',
+              to: 'compaction',
+            },
+            {
+              id: 'routing',
+              label: `Routing (${config.routing.cheap || config.routing.strong ? 'enabled' : 'disabled'})`,
+              to: 'routing',
+            },
+            { id: 'showResolved', label: 'Show resolved config', action: 'showResolved' },
+          ],
+          hint: 'close',
+        };
+      },
+      general: () => groupScreen('general', 'pi-jev — General', paths),
+      compaction: () => groupScreen('compaction', 'pi-jev — Compaction', paths),
+      routing: () => groupScreen('routing', 'pi-jev — Routing', paths),
+      chooseModel: () => {
+        const current = displayValue(keyMeta(state.editingKey)!, paths);
+        const items = [
+          ...(current !== 'unset' ? [{ id: '__unset__', label: '(unset)', description: 'clear this key' }] : []),
+          ...models.map((model) => ({
+            id: model.ref,
+            label: model.name,
+            description: `${model.provider}${model.image ? ' · images' : ''}${model.reasoning ? ' · thinking' : ''}${model.contextWindow ? ` · ${Math.round(model.contextWindow / 1000)}k ctx` : ''}`,
+          })),
+        ];
+        return {
+          kind: 'choice',
+          title: `pi-jev — ${state.editingKey}`,
+          lines: models.length === 0 ? ['No models found in pi (check provider auth).'] : [],
+          items,
+          action: 'pickModel',
+          enableSearch: true,
+          hint: 'back',
+        };
+      },
+      chooseThinking: () => {
+        const model = models.find((entry) => entry.modelRef === state.selectedModelRef);
+        return {
+          kind: 'choice',
+          title: `pi-jev — thinking level`,
+          lines: [`${state.selectedModelRef ?? ''} (thinking optional — default keeps the model's own)`],
+          items: [
+            { id: '__default__', label: 'default', description: "no override (model default)" },
+            ...(model?.reasoning !== false && model ? THINKING_LEVELS.map((level) => ({ id: level, label: level })) : []),
+          ],
+          action: 'pickThinking',
+          initialItemId: '__default__',
+          hint: 'back',
+        };
+      },
+      chooseValue: () => {
+        const options = VALUE_OPTIONS[state.editingKey] ?? [];
+        return {
+          kind: 'choice',
+          title: `pi-jev — ${state.editingKey}`,
+          items: options.map((option) => ({
+            id: option.label,
+            label: option.label,
+            description: option.description,
+          })),
+          action: 'setEnum',
+          hint: 'back',
+        };
+      },
+      inputValue: () => {
+        const meta = keyMeta(state.editingKey);
+        return {
+          kind: 'input',
+          title: `pi-jev — set ${state.editingKey}`,
+          lines: meta ? [meta.description] : [],
+          placeholder: '(new value)',
+          action: 'setValue',
+          hint: 'back',
+        };
+      },
+    },
+    actions: {
+      toggleScope: () => {
+        state.scope = state.scope === 'global' ? 'project' : 'global';
+        return { kind: 'stay' };
+      },
+      editKey: ({ itemId }) => {
+        if (!keyMeta(itemId)) return { kind: 'rejected', error: new Error(`unknown key "${itemId}"`) };
+        state.editingKey = itemId;
+        if (itemId === 'routing.cheap' || itemId === 'routing.strong') return { kind: 'to', screen: 'chooseModel' };
+        return VALUE_OPTIONS[itemId] ? { kind: 'to', screen: 'chooseValue' } : { kind: 'to', screen: 'inputValue' };
+      },
+      setEnum: ({ itemId }) => {
+        writeKey(paths, state.scope, state.editingKey, itemId);
+        return { kind: 'back' };
+      },
+      pickModel: ({ itemId }) => {
+        if (itemId === '__unset__') {
+          const targetPath = state.scope === 'project' ? paths.projectPath : paths.globalPath;
+          const file = readOrInit(targetPath);
+          const [section, key] = state.editingKey.split('.') as [string, string];
+          delete ((file as Record<string, Record<string, unknown>>)[section] ??= {})[key];
+          if (Object.keys((file as Record<string, Record<string, unknown>>)[section]).length === 0) {
+            delete (file as Record<string, unknown>)[section];
+          }
+          saveFile(targetPath, file);
+          return { kind: 'back' };
+        }
+        const model = models.find((entry) => entry.ref === itemId);
+        state.selectedModelRef = itemId;
+        state.selectedModelReasoning = model?.reasoning ?? false;
+        if (state.selectedModelReasoning) return { kind: 'to', screen: 'chooseThinking' };
+        writeKey(paths, state.scope, state.editingKey, itemId);
+        return { kind: 'back' };
+      },
+      pickThinking: ({ itemId }) => {
+        const ref = itemId === '__default__' ? state.selectedModelRef : `${state.selectedModelRef}:${itemId}`;
+        writeKey(paths, state.scope, state.editingKey, ref ?? '');
+        return { kind: 'back' };
+      },
+      setValue: ({ value }) => {
+        if (value === undefined || !value.trim()) return { kind: 'rejected', error: new Error('empty value') };
+        try {
+          writeKey(paths, state.scope, state.editingKey, value.trim());
+        } catch (error) {
+          return { kind: 'rejected', error };
+        }
+        return { kind: 'back' };
+      },
+      showResolved: () => {
+        const lines: string[] = [];
+        const global = readFileTolerant(paths.globalPath);
+        const project = readFileTolerant(paths.projectPath);
+        const config = configFromEnv(process.env, mergeConfigFiles(global, project));
+        for (const meta of CONFIG_KEYS) {
+          lines.push(`${meta.path} = ${valueAt(config, meta.path) ?? 'unset'}`);
+        }
+        io.out(lines.join('\n'));
+        return { kind: 'close' };
+      },
+    },
+  });
+}
+
+/** Opens the interactive menu; falls back to text output outside TUI mode. */
+export async function openJevSettingsMenu(
+  ctx: ExtensionCommandContext,
+  paths: MenuPaths,
+  io: { out(text: string): void },
+): Promise<void> {
+  if (ctx.mode !== 'tui' || !ctx.hasUI) {
+    io.out('/jev menu requires an interactive pi UI; use `/jev set <key> <value>` instead');
+    return;
+  }
+  const controller = new AbortController();
+  const state: EditorState = { scope: 'global', editingKey: 'model' };
+  const { modelsFromContext } = await import('./models.js');
+  const menu = buildJevMenu(paths, state, io, modelsFromContext(ctx));
+  try {
+    await runMenu(ctx, menu, {
+      getState: () => state,
+      signal: controller.signal,
+      isCurrent: () => !controller.signal.aborted,
+    });
+  } finally {
+    controller.abort();
+  }
+}

package/src/commands/models.ts

@@ -0,0 +1,43 @@
+import type { Model } from '@earendil-works/pi-ai';
+
+/** A model as shown in pickers and completions. */
+export interface ModelOption {
+  /** pi-style reference: `provider/id`, optionally `:thinking` when pinned. */
+  ref: string;
+  /** Bare reference without a thinking suffix. */
+  modelRef: string;
+  name: string;
+  provider: string;
+  reasoning: boolean;
+  image: boolean;
+  contextWindow: number;
+}
+
+/** pi thinking levels, lowest to highest. */
+export const THINKING_LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const;
+
+function fromModel(model: Model<never> | { id: string; name?: string; provider: string; reasoning?: boolean; input?: string[]; contextWindow?: number }): ModelOption {
+  const provider = String(model.provider);
+  const id = String(model.id);
+  return {
+    ref: `${provider}/${id}`,
+    modelRef: `${provider}/${id}`,
+    name: model.name ?? id,
+    provider,
+    reasoning: model.reasoning === true,
+    image: Array.isArray(model.input) ? model.input.includes('image') : false,
+    contextWindow: model.contextWindow ?? 0,
+  };
+}
+
+/** Models configured in pi: scoped models when set, otherwise the full available catalogue. */
+export function modelsFromContext(ctx: {
+  scopedModels?: readonly { model: unknown }[];
+  modelRegistry?: { getAvailable?: () => readonly unknown[] };
+}): ModelOption[] {
+  const scoped = ctx.scopedModels ?? [];
+  const raw = scoped.length > 0 ? scoped.map((entry) => entry.model) : (ctx.modelRegistry?.getAvailable?.() ?? []);
+  return raw
+    .map((model) => fromModel(model as never))
+    .sort((a, b) => (a.provider === b.provider ? a.name.localeCompare(b.name) : a.provider.localeCompare(b.provider)));
+}

package/src/compaction/convert.ts

@@ -0,0 +1,95 @@
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
+import type { Message, ToolResult } from '../vendor/fast-jev-compaction/index.js';
+
+type Blocks = Array<{ type: string; text?: string }>;
+
+/** Extracts text from a string-or-content-blocks payload; images become a note. */
+function textOf(content: string | Blocks): string {
+  if (typeof content === 'string') return content;
+  return content
+    .map(block => (block.type === 'text' && typeof block.text === 'string' ? block.text : '[image]'))
+    .join('\n');
+}
+
+/**
+ * Converts the span pi wants to summarize (any `AgentMessage`) into the
+ * Claude-Code-shaped `Message[]` fast-jev-compaction works with:
+ *
+ * - `toolResult` messages merge into synthetic user messages (consecutive
+ *   ones share one message), keeping their call order;
+ * - `bashExecution` messages become an assistant tool call (`bash`) paired
+ *   with a user tool result, so Jev can drop their outputs like any other;
+ * - assistant thinking is dropped (transient, never needed verbatim later);
+ * - `compactionSummary` / `branchSummary` are skipped: the hook receives the
+ *   previous summary separately (`previousSummary`);
+ * - images cannot be represented and render as `[image]`.
+ */
+export function convertMessages(messages: readonly AgentMessage[]): Message[] {
+  const out: Message[] = [];
+  let pendingResults: ToolResult[] = [];
+
+  const flushResults = (): void => {
+    if (pendingResults.length > 0) {
+      out.push({ role: 'user', text: '', toolUses: [], toolResults: pendingResults });
+      pendingResults = [];
+    }
+  };
+
+  for (const message of messages) {
+    switch (message.role) {
+      case 'user': {
+        flushResults();
+        out.push({ role: 'user', text: textOf(message.content), toolUses: [], toolResults: [] });
+        break;
+      }
+      case 'assistant': {
+        flushResults();
+        const text = message.content
+          .filter((block): block is { type: 'text'; text: string } => block.type === 'text')
+          .map(block => block.text)
+          .join('\n');
+        const toolUses = message.content
+          .filter((block): block is { type: 'toolCall'; id: string; name: string; arguments: Record<string, unknown> } =>
+            block.type === 'toolCall',
+          )
+          .map(block => ({ tool_use_id: block.id, tool: block.name, input: block.arguments }));
+        out.push({ role: 'assistant', text, toolUses });
+        break;
+      }
+      case 'toolResult': {
+        pendingResults.push({
+          tool_use_id: message.toolCallId,
+          text: textOf(message.content),
+          isError: message.isError,
+        });
+        break;
+      }
+      case 'bashExecution': {
+        flushResults();
+        if (message.excludeFromContext) break;
+        const id = `bashexec_${message.timestamp}`;
+        out.push({
+          role: 'assistant',
+          text: '',
+          toolUses: [{ tool_use_id: id, tool: 'bash', input: { command: message.command } }],
+        });
+        pendingResults.push({
+          tool_use_id: id,
+          text: message.output,
+          isError: message.cancelled || (message.exitCode !== undefined && message.exitCode !== 0),
+        });
+        break;
+      }
+      case 'custom': {
+        flushResults();
+        out.push({ role: 'user', text: textOf(message.content), toolUses: [], toolResults: [] });
+        break;
+      }
+      default:
+        // compactionSummary / branchSummary arrive via previousSummary instead
+        break;
+    }
+  }
+  flushResults();
+  return out;
+}

package/src/compaction/decision.ts

@@ -0,0 +1,262 @@
+import {
+  estimateTokens,
+  type CallAction,
+  type JevAnswer,
+  type JevQuestions,
+  type Message,
+  type ToolCall,
+} from '../vendor/fast-jev-compaction/index.js';
+
+/** Ordered staleness levels for the per-result `score` question. */
+const STALENESS_LEVELS = ['needed', 'probably needed', 'uncertain', 'stale', 'very stale'] as const;
+
+/** Tokens the request envelope (`model`, key names) adds around state and questions. */
+const REQUEST_OVERHEAD_TOKENS = 20;
+
+/**
+ * The three questions asked about one tool call: two `noul` questions (keep
+ * the call, keep its result verbatim) and one `score` question whose
+ * confident answer can rescue a borderline result.
+ */
+export function questionsFor(call: ToolCall): JevQuestions {
+  return {
+    [`call_${call.id}`]: {
+      type: 'noul',
+      instructions: `Tool call ${call.id} (${call.tool}) should stay in the history: knowing this call was made, with its input, still matters for what the assistant does next`,
+    },
+    [`result_${call.id}`]: {
+      type: 'noul',
+      instructions: `The full output of tool call ${call.id} (${call.tool}, ${call.resultChars} chars) should stay in the history verbatim: the assistant still needs its contents and re-running the tool would not do`,
+    },
+    [`staleness_${call.id}`]: {
+      type: 'score',
+      instructions: `Rate how stale the output of tool call ${call.id} (${call.tool}) is for the ongoing work: level 0 means its contents are still needed verbatim, level ${STALENESS_LEVELS.length - 1} means clearly obsolete`,
+      criteria: [...STALENESS_LEVELS],
+    },
+  };
+}
+
+/**
+ * Splits candidate calls into batches whose questions, together with the
+ * (always complete) state, fit one Jev request.
+ */
+export function batchCalls(
+  calls: readonly ToolCall[],
+  stateTokens: number,
+  maxRequestTokens: number,
+): ToolCall[][] {
+  const budget = maxRequestTokens - stateTokens - REQUEST_OVERHEAD_TOKENS;
+  const batches: ToolCall[][] = [];
+  let current: ToolCall[] = [];
+  let currentTokens = 0;
+  for (const call of calls) {
+    const tokens = estimateTokens(JSON.stringify(questionsFor(call)));
+    if (current.length > 0 && currentTokens + tokens > budget) {
+      batches.push(current);
+      current = [];
+      currentTokens = 0;
+    }
+    if (current.length === 0 && tokens > budget) {
+      throw new Error(
+        `state leaves no room for questions (~${stateTokens} of ${maxRequestTokens} tokens)`,
+      );
+    }
+    current.push(call);
+    currentTokens += tokens;
+  }
+  if (current.length > 0) batches.push(current);
+  return batches;
+}
+
+export interface DecisionOutcome {
+  id: string;
+  tool: string;
+  keepCall: number;
+  keepResult: number;
+  action: CallAction;
+  reason: 'pinned' | 'kept' | 'result_dropped' | 'call_dropped';
+  pinned: boolean;
+  /** Kept only because of a confident low-staleness score. */
+  guarded: boolean;
+  /** Answers missing or malformed; kept conservatively. */
+  missing: boolean;
+}
+
+function noulOr(answers: Record<string, JevAnswer>, name: string): number | undefined {
+  const answer = answers[name];
+  if (
+    answer === null ||
+    typeof answer !== 'object' ||
+    !('noul' in answer) ||
+    typeof (answer as { noul?: unknown }).noul !== 'number' ||
+    !Number.isFinite((answer as { noul: number }).noul)
+  ) {
+    return undefined;
+  }
+  return (answer as { noul: number }).noul;
+}
+
+function scoreAnswer(
+  answers: Record<string, JevAnswer>,
+  name: string,
+): { score: number; confidence: number } | undefined {
+  const answer = answers[name];
+  if (
+    answer === null ||
+    typeof answer !== 'object' ||
+    !('score' in answer) ||
+    typeof (answer as { score?: unknown }).score !== 'number' ||
+    !Number.isFinite((answer as { score: number }).score)
+  ) {
+    return undefined;
+  }
+  const confidence =
+    'confidence' in answer && typeof (answer as { confidence?: unknown }).confidence === 'number'
+      ? (answer as { confidence: number }).confidence
+      : 0;
+  return { score: (answer as { score: number }).score, confidence };
+}
+
+/** Jev scores arrive either in [0, 1] or spread across the criteria levels. */
+function normalizedStaleness(score: number): number {
+  return score <= 1 ? score : score / (STALENESS_LEVELS.length - 1);
+}
+
+export interface DecideOptions {
+  keepThreshold: number;
+  borderline: number;
+}
+
+/**
+ * Decides one call from Jev's answers: keep, truncate the result, or drop the
+ * call. A result whose keep probability falls just under the threshold is
+ * rescued when the staleness score is confidently low. Missing or malformed
+ * answers keep the call (conservative).
+ */
+export function decideCall(
+  call: Pick<ToolCall, 'id' | 'tool' | 'pinned'>,
+  answers: Record<string, JevAnswer>,
+  options: DecideOptions,
+): DecisionOutcome {
+  if (call.pinned) {
+    return {
+      id: call.id,
+      tool: call.tool,
+      keepCall: 1,
+      keepResult: 1,
+      action: 'keep',
+      reason: 'pinned',
+      pinned: true,
+      guarded: false,
+      missing: false,
+    };
+  }
+
+  const keepCall = noulOr(answers, `call_${call.id}`);
+  const keepResult = noulOr(answers, `result_${call.id}`);
+  if (keepCall === undefined || keepResult === undefined) {
+    return {
+      id: call.id,
+      tool: call.tool,
+      keepCall: keepCall ?? 1,
+      keepResult: keepResult ?? 1,
+      action: 'keep',
+      reason: 'kept',
+      pinned: false,
+      guarded: false,
+      missing: true,
+    };
+  }
+
+  const base = { id: call.id, tool: call.tool, keepCall, keepResult, pinned: false, missing: false };
+
+  if (keepResult >= options.keepThreshold) {
+    return { ...base, action: 'keep', reason: 'kept', guarded: false };
+  }
+
+  const staleness = scoreAnswer(answers, `staleness_${call.id}`);
+  if (
+    keepResult >= options.keepThreshold - options.borderline &&
+    staleness !== undefined &&
+    normalizedStaleness(staleness.score) <= 0.25 &&
+    staleness.confidence >= 0.5
+  ) {
+    return { ...base, action: 'keep', reason: 'kept', guarded: true };
+  }
+
+  if (keepCall >= options.keepThreshold) {
+    return { ...base, action: 'drop_result', reason: 'result_dropped', guarded: false };
+  }
+  return { ...base, action: 'drop_call', reason: 'call_dropped', guarded: false };
+}
+
+function truncatedResultText(text: string, isError: boolean, headChars: number): string {
+  if (text.length <= headChars + 120) return text;
+  const head = headChars > 0 ? `${text.slice(0, headChars)}\n` : '';
+  return `${head}[jev-compaction truncated ${text.length - headChars} chars of this tool result${
+    isError ? ' (error)' : ''
+  }; re-run the tool if needed]`;
+}
+
+/**
+ * Rebuilds the conversation from the decisions. A dropped call disappears
+ * together with its result; a dropped result keeps a bounded head and a note.
+ * Messages that lose all their content are removed; untouched messages are
+ * returned as the same objects they came in as.
+ */
+export function applyJevDecisions(
+  messages: readonly Message[],
+  decisions: readonly DecisionOutcome[],
+  calls: readonly ToolCall[],
+  headChars: number,
+): Message[] {
+  const byId = new Map(calls.map(call => [call.id, call]));
+  const actionFor = new Map<string, CallAction>();
+  for (const decision of decisions) {
+    const call = byId.get(decision.id);
+    if (call && decision.action !== 'keep') actionFor.set(call.tool_use_id, decision.action);
+  }
+
+  const kept: Message[] = [];
+  for (const message of messages) {
+    const touched =
+      message.toolUses.some(tool => actionFor.has(tool.tool_use_id)) ||
+      (message.toolResults ?? []).some(result => actionFor.has(result.tool_use_id));
+    if (!touched) {
+      kept.push(message);
+      continue;
+    }
+
+    const toolUses = message.toolUses
+      .filter(tool => actionFor.get(tool.tool_use_id) !== 'drop_call')
+      .map(tool => {
+        if (actionFor.get(tool.tool_use_id) !== 'drop_result' || tool.text === undefined) return tool;
+        const text = truncatedResultText(tool.text, tool.isError ?? false, headChars);
+        return text === tool.text ? tool : { ...tool, text };
+      });
+    const toolResults = (message.toolResults ?? [])
+      .filter(result => actionFor.get(result.tool_use_id) !== 'drop_call')
+      .map(result => {
+        if (actionFor.get(result.tool_use_id) !== 'drop_result') return result;
+        const text = truncatedResultText(result.text, result.isError ?? false, headChars);
+        return text === result.text ? result : { ...result, text };
+      });
+
+    const unchanged =
+      toolUses.length === message.toolUses.length &&
+      toolUses.every((tool, index) => tool === message.toolUses[index]) &&
+      toolResults.length === (message.toolResults ?? []).length &&
+      toolResults.every((result, index) => result === message.toolResults?.[index]);
+    if (unchanged) {
+      kept.push(message);
+      continue;
+    }
+    if (message.text.trim().length === 0 && toolUses.length === 0 && toolResults.length === 0) {
+      continue;
+    }
+    const rebuilt: Message = { role: message.role, text: message.text, toolUses };
+    if (toolResults.length > 0) rebuilt.toolResults = toolResults;
+    kept.push(rebuilt);
+  }
+  return kept;
+}