pi-ui-extend 1.0.38 → 1.0.39

package/external/pi-tools-suite/src/dcp/provider-tool-results.ts

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import type { ToolRecord } from "./state.js";
+import { stripStaleDcpMetadataLines } from "./pruner-metadata.js";
 
 export interface ProviderToolResultEvidence {
   ids: Set<string>;
@@ -19,7 +20,7 @@ function signature(toolName: string, outputText: string): string {
   return createHash("sha256")
     .update(toolName)
     .update("\u0000")
-    .update(outputText)
+    .update(stripStaleDcpMetadataLines(outputText))
     .digest("hex");
 }
 

package/external/pi-tools-suite/src/dcp/pruner-candidates.ts

@@ -6,6 +6,7 @@ import {
   extractBlockId,
   messageText,
 } from "./pruner-metadata.js";
+import { stableMessageKeys } from "./pruner-message-ids.js";
 
 interface CandidateBoundary {
   id: string;
@@ -24,13 +25,27 @@ function isActiveBlockId(blockId: number, state: DcpState): boolean {
   return state.compressionBlocks.some((block) => block.id === blockId && block.active);
 }
 
-function findCurrentMessageId(msg: any, state: DcpState): string | undefined {
+function findCurrentMessageId(msg: any, stableKey: string, state: DcpState): string | undefined {
   const role = msg?.role ?? "";
   const timestamp = msg?.timestamp;
   if (!Number.isFinite(timestamp)) return undefined;
 
   for (const [id, meta] of state.messageMetaSnapshot) {
-    if (meta.timestamp === timestamp && meta.role === role && meta.blockId === undefined) return id;
+    if (meta.stableId === stableKey) return id;
+  }
+
+  // Backward compatibility for snapshots created before stable IDs were
+  // recorded. Never mix timestamp fallback with a modern stable-ID snapshot.
+  const isLegacySnapshot = [...state.messageMetaSnapshot.values()]
+    .every((meta) => meta.stableId === undefined);
+  if (!isLegacySnapshot) return undefined;
+
+  for (const [id, meta] of state.messageMetaSnapshot) {
+    if (
+      meta.timestamp === timestamp &&
+      meta.role === role &&
+      meta.blockId === undefined
+    ) return id;
   }
 
   for (const [id, ts] of state.messageIdSnapshot) {
@@ -42,6 +57,7 @@ function findCurrentMessageId(msg: any, state: DcpState): string | undefined {
 
 function resolveAddressableBoundaryId(
   msg: any,
+  stableKey: string,
   state: DcpState,
   options: { allowBlocks: boolean },
 ): { id: string; blockId?: number; text: string } | null {
@@ -55,8 +71,9 @@ function resolveAddressableBoundaryId(
 
   // Inline [dcp-id] markers are no longer injected into message content; the
   // snapshot rebuilt by injectMessageIds() is the sole addressability source.
-  // Resolve the message id by matching its (timestamp, role) in the snapshot.
-  const currentId = findCurrentMessageId(msg, state);
+  // Resolve the message ID by its persistent stable identity. Timestamp/role
+  // matching is retained only for legacy snapshots without stable IDs.
+  const currentId = findCurrentMessageId(msg, stableKey, state);
   if (currentId) return { id: currentId, text };
 
   return null;
@@ -73,15 +90,17 @@ export function detectCompressionCandidate(
   if (contextPercent < settings.minContextPercent) return null;
 
   const boundaries: CandidateBoundary[] = [];
-  for (const msg of messages) {
-    const boundary = resolveAddressableBoundaryId(msg, _state, { allowBlocks: true });
+  const stableKeys = stableMessageKeys(messages);
+  for (let index = 0; index < messages.length; index++) {
+    const msg = messages[index];
+    const boundary = resolveAddressableBoundaryId(msg, stableKeys[index]!, _state, { allowBlocks: true });
     if (!boundary) continue;
     if (!Number.isFinite(msg.timestamp)) continue;
     boundaries.push({
       id: boundary.id,
       role: msg.role ?? "",
       timestamp: msg.timestamp,
-      tokenEstimate: estimateMessageTokens(msg),
+      tokenEstimate: _state.messageMetaSnapshot.get(boundary.id)?.tokenEstimate ?? estimateMessageTokens(msg),
       blockId: boundary.blockId,
       isSystemReminder: boundary.text.includes("<dcp-system-reminder>"),
     });
@@ -153,15 +172,17 @@ export function detectMessageCompressionCandidates(
   if (contextPercent < settings.minContextPercent) return [];
 
   const boundaries: CandidateBoundary[] = [];
-  for (const msg of messages) {
-    const boundary = resolveAddressableBoundaryId(msg, state, { allowBlocks: false });
+  const stableKeys = stableMessageKeys(messages);
+  for (let index = 0; index < messages.length; index++) {
+    const msg = messages[index];
+    const boundary = resolveAddressableBoundaryId(msg, stableKeys[index]!, state, { allowBlocks: false });
     if (!boundary || boundary.blockId !== undefined) continue;
     if (!Number.isFinite(msg.timestamp)) continue;
     boundaries.push({
       id: boundary.id,
       role: msg.role ?? "",
       timestamp: msg.timestamp,
-      tokenEstimate: estimateMessageTokens(msg),
+      tokenEstimate: state.messageMetaSnapshot.get(boundary.id)?.tokenEstimate ?? estimateMessageTokens(msg),
       isSystemReminder: boundary.text.includes("<dcp-system-reminder>"),
     });
   }

package/external/pi-tools-suite/src/dcp/pruner-compression-blocks.ts

@@ -1,16 +1,15 @@
 import type { DcpConfig } from "./config.js";
 import type { DcpState } from "./state.js";
 import { PASSTHROUGH_ROLES, estimateMessageTokens } from "./pruner-metadata.js";
-import { stableMessageId } from "./pruner-message-ids.js";
+import { stableMessageKeys } from "./pruner-message-ids.js";
 import { writeDcpDebugLog } from "./debug-log.js";
 
-function messageMatchesBoundary(msg: any, messageIndex: number, stableId: string | undefined, timestamp: number): boolean {
-  if (stableId && stableMessageId(msg, messageIndex) === stableId) return true;
-  return msg.timestamp === timestamp;
-}
-
 function findBoundaryIndex(messages: any[], stableId: string | undefined, timestamp: number): number {
-  return messages.findIndex((m, index) => messageMatchesBoundary(m, index, stableId, timestamp));
+  const stableKeys = stableId ? stableMessageKeys(messages) : [];
+  return messages.findIndex((message, index) => {
+    if (stableId && stableKeys[index] === stableId) return true;
+    return message.timestamp === timestamp;
+  });
 }
 
 export interface ReconcileInheritedBlocksResult {

package/external/pi-tools-suite/src/dcp/pruner-message-ids.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import type { DcpState, MessageIdMeta } from "./state.js";
 import type { DcpConfig } from "./config.js";
 import {
@@ -6,6 +7,7 @@ import {
   estimateMessageTokens,
   extractBlockId,
   messageText,
+  stripStaleDcpMetadataLines,
 } from "./pruner-metadata.js";
 
 export interface InjectMessageIdsOptions {
@@ -13,6 +15,39 @@ export interface InjectMessageIdsOptions {
   config?: DcpConfig;
 }
 
+const ID_CARRIER_ROLES = new Set(["user", "toolResult", "bashExecution"]);
+
+function canonicalContentForStableId(msg: any): unknown {
+  if (!Array.isArray(msg?.content)) {
+    if (msg?.role === "assistant") return msg?.content ?? "";
+    return stripStaleDcpMetadataLines(typeof msg?.content === "string" ? msg.content : "");
+  }
+
+  if (msg?.role === "assistant") return msg.content;
+
+  return msg.content.flatMap((block: any) => {
+    if (!block || typeof block !== "object") return [block];
+    if (typeof block.text === "string") {
+      const text = stripStaleDcpMetadataLines(block.text);
+      return text.length > 0 ? [{ ...block, text }] : [];
+    }
+    if (typeof block.thinking === "string") {
+      const thinking = stripStaleDcpMetadataLines(block.thinking);
+      return thinking.length > 0 ? [{ ...block, thinking }] : [];
+    }
+    return [block];
+  });
+}
+
+function fallbackContentFingerprint(msg: any): string {
+  return createHash("sha256")
+    .update(String(msg?.role ?? ""))
+    .update("\u0000")
+    .update(JSON.stringify(canonicalContentForStableId(msg)))
+    .digest("hex")
+    .slice(0, 20);
+}
+
 export function stableMessageId(msg: any, fallbackIndex = 0): string {
   const candidates = [
     msg?.id,
@@ -32,10 +67,29 @@ export function stableMessageId(msg: any, fallbackIndex = 0): string {
     return `tool:${msg.toolCallId.trim()}`;
   }
 
-  if (Number.isFinite(msg?.timestamp)) return `ts:${msg.timestamp}`;
+  const blockId = extractBlockId(messageText(msg));
+  if (blockId !== undefined) return `block:${blockId}`;
+  if (Number.isFinite(msg?.timestamp)) {
+    return `ts:${msg.timestamp}:${fallbackContentFingerprint(msg)}`;
+  }
   return `idx:${fallbackIndex}`;
 }
 
+/**
+ * Return deterministic per-occurrence identities for a message sequence.
+ * Session entry IDs and content-fingerprinted fallbacks are normally unique;
+ * the suffix keeps byte-identical legacy messages from sharing one mNNN ID.
+ */
+export function stableMessageKeys(messages: any[]): string[] {
+  const occurrences = new Map<string, number>();
+  return messages.map((message, index) => {
+    const base = stableMessageId(message, index);
+    const occurrence = (occurrences.get(base) ?? 0) + 1;
+    occurrences.set(base, occurrence);
+    return occurrence === 1 ? base : `${base}#${occurrence}`;
+  });
+}
+
 function priorityForMessage(tokenEstimate: number, config: DcpConfig | undefined): "low" | "medium" | "high" {
   const settings = config?.compress?.messageMode;
   const mediumTokens = Math.max(1, settings?.mediumTokens ?? 500);
@@ -46,140 +100,128 @@ function priorityForMessage(tokenEstimate: number, config: DcpConfig | undefined
   return "low";
 }
 
-function messageIdIndex(id: string): number | undefined {
-  const match = /^m(\d+)$/.exec(id);
-  if (!match) return undefined;
-  const index = Number.parseInt(match[1]!, 10);
-  return Number.isFinite(index) ? index : undefined;
-}
-
-function summarizeMessageIds(ids: string[]): string {
-  if (ids.length === 0) return "none";
-
-  const ranges: string[] = [];
-  let start = ids[0]!;
-  let previous = ids[0]!;
-  let previousIndex = messageIdIndex(previous);
-
-  const flush = () => {
-    const startIndex = messageIdIndex(start);
-    const endIndex = messageIdIndex(previous);
-    if (
-      startIndex !== undefined &&
-      endIndex !== undefined &&
-      endIndex - startIndex >= 2
-    ) {
-      ranges.push(`${start}..${previous}`);
-    } else if (start === previous) {
-      ranges.push(start);
-    } else {
-      ranges.push(start, previous);
-    }
-  };
-
-  for (let i = 1; i < ids.length; i++) {
-    const id = ids[i]!;
-    const index = messageIdIndex(id);
-    if (previousIndex !== undefined && index === previousIndex + 1) {
-      previous = id;
-      previousIndex = index;
-      continue;
-    }
+function persistentMessageId(stableKey: string, state: DcpState): string {
+  const existing = state.messageIdsByStableId.get(stableKey);
+  if (existing) return existing;
 
-    flush();
-    start = id;
-    previous = id;
-    previousIndex = index;
-  }
-
-  flush();
-  return ranges.join(", ");
+  const id = `m${String(state.nextMessageId++).padStart(3, "0")}`;
+  state.messageIdsByStableId.set(stableKey, id);
+  return id;
 }
 
-function compactPriorityHint(ids: string[], state: DcpState): string | undefined {
-  const high: string[] = [];
-  const medium: string[] = [];
-  const blocks: string[] = [];
-
-  for (const id of ids) {
-    const meta = state.messageMetaSnapshot.get(id);
-    if (!meta) continue;
-    if (meta.priority === "high") high.push(id);
-    else if (meta.priority === "medium") medium.push(id);
-    if (meta.blockId !== undefined) blocks.push(`${id}=b${meta.blockId}`);
-  }
-
-  const parts: string[] = [];
-  if (high.length > 0) parts.push(`high=${summarizeMessageIds(high)}`);
-  if (medium.length > 0) parts.push(`medium=${summarizeMessageIds(medium)}`);
-  if (blocks.length > 0) parts.push(`blocks=${blocks.join(",")}`);
-  return parts.length > 0 ? `Hints: ${parts.join("; ")}` : undefined;
+function carrierSelfLabel(role: string): string {
+  if (role === "toolResult") return "this tool result";
+  if (role === "bashExecution") return "this bash result";
+  return "this user message";
 }
 
-export function buildMessageIdControlText(state: DcpState): string | undefined {
-  const ids = [...state.messageIdSnapshot.keys()];
-  if (ids.length === 0) return undefined;
-
-  const hint = compactPriorityHint(ids, state);
-
+function buildCarrierControlText(
+  precedingAssistantIds: string[],
+  ownId: string,
+  ownRole: string,
+  blockId: number | undefined,
+): string {
+  const assignments = [
+    ...precedingAssistantIds.map((id) => `${id}=preceding assistant message`),
+    `${ownId}=${carrierSelfLabel(ownRole)}`,
+  ];
   return [
     "<dcp-message-ids>",
-    "DCP metadata for the preceding conversation messages. IDs follow current message order; use only these IDs with compress; do not quote/output.",
-    `Current raw message IDs: ${summarizeMessageIds(ids)}${ids.length > 2 ? ` (${ids.length} messages)` : ""}`,
-    ...(hint ? [hint] : []),
+    `Stable DCP IDs (use with compress; do not quote/output): ${assignments.join("; ")}`,
+    ...(blockId === undefined ? [] : [`Active compressed block alias: b${blockId}`]),
     "</dcp-message-ids>",
   ].join("\n");
 }
 
+function appendControlToCarrier(message: any, controlText: string): void {
+  const suffix = `\n\n${controlText}`;
+  if (typeof message.content === "string") {
+    message.content += suffix;
+    return;
+  }
+  if (Array.isArray(message.content)) {
+    message.content = [...message.content, { type: "text", text: suffix }];
+    return;
+  }
+  message.content = [{ type: "text", text: controlText }];
+}
+
+/**
+ * Build the current addressability snapshot and distribute immutable ID
+ * metadata over append-only user/tool-result carriers. Assistant messages are
+ * never modified: provider-signed reasoning and function-call items must replay
+ * byte-for-byte for Responses continuation.
+ */
 export function injectMessageIds(
   messages: any[],
   state: DcpState,
   options: InjectMessageIdsOptions = {},
 ): void {
-  // Rebuild into local maps and assign once at the end, so readers (compress
-  // tool, candidates, provider payload builder) never observe a transiently
-  // empty snapshot mid-rebuild. The previous clear()-then-set loop exposed a
-  // window where any concurrent reader saw `messageIdSnapshot` as empty,
-  // which surfaced to the model as `Current raw message IDs: none`.
-  const nextIdSnapshot = new Map<string, number>()
-  const nextMetaSnapshot = new Map<string, MessageIdMeta>()
-
-  let counter = 1;
+  const nextIdSnapshot = new Map<string, number>();
+  const nextMetaSnapshot = new Map<string, MessageIdMeta>();
+  const stableKeys = stableMessageKeys(messages);
+  const assignedIds = new Map<number, string>();
+  const assignedMeta = new Map<number, MessageIdMeta>();
 
   for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
     const msg = messages[messageIndex];
-    const role: string = msg.role ?? "";
-
-    // Skip PI-internal passthrough messages
-    if (PASSTHROUGH_ROLES.has(role)) continue;
-    // Skip non-eligible roles
-    if (!ID_ELIGIBLE_ROLES.has(role)) continue;
-
-    const id = "m" + String(counter).padStart(3, "0");
-    counter++;
+    const role: string = msg?.role ?? "";
+    if (PASSTHROUGH_ROLES.has(role) || !ID_ELIGIBLE_ROLES.has(role)) continue;
+    if (!Number.isFinite(msg?.timestamp)) continue;
 
+    const stableKey = stableKeys[messageIndex]!;
+    const id = persistentMessageId(stableKey, state);
     const originalText = messageText(msg);
     const blockId = extractBlockId(originalText);
     const tokenEstimate = estimateMessageTokens(msg);
-    const priority = priorityForMessage(tokenEstimate, options.config);
-    const rawStableId = stableMessageId(msg, messageIndex);
-
-    if (msg.timestamp !== undefined) {
-      nextIdSnapshot.set(id, msg.timestamp);
-      nextMetaSnapshot.set(id, {
-        timestamp: msg.timestamp,
-        stableId: rawStableId,
-        role,
-        blockId,
-        toolCallId: typeof msg.toolCallId === "string" ? msg.toolCallId : undefined,
-        toolName: typeof msg.toolName === "string" ? msg.toolName : undefined,
-        text: originalText,
-        tokenEstimate,
-        priority,
-      });
+
+    assignedIds.set(messageIndex, id);
+    assignedMeta.set(messageIndex, {
+      timestamp: msg.timestamp,
+      stableId: stableKey,
+      role,
+      blockId,
+      toolCallId: typeof msg.toolCallId === "string" ? msg.toolCallId : undefined,
+      toolName: typeof msg.toolName === "string" ? msg.toolName : undefined,
+      text: originalText,
+      tokenEstimate,
+      priority: priorityForMessage(tokenEstimate, options.config),
+    });
+  }
+
+  const publish = (messageIndex: number): void => {
+    const id = assignedIds.get(messageIndex);
+    const meta = assignedMeta.get(messageIndex);
+    if (!id || !meta) return;
+    nextIdSnapshot.set(id, meta.timestamp);
+    nextMetaSnapshot.set(id, meta);
+  };
+  const pendingAssistantIndexes: number[] = [];
+  for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+    const message = messages[messageIndex];
+    const role: string = message?.role ?? "";
+    const id = assignedIds.get(messageIndex);
+    if (!id) continue;
+
+    if (role === "assistant") {
+      pendingAssistantIndexes.push(messageIndex);
+      continue;
     }
+    if (!ID_CARRIER_ROLES.has(role)) continue;
+
+    for (const pendingIndex of pendingAssistantIndexes) publish(pendingIndex);
+    publish(messageIndex);
+    const pendingAssistantIds = pendingAssistantIndexes
+      .map((pendingIndex) => assignedIds.get(pendingIndex))
+      .filter((pendingId): pendingId is string => pendingId !== undefined);
+    const blockId = assignedMeta.get(messageIndex)?.blockId;
+    appendControlToCarrier(
+      message,
+      buildCarrierControlText(pendingAssistantIds, id, role, blockId),
+    );
+    pendingAssistantIndexes.length = 0;
   }
 
-  state.messageIdSnapshot = nextIdSnapshot
-  state.messageMetaSnapshot = nextMetaSnapshot
+  state.messageIdSnapshot = nextIdSnapshot;
+  state.messageMetaSnapshot = nextMetaSnapshot;
 }

package/external/pi-tools-suite/src/dcp/pruner-metadata.ts

@@ -182,7 +182,7 @@ export function extractMessageId(text: string): string | undefined {
   )?.[1];
 }
 
-function stripStaleDcpMetadataLines(text: string): string {
+export function stripStaleDcpMetadataLines(text: string): string {
   if (!text.includes("<dcp-") && !text.includes("[dcp-")) return text;
 
   const lines = text.split("\n");
@@ -238,21 +238,29 @@ function stripStaleDcpMetadataLines(text: string): string {
 
 function stripStaleDcpMetadataFromAssistantBlock(block: any): any | undefined {
   if (!block || typeof block !== "object") return block;
-  const next = { ...block };
+  const textCanChange = typeof block.text === "string" &&
+    (block.text.includes("<dcp-") || block.text.includes("[dcp-"));
+  const thinkingCanChange = typeof block.thinking === "string" &&
+    (block.thinking.includes("<dcp-") || block.thinking.includes("[dcp-"));
+  if (!textCanChange && !thinkingCanChange) return block;
+
+  let next = block;
   let touched = false;
 
-  if (typeof next.text === "string") {
-    const stripped = stripStaleDcpMetadataLines(next.text);
-    if (stripped !== next.text) {
+  if (typeof block.text === "string") {
+    const stripped = stripStaleDcpMetadataLines(block.text);
+    if (stripped !== block.text) {
+      next = { ...next };
       touched = true;
       next.text = stripped;
       delete next.textSignature;
     }
   }
 
-  if (typeof next.thinking === "string") {
-    const stripped = stripStaleDcpMetadataLines(next.thinking);
-    if (stripped !== next.thinking) {
+  if (typeof block.thinking === "string") {
+    const stripped = stripStaleDcpMetadataLines(block.thinking);
+    if (stripped !== block.thinking) {
+      if (!touched) next = { ...next };
       touched = true;
       next.thinking = stripped;
       delete next.thinkingSignature;
@@ -265,20 +273,23 @@ function stripStaleDcpMetadataFromAssistantBlock(block: any): any | undefined {
 }
 
 export function stripStaleDcpMetadataFromAssistantMessage(message: any): any {
-  if (!message || typeof message !== "object" || message.role !== "assistant") return message;
-  return stripStaleDcpMetadataFromMessage(message);
+  return message;
 }
 
 export function stripStaleDcpMetadataFromMessage(message: any): any {
   if (!message || typeof message !== "object") return message;
+  // Assistant content may contain provider-signed reasoning, text, or tool-call
+  // items. Even DCP-looking text must replay byte-for-byte once persisted.
+  if (message.role === "assistant") return message;
   if (typeof message.content === "string") {
-    return { ...message, content: stripStaleDcpMetadataLines(message.content) };
+    const stripped = stripStaleDcpMetadataLines(message.content);
+    return stripped === message.content ? message : { ...message, content: stripped };
   }
   if (!Array.isArray(message.content)) return message;
-  return {
-    ...message,
-    content: message.content
-      .map(stripStaleDcpMetadataFromAssistantBlock)
-      .filter((block: any) => block !== undefined),
-  };
+  const content = message.content
+    .map(stripStaleDcpMetadataFromAssistantBlock)
+    .filter((block: any) => block !== undefined);
+  const unchanged = content.length === message.content.length &&
+    content.every((block: any, index: number) => block === message.content[index]);
+  return unchanged ? message : { ...message, content };
 }