@linxiraos/pi-agent-core 1.1.14 → 1.1.16

package/src/compaction/openai.ts

@@ -66,14 +66,14 @@ export * from "./compaction-v2-streaming";
 export const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompaction";
 
 /**
- * Hard ceiling on remote compaction HTTP requests. Unlike every provider
- * stream (guarded by first-event/idle watchdogs in pi-ai), these are raw
- * fetches awaiting one non-streamed JSON body — a connection silently dropped
- * by a middlebox would otherwise hang the whole compaction pipeline forever
- * (frozen "Auto context-full maintenance…" spinner, manual /compact queueing
- * behind it). On timeout the caller falls back to local summarization.
+ * Hard ceiling on remote compaction HTTP requests (5 minutes). Unlike every
+ * provider stream (guarded by first-event/idle watchdogs in pi-ai), these are
+ * raw fetches awaiting one non-streamed JSON body — a connection silently
+ * dropped by a middlebox would otherwise hang the whole compaction pipeline
+ * forever (frozen "Auto context-full maintenance…" spinner, manual /compact
+ * queueing behind it). On timeout the caller falls back to local summarization.
  */
-export const REMOTE_COMPACTION_TIMEOUT_MS = 180_000;
+export const REMOTE_COMPACTION_TIMEOUT_MS = 300_000;
 
 const DEFAULT_AZURE_API_VERSION = "v1";
 
@@ -282,15 +282,22 @@ export interface RemoteCompactionResponse {
 // OpenAI provider gating + endpoint resolution
 // ============================================================================
 
-function isOpenAiRemoteCompactionApi(api: Api | undefined): boolean {
+export function isOpenAiRemoteCompactionApi(api: Api | undefined): boolean {
 	return api === "openai-responses" || api === "azure-openai-responses" || api === "openai-codex-responses";
 }
 
 export function shouldUseOpenAiRemoteCompaction(model: Model): boolean {
 	if (model.remoteCompaction?.enabled === false) return false;
-	if (model.provider === "openai" || model.provider === "openai-codex") return true;
+	const compactionApi = model.remoteCompaction?.api ?? model.api;
+	// ChatGPT's Codex backend exposes V2 compaction on /codex/responses, but
+	// does not expose the OpenAI V1 /responses/compact endpoint. Only use the
+	// V1 path for Codex when an explicit compatible endpoint was configured.
+	if (model.provider === "openai-codex") {
+		return (model.remoteCompaction?.endpoint?.trim().length ?? 0) > 0;
+	}
+	if (model.provider === "openai") return true;
 	if (model.remoteCompaction?.enabled !== true) return false;
-	return isOpenAiRemoteCompactionApi(model.remoteCompaction.api ?? model.api);
+	return isOpenAiRemoteCompactionApi(compactionApi);
 }
 
 function resolveOpenAiCompactEndpoint(model: Model): string {

package/src/compaction/prompts/anthropic-compaction-instructions.md

@@ -0,0 +1,17 @@
+{{#if retainedTail}}
+SCOPE: The conversation's final {{#when retainedTail.count "==" 1}}{{retainedTail.role}} message stays{{else}}{{retainedTail.count}} messages, starting with a {{retainedTail.role}} message, stay{{/when}} in context verbatim after your summary. Summarize ONLY the history before those messages. You MUST NOT restate anything from those final messages — the reader sees them right after the summary — and you MUST treat them as the most recent state when describing progress and next steps.
+{{else}}
+SCOPE: The conversation above is the transcript to summarize. The API replaces everything before your summary with it, so nothing you leave out survives into the next context window.
+{{/if}}
+
+{{#if extraContext}}
+{{extraContext}}
+
+{{/if}}
+{{basePrompt}}
+{{#if customInstructions}}
+
+Additional focus: {{customInstructions}}
+{{/if}}
+
+You MUST NOT call any tools while writing the summary; respond with the summary text only.

package/src/index.ts

@@ -14,6 +14,8 @@ export * from "./proxy";
 export * from "./replay-policy";
 // Run-level telemetry collector + aggregators
 export * from "./run-collector";
+// Speculative execution coordinator
+export * from "./speculative-execution";
 // Telemetry
 export * from "./telemetry";
 // Thinking selectors

package/src/proxy.ts

@@ -20,8 +20,7 @@ import {
 	type StreamingPartialJsonCarrier,
 	setStreamingPartialJson,
 } from "@linxiraos/pi-ai/utils/block-symbols";
-import { calculateCost } from "@linxiraos/pi-catalog/models";
-import { parseStreamingJson, readSseJson } from "@linxiraos/pi-utils";
+import { parseStreamingJson, parseStreamingJsonThrottled, readSseJson } from "@linxiraos/pi-utils";
 
 // Event stream adapter for proxy SSE events
 export class ProxyMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
@@ -118,6 +117,10 @@ export function streamProxy(model: Model, context: Context, options: ProxyStream
 		};
 
 		let response: Response | null = null;
+		// Declared outside try so the disconnect path (catch) can finalize
+		// still-buffered tool-call arguments before emitting the error event.
+		const partialJsonByIndex = new Map<number, string>();
+		const parsedLenByIndex = new Map<number, number>();
 		const abortHandler = () => {
 			const body = response?.body;
 			if (body) {
@@ -166,12 +169,11 @@ export function streamProxy(model: Model, context: Context, options: ProxyStream
 			}
 
 			let sawTerminalEvent = false;
-			const partialJsonByIndex = new Map<number, string>();
 			for await (const event of readSseJson<ProxyAssistantMessageEvent>(
 				response.body as ReadableStream<Uint8Array>,
 				options.signal,
 			)) {
-				const parsedEvent = processProxyEvent(model, event, partial, partialJsonByIndex);
+				const parsedEvent = processProxyEvent(event, partial, partialJsonByIndex, parsedLenByIndex);
 				if (parsedEvent) {
 					if (parsedEvent.type === "done" || parsedEvent.type === "error") {
 						sawTerminalEvent = true;
@@ -194,6 +196,10 @@ export function streamProxy(model: Model, context: Context, options: ProxyStream
 			const reason = options.signal?.aborted ? "aborted" : "error";
 			partial.stopReason = reason;
 			partial.errorMessage = errorMessage;
+			// Disconnect/abort path: no terminal event ran, so trailing
+			// throttled deltas never reached content.arguments. Finalize
+			// them here so the persisted/retried transcript is complete.
+			finalizeBufferedArguments(partial, partialJsonByIndex);
 			scrubPartialJson(partial);
 			stream.push({
 				type: "error",
@@ -233,10 +239,10 @@ function scrubPartialJson(partial: AssistantMessage): void {
  * reads as still-streaming.
  */
 function processProxyEvent(
-	model: Model,
 	proxyEvent: ProxyAssistantMessageEvent,
 	partial: AssistantMessage,
 	partialJsonByIndex: Map<number, string>,
+	parsedLenByIndex: Map<number, number>,
 ): AssistantMessageEvent | undefined {
 	switch (proxyEvent.type) {
 		case "start":
@@ -337,13 +343,22 @@ function processProxyEvent(
 				[kStreamingPartialJson]: "",
 			} as ToolCall & StreamingPartialJsonCarrier;
 			partialJsonByIndex.set(proxyEvent.contentIndex, "");
+			parsedLenByIndex.set(proxyEvent.contentIndex, 0);
 			return { type: "toolcall_start", contentIndex: proxyEvent.contentIndex, partial };
 		case "toolcall_delta": {
 			const content = partial.content[proxyEvent.contentIndex];
 			if (content?.type === "toolCall") {
 				const acc = (partialJsonByIndex.get(proxyEvent.contentIndex) ?? "") + proxyEvent.delta;
 				partialJsonByIndex.set(proxyEvent.contentIndex, acc);
-				content.arguments = parseStreamingJson(acc) || {};
+				// Geometric throttle (same contract as native providers): the
+				// authoritative parse lands at toolcall_end; mid-stream
+				// previews refresh at most ~3% late on large buffers.
+				const lastLen = parsedLenByIndex.get(proxyEvent.contentIndex) ?? 0;
+				const parsed = parseStreamingJsonThrottled(acc, lastLen);
+				if (parsed !== null) {
+					content.arguments = parsed.value || {};
+					parsedLenByIndex.set(proxyEvent.contentIndex, parsed.parsedLen);
+				}
 				setStreamingPartialJson(content, acc);
 				partial.content[proxyEvent.contentIndex] = { ...content }; // Trigger reactivity
 				return {
@@ -359,7 +374,13 @@ function processProxyEvent(
 		case "toolcall_end": {
 			const content = partial.content[proxyEvent.contentIndex];
 			if (content?.type === "toolCall") {
+				// Authoritative final parse (mirrors native providers): the
+				// throttle may have skipped trailing deltas, so the last
+				// parsed arguments can lag the accumulated buffer.
+				const acc = partialJsonByIndex.get(proxyEvent.contentIndex);
+				if (acc !== undefined && acc.length > 0) content.arguments = parseStreamingJson(acc) || {};
 				partialJsonByIndex.delete(proxyEvent.contentIndex);
+				parsedLenByIndex.delete(proxyEvent.contentIndex);
 				clearStreamingPartialJson(content);
 				return {
 					type: "toolcall_end",
@@ -375,8 +396,10 @@ function processProxyEvent(
 			partial.stopReason = proxyEvent.reason;
 			partial.usage = proxyEvent.usage;
 			if (proxyEvent.content !== undefined) partial.content = proxyEvent.content;
-			calculateCost(model, partial.usage);
+			else finalizeBufferedArguments(partial, partialJsonByIndex);
 			scrubPartialJson(partial);
+			partialJsonByIndex.clear();
+			parsedLenByIndex.clear();
 			return { type: "done", reason: proxyEvent.reason, message: partial };
 
 		case "error":
@@ -384,8 +407,26 @@ function processProxyEvent(
 			partial.errorMessage = proxyEvent.errorMessage;
 			partial.usage = proxyEvent.usage;
 			if (proxyEvent.content !== undefined) partial.content = proxyEvent.content;
-			calculateCost(model, partial.usage);
+			else finalizeBufferedArguments(partial, partialJsonByIndex);
 			scrubPartialJson(partial);
+			partialJsonByIndex.clear();
+			parsedLenByIndex.clear();
 			return { type: "error", reason: proxyEvent.reason, error: partial };
 	}
 }
+
+/**
+ * Authoritatively parse every still-buffered tool-call argument accumulator
+ * into its content block. Terminal `done`/`error` events without a preceding
+ * `toolcall_end` (and with `content` omitted) finalize the partial message as
+ *-is; without this, trailing deltas below the throttle gate never reach
+ * `content.arguments` and the finalized call carries stale arguments.
+ */
+function finalizeBufferedArguments(partial: AssistantMessage, partialJsonByIndex: Map<number, string>): void {
+	if (partialJsonByIndex.size === 0) return;
+	for (const [index, acc] of partialJsonByIndex) {
+		if (acc.length === 0) continue;
+		const content = partial.content[index];
+		if (content?.type === "toolCall") content.arguments = parseStreamingJson(acc) || {};
+	}
+}