pi-ui-extend 1.0.37 → 1.0.39

package/external/pi-tools-suite/src/dcp/index.ts

@@ -45,13 +45,7 @@ import {
 	resolveContextThresholds,
 	estimateTokens,
 } from "./pruner.js"
-import {
-	stripStaleDcpMetadataFromAssistantMessage,
-	stripStaleDcpMetadataFromMessage,
-} from "./pruner-metadata.js"
-import {
-	buildMessageIdControlText,
-} from "./pruner-message-ids.js"
+import { stripStaleDcpMetadataFromMessage } from "./pruner-metadata.js"
 import { summarizeDcpState, writeDcpDebugLog } from "./debug-log.js"
 import type { DcpNudgeType } from "./pruner-types.js"
 import { registerCompressTool } from "./compress-tool.js"
@@ -119,104 +113,6 @@ function isDcpControlPlaneMessage(message: any): boolean {
 	return message?.role === "custom" && DCP_CONTROL_PLANE_CUSTOM_TYPES.has(message.customType)
 }
 
-const DCP_PROVIDER_CONTROL_HEADER = "DCP message ID control data (do not quote or output):"
-
-function appendTextToContent(content: unknown, text: string): unknown {
-	if (typeof content === "string") return `${content}\n\n${text}`
-	if (Array.isArray(content)) {
-		const textType = content.some((part: any) => part?.type === "input_text") ? "input_text" : "text"
-		return [...content, { type: textType, text }]
-	}
-	return text
-}
-
-function appendDcpControlToMessages(messages: unknown, text: string): unknown {
-	if (!Array.isArray(messages)) return messages
-	const block = `${DCP_PROVIDER_CONTROL_HEADER}\n${text}`
-
-	// Keep DCP's volatile ID map at the tail of the provider context instead of
-	// mutating the stable system/developer prefix. Prefix cache reuse is much
-	// better when only the newest transcript item changes on each request.
-	let targetIndex = -1
-	for (let index = messages.length - 1; index >= 0; index--) {
-		const message = messages[index] as any
-		if (!message || typeof message !== "object") continue
-		// Responses items such as reasoning/function_call_output do not accept a
-		// `content` field. Keep a function output at the tail by appending to its
-		// valid `output` string; otherwise scan back to an actual message item.
-		if (typeof message.type === "string" && message.type !== "message" && message.role === undefined) {
-			if (message.type === "function_call_output" && typeof message.output === "string") {
-				return messages.map((candidate: any, candidateIndex) => candidateIndex === index
-					? { ...candidate, output: `${candidate.output}\n\n${block}` }
-					: candidate)
-			}
-			continue
-		}
-		if (message.role === "system" || message.role === "developer") continue
-		targetIndex = index
-		break
-	}
-
-	if (targetIndex < 0) {
-		targetIndex = messages.findIndex((message: any) =>
-			message?.role === "system" || message?.role === "developer"
-		)
-	}
-
-	if (targetIndex >= 0) {
-		return messages.map((message: any, index) => index === targetIndex
-			? { ...message, content: appendTextToContent(message.content, block) }
-			: message)
-	}
-	return [{ role: "system", content: block }, ...messages]
-}
-
-function appendDcpControlToAnthropicSystem(system: unknown, text: string): unknown {
-	const block = `${DCP_PROVIDER_CONTROL_HEADER}\n${text}`
-	if (typeof system === "string") return `${system}\n\n${block}`
-	if (Array.isArray(system)) return [...system, { type: "text", text: block }]
-	if (system === undefined || system === null) return [{ type: "text", text: block }]
-	return system
-}
-
-function appendDcpControlToGoogleSystemInstruction(systemInstruction: unknown, text: string): unknown {
-	const block = `${DCP_PROVIDER_CONTROL_HEADER}\n${text}`
-	if (typeof systemInstruction === "string") return `${systemInstruction}\n\n${block}`
-	if (systemInstruction === undefined || systemInstruction === null) return block
-	return systemInstruction
-}
-
-function appendDcpControlToProviderPayload(payload: unknown, text: string): unknown {
-	if (Array.isArray(payload)) return appendDcpControlToMessages(payload, text)
-	if (!payload || typeof payload !== "object") return payload
-	const record = payload as Record<string, unknown>
-
-	if (Array.isArray(record.input)) {
-		return { ...record, input: appendDcpControlToMessages(record.input, text) }
-	}
-
-	if (Array.isArray(record.messages)) {
-		return { ...record, messages: appendDcpControlToMessages(record.messages, text) }
-	}
-
-	if ("system" in record) {
-		return { ...record, system: appendDcpControlToAnthropicSystem(record.system, text) }
-	}
-
-	if (record.config && typeof record.config === "object") {
-		const config = record.config as Record<string, unknown>
-		return {
-			...record,
-			config: {
-				...config,
-				systemInstruction: appendDcpControlToGoogleSystemInstruction(config.systemInstruction, text),
-			},
-		}
-	}
-
-	return payload
-}
-
 // ---------------------------------------------------------------------------
 // Module export
 // ---------------------------------------------------------------------------
@@ -344,15 +240,6 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 		}
 	})
 
-	// ── 7b. message_end: never persist provider-echoed DCP control markers ─────
-	pi.on("message_end", async (event, ctx) => {
-		const effectiveConfig = configForContext(ctx)
-		if (!effectiveConfig.enabled || event.message?.role !== "assistant") return undefined
-
-		const sanitized = stripStaleDcpMetadataFromAssistantMessage(event.message)
-		return { message: sanitized }
-	})
-
 	// ── 8. tool_call: record input args for dedup / purge fingerprinting ───────
 	pi.on("tool_call", async (event, _ctx) => {
 		if (!state.toolCalls.has(event.toolCallId)) {
@@ -418,7 +305,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				inputMessages: event.messages.length,
 				filteredMessages: contextMessages.length,
 				outputMessages: messages.length,
-				messageIdControl: "provider-payload",
+				messageIdControl: "distributed-carriers",
 				state: summarizeDcpState(state),
 				...details,
 			}, ctx)
@@ -454,7 +341,20 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				await saveDcpState(ctx, state)
 			}
 		}
+		const prunedToolCountBeforeCheckpoint = state.prunedToolIds.size
 		let prunedMessages = applyPruning(contextMessages, state, effectiveConfig)
+		const automaticPrunesCommitted = state.prunedToolIds.size - prunedToolCountBeforeCheckpoint
+		if (automaticPrunesCommitted > 0) {
+			const clearedAnchors = clearDcpNudgeAnchors(state)
+			await saveDcpState(ctx, state)
+			writeDcpDebugLog(effectiveConfig, "prune.tool_checkpoint", {
+				committed: automaticPrunesCommitted,
+				clearedAnchors,
+				turn: state.currentTurn,
+				blockId: state.lastAutomaticPruneBlockId,
+				state: summarizeDcpState(state),
+			}, ctx)
+		}
 		let candidate = null as ReturnType<typeof detectCompressionCandidate>
 		let messageCandidates = [] as ReturnType<typeof detectMessageCompressionCandidates>
 		let emergencySelection = null as ReturnType<typeof analyzeEmergencyCurrentTurn> | null
@@ -746,6 +646,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				)
 				if (emergencyPruneResult.prunedToolCallIds.length > 0) {
 					prunedMessages = applyPruning(contextMessages, state, effectiveConfig)
+					const clearedAnchors = clearDcpNudgeAnchors(state)
 					state.consecutiveIgnoredStrongNudges = 0
 					emergencySelection = analyzeEmergencyCurrentTurn(prunedMessages, state, effectiveConfig)
 					messageCandidates = emergencyCurrentTurnMessageCandidates(emergencySelection, effectiveConfig)
@@ -758,6 +659,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 						targetContextPercent,
 						targetRecoveryTokens,
 						prunedOutputs: emergencyPruneResult.prunedToolCallIds.length,
+						clearedAnchors,
 						estimatedTokensRecovered: emergencyPruneResult.estimatedTokensRecovered,
 						estimatedContextPercentAfter: Math.max(
 							0,
@@ -786,7 +688,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 					prunedMessages,
 					state,
 					nudgeType,
-					{ contextPercent },
+					{ contextPercent, renderedReminder: nudgeText },
 				)
 				if (anchorResult.anchor) {
 					if (anchorResult.updated) {
@@ -836,10 +738,10 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				anchor.type === "context-strong" || anchor.type === "context-soft",
 			)
 		}
-		applyAnchoredNudges(prunedMessages, state, (anchor) =>
+		const nudgeApplication = applyAnchoredNudges(prunedMessages, state, (anchor) =>
 			appendConcreteNudgeGuidance(baseNudgeText(anchor.type), candidate, messageCandidates, state),
 		)
-		if (state.nudgeAnchors.length !== anchorsBeforeFinalization) {
+		if (state.nudgeAnchors.length !== anchorsBeforeFinalization || nudgeApplication.stateChanged) {
 			await saveDcpState(ctx, state)
 		}
 
@@ -851,7 +753,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 		})
 	})
 
-	// ── 10b. before_provider_request: inject DCP IDs outside transcript ────────
+	// ── 10b. before_provider_request: observe accepted tool-result payloads ────
 	pi.on("before_provider_request", async (event, ctx) => {
 		const effectiveConfig = configForContext(ctx)
 		pendingProviderToolIds.clear()
@@ -868,16 +770,16 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 			}
 		}
 
-		const controlText = buildMessageIdControlText(state)
-		if (!controlText) return undefined
-
-		const payload = appendDcpControlToProviderPayload(event.payload, controlText)
 		writeDcpDebugLog(effectiveConfig, "provider_payload.message_ids", {
-			injected: payload !== event.payload,
+			injected: false,
+			delivery: "distributed-carriers",
 			pendingToolResults: pendingProviderToolIds.size,
 			state: summarizeDcpState(state),
 		}, ctx)
-		return payload === event.payload ? undefined : payload
+		// IDs are already attached to deterministic user/tool-result context
+		// carriers. Replacing the payload here would move metadata from the old
+		// tail to the new one and break strict append-only Responses continuation.
+		return undefined
 	})
 
 	// Promote pending IDs only after the provider accepted the exact payload.

package/external/pi-tools-suite/src/dcp/prompts.ts

@@ -118,9 +118,9 @@ You specify boundaries by ID using the injected metadata IDs present in the conv
 - \`mNNN\` IDs identify raw messages (3 digits, zero-padded, e.g. \`m001\`, \`m042\`)
 - \`bN\` IDs identify previously compressed blocks
 
-Current raw message IDs are provided in hidden DCP control metadata at the end of the model context.
+Raw message IDs are provided in hidden DCP control metadata attached to stable user/tool-result carriers. IDs may be sparse; determine range order from where their carriers appear in context, not from the numeric suffix.
 Some message-compression candidate hints include a low/medium/high priority; prefer high-priority stale message IDs for message-mode compression when a full range would be too broad.
-The ID reference line appears at the end of the message it belongs to — it identifies the message above it, not the one below it.
+Each carrier's metadata labels that carrier and any immediately preceding assistant message(s).
 Treat these reference lines as boundary metadata only, not as tool result content.
 
 Rules:

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 {