@gajae-code/agent-core 0.10.2 → 0.11.1

package/src/agent.ts

@@ -20,6 +20,7 @@ import {
 	type ToolChoice,
 	type ToolResultMessage,
 } from "@gajae-code/ai";
+import { extractHttpStatusFromError } from "@gajae-code/utils";
 import { agentLoop, agentLoopContinue } from "./agent-loop";
 import type { AppendOnlyContextManager } from "./append-only-context";
 import type { HarmonyAuditEvent } from "./harmony-leak";
@@ -32,6 +33,12 @@ import type {
 	AgentState,
 	AgentTool,
 	AgentToolContext,
+	ManagedAttemptContinuation,
+	ManagedAttemptContinuationOwnership,
+	ManagedAttemptDecision,
+	ManagedAttemptOutcome,
+	ManagedLogicalRunId,
+	RunTerminalRequest,
 	StreamFn,
 	ToolCallContext,
 } from "./types";
@@ -88,6 +95,13 @@ function refreshToolChoiceForActiveTools(
 	return tools.some(tool => tool.name === toolName) ? toolChoice : undefined;
 }
 
+export class ManagedCursorInvariantError extends Error {
+	constructor(message: string = "Managed Cursor attempt received a provider-side tool result") {
+		super(message);
+		this.name = "ManagedCursorInvariantError";
+	}
+}
+
 export class AgentBusyError extends Error {
 	constructor(
 		message: string = "Agent is already processing. Use steer() or followUp() to queue messages, or wait for completion.",
@@ -276,6 +290,16 @@ export interface AgentOptions {
 
 export interface AgentPromptOptions {
 	toolChoice?: ToolChoice;
+	/** Disable transport replay; fallback accounting is owned by the caller. */
+	fallbackManaged?: boolean;
+	/** Called synchronously after this invocation claims the agent run, before asynchronous provider work. */
+	onRunAccepted?: () => void;
+	/** Called once immediately before every managed upstream request. */
+	nextFallbackAttempt?: AgentLoopConfig["nextFallbackAttempt"];
+	/** Called after a managed upstream request is accepted and committed. */
+	onManagedAttemptAccepted?: AgentLoopConfig["onManagedAttemptAccepted"];
+	/** Receives a discarded managed attempt without exposing assistant lifecycle events. */
+	onManagedAttemptOutcome?: AgentLoopConfig["onManagedAttemptOutcome"];
 }
 
 /** Buffered Cursor tool result with text position at time of call */
@@ -332,6 +356,8 @@ export class Agent {
 	#resolveRunningPrompt?: () => void;
 	#runSequence = 0;
 	#activeRunId?: number;
+	#continuationGeneration = 0;
+	#activeFallbackManaged = false;
 	#kimiApiFormat?: "openai" | "anthropic";
 	#preferWebsockets?: boolean;
 	#transformToolCallArguments?: (args: Record<string, unknown>, toolName: string) => Record<string, unknown>;
@@ -345,6 +371,7 @@ export class Agent {
 	#onHarmonyLeak?: (event: HarmonyAuditEvent) => void | Promise<void>;
 	#onBeforeYield?: () => Promise<void> | void;
 	#shouldPause?: AgentLoopConfig["shouldPause"];
+	#maintainContext?: AgentLoopConfig["maintainContext"];
 	#telemetry?: AgentLoopConfig["telemetry"];
 	#appendOnlyContext?: AppendOnlyContextManager;
 
@@ -354,6 +381,8 @@ export class Agent {
 
 	/** Buffered Cursor tool results with text length at time of call (for correct ordering) */
 	#cursorToolResultBuffer: CursorToolResultEntry[] = [];
+	#terminalizedLogicalRunIds = new Set<ManagedLogicalRunId>();
+	#managedLogicalRunOwner?: ManagedLogicalRunId;
 
 	streamFn: StreamFn;
 	getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
@@ -680,6 +709,10 @@ export class Agent {
 		this.#shouldPause = fn;
 	}
 
+	setMaintainContext(fn: AgentLoopConfig["maintainContext"] | undefined): void {
+		this.#maintainContext = fn;
+	}
+
 	emitExternalEvent(event: AgentEvent) {
 		switch (event.type) {
 			case "message_start":
@@ -1088,23 +1121,30 @@ export class Agent {
 	 * #runLoop guards every state mutation with a run id.
 	 */
 	forceAbort(reason = "Force aborted"): boolean {
-		const hadActiveRun = this.#runningPrompt !== undefined || this.#state.isStreaming;
+		const runId = this.#activeRunId;
+		const managedLogicalRunId = this.#managedLogicalRunOwner;
+		const hadActiveRun = runId !== undefined && (this.#runningPrompt !== undefined || this.#state.isStreaming);
 		if (!hadActiveRun) return false;
 
 		this.#abortController?.abort(reason);
-		this.#activeRunId = undefined;
+		this.#continuationGeneration++;
 		this.#state.isStreaming = false;
 		this.#state.streamMessage = null;
 		this.#state.pendingToolCalls = new Set<string>();
 		this.#abortController = undefined;
 		this.#cursorToolResultBuffer = [];
+		this.#managedLogicalRunOwner = undefined;
 
 		const resolve = this.#resolveRunningPrompt;
 		this.#runningPrompt = undefined;
 		this.#resolveRunningPrompt = undefined;
+		this.#activeRunId = undefined;
 		resolve?.();
-
-		this.#emit({ type: "agent_end", messages: [] });
+		if (this.#activeFallbackManaged) {
+			this.requestRunTerminal(managedLogicalRunId ?? runId, { stopReason: "cancelled" });
+		} else {
+			this.#finalizeRun(runId, { type: "agent_end", messages: [] });
+		}
 		return true;
 	}
 
@@ -1112,12 +1152,56 @@ export class Agent {
 		return this.#runningPrompt ?? Promise.resolve();
 	}
 
+	/** The active per-attempt run identifier. */
+	get activeRunId(): number | undefined {
+		return this.#activeRunId;
+	}
+
+	/**
+	 * Stable identifier for the active managed logical run, shared by every retry
+	 * attempt. Pass this value to requestRunTerminal(); never retain activeRunId
+	 * for managed terminal completion.
+	 */
+	get currentManagedLogicalRunId(): ManagedLogicalRunId | undefined {
+		return this.#managedLogicalRunOwner;
+	}
+
+	/**
+	 * Request terminal completion through the single logical-run keyed finalizer.
+	 *
+	 * For managed runs, logicalRunId must be currentManagedLogicalRunId from any
+	 * attempt in the retry chain. Non-managed runs use their activeRunId. Terminal
+	 * requests with messages emit a committed message_start/message_end lifecycle
+	 * for each diagnostic before agent_end. Requests without messages (such as
+	 * cancellation) emit only agent_end.
+	 */
+	requestRunTerminal(logicalRunId: ManagedLogicalRunId, request: RunTerminalRequest): boolean {
+		if (this.#terminalizedLogicalRunIds.has(logicalRunId)) return false;
+		this.#finalizeRun(
+			logicalRunId,
+			{
+				type: "agent_end",
+				messages: request.messages ?? [],
+				...(request.stopReason === "cancelled" ? { stopReason: "cancelled" as const } : {}),
+			},
+			() => {
+				for (const message of request.messages ?? []) {
+					this.#emit({ type: "message_start", message });
+					this.appendMessage(message);
+					this.#emit({ type: "message_end", message });
+				}
+			},
+		);
+		return true;
+	}
+
 	reset() {
 		this.#state.messages = [];
 		this.#contextRevision++;
 		this.#state.isStreaming = false;
 		this.#state.streamMessage = null;
 		this.#state.pendingToolCalls = new Set<string>();
+		this.#managedLogicalRunOwner = undefined;
 		this.#state.error = undefined;
 		this.#steeringQueue = [];
 		this.#followUpQueue = [];
@@ -1170,6 +1254,10 @@ export class Agent {
 		}
 
 		assertUserImagePlaceholdersHavePayload(msgs);
+		if (this.#managedLogicalRunOwner !== undefined) {
+			this.requestRunTerminal(this.#managedLogicalRunOwner, { stopReason: "cancelled" });
+			this.#managedLogicalRunOwner = undefined;
+		}
 
 		await this.#runLoop(msgs, promptOptions);
 	}
@@ -1177,7 +1265,7 @@ export class Agent {
 	/**
 	 * Continue from current context (used for retries and resuming queued messages).
 	 */
-	async continue() {
+	async continue(options?: AgentPromptOptions) {
 		if (this.#state.isStreaming) {
 			throw new AgentBusyError();
 		}
@@ -1189,13 +1277,13 @@ export class Agent {
 		if (messages[messages.length - 1].role === "assistant") {
 			const queuedSteering = this.#dequeueSteeringMessages();
 			if (queuedSteering.length > 0) {
-				await this.#runLoop(queuedSteering, { skipInitialSteeringPoll: true });
+				await this.#runLoop(queuedSteering, { ...options, skipInitialSteeringPoll: true });
 				return;
 			}
 
 			const queuedFollowUp = this.#dequeueFollowUpMessages();
 			if (queuedFollowUp.length > 0) {
-				await this.#runLoop(queuedFollowUp);
+				await this.#runLoop(queuedFollowUp, options);
 				return;
 			}
 
@@ -1206,7 +1294,7 @@ export class Agent {
 			throw new Error("No messages to continue from");
 		}
 
-		await this.#runLoop(undefined);
+		await this.#runLoop(undefined, options);
 	}
 
 	/**
@@ -1225,18 +1313,41 @@ export class Agent {
 		this.#resolveRunningPrompt = resolve;
 
 		const runId = ++this.#runSequence;
+		const continuationGeneration = ++this.#continuationGeneration;
 		this.#activeRunId = runId;
 		const abortController = new AbortController();
 		this.#abortController = abortController;
 		this.#state.isStreaming = true;
 		this.#state.streamMessage = null;
 		this.#state.error = undefined;
-
-		// Clear Cursor tool result buffer at start of each run
+		options?.onRunAccepted?.();
+
+		const fallbackManaged = options?.fallbackManaged === true;
+		const managedLogicalRunOwner = fallbackManaged ? (this.#managedLogicalRunOwner ?? runId) : undefined;
+		const startsManagedLogicalRun = fallbackManaged && this.#managedLogicalRunOwner === undefined;
+		if (startsManagedLogicalRun) {
+			this.#managedLogicalRunOwner = managedLogicalRunOwner;
+			this.#emit({ type: "agent_start" });
+		}
+		if (fallbackManaged && this.#cursorToolResultBuffer.length > 0) {
+			const error = new ManagedCursorInvariantError(
+				"Managed Cursor attempt started with buffered provider-side tool results",
+			);
+			this.#state.isStreaming = false;
+			this.#abortController = undefined;
+			this.#activeRunId = undefined;
+			this.#runningPrompt = undefined;
+			this.#resolveRunningPrompt = undefined;
+			resolve();
+			this.requestRunTerminal(managedLogicalRunOwner ?? runId, { stopReason: "error" });
+			this.#managedLogicalRunOwner = undefined;
+			throw error;
+		}
+		// Each run gets a fresh buffer only after managed stale-state validation.
 		this.#cursorToolResultBuffer = [];
+		this.#activeFallbackManaged = fallbackManaged;
 
 		const reasoning = this.#state.thinkingLevel;
-
 		const context: AgentContext = {
 			systemPrompt: this.#state.systemPrompt,
 			messages: this.#state.messages.slice(),
@@ -1244,7 +1355,7 @@ export class Agent {
 		};
 
 		const cursorOnToolResult =
-			this.#cursorExecHandlers || this.#cursorOnToolResult
+			!fallbackManaged && (this.#cursorExecHandlers || this.#cursorOnToolResult)
 				? async (message: ToolResultMessage) => {
 						let finalMessage = message;
 						if (this.#activeRunId !== runId) {
@@ -1261,7 +1372,6 @@ export class Agent {
 								}
 							} catch {}
 						}
-						// Buffer tool result with current text length for correct ordering later.
 						// Cursor executes tools server-side during streaming, so the assistant message
 						// already incorporates results. We buffer here and emit in correct order
 						// when the assistant message ends.
@@ -1273,7 +1383,10 @@ export class Agent {
 
 		const getToolChoice = () =>
 			this.#getToolChoice?.() ?? refreshToolChoiceForActiveTools(options?.toolChoice, this.#state.tools);
-		const cursorExecHandlers = this.#cursorExecHandlersForRun(runId);
+		const cursorExecHandlers = fallbackManaged ? undefined : this.#cursorExecHandlersForRun(runId);
+		let managedDecision: ManagedAttemptDecision | undefined;
+		let managedOutcome: ManagedAttemptOutcome | undefined;
+		let maintenanceInterrupted = false;
 
 		const config: AgentLoopConfig = {
 			model,
@@ -1296,6 +1409,21 @@ export class Agent {
 			maxRetryDelayMs: this.#maxRetryDelayMs,
 			requestMaxRetries: this.#requestMaxRetries,
 			streamMaxRetries: this.#streamMaxRetries,
+			...(fallbackManaged
+				? {
+						fallbackManaged: true,
+						nextFallbackAttempt: options?.nextFallbackAttempt,
+						onManagedAttemptAccepted: options?.onManagedAttemptAccepted,
+						onManagedAttemptOutcome: async outcome => {
+							managedOutcome = outcome;
+							managedDecision = (await options?.onManagedAttemptOutcome?.(outcome)) ?? {
+								type: "terminal",
+								terminal: { stopReason: outcome.type === "run_terminal" ? outcome.reason : "error" },
+							};
+							return managedDecision;
+						},
+					}
+				: {}),
 			kimiApiFormat: this.#kimiApiFormat,
 			preferWebsockets: this.#preferWebsockets,
 			convertToLlm: this.#convertToLlm,
@@ -1314,8 +1442,8 @@ export class Agent {
 				context.systemPrompt = this.#state.systemPrompt;
 				context.tools = this.#state.tools;
 			},
-			cursorExecHandlers,
-			cursorOnToolResult,
+			...(cursorExecHandlers ? { cursorExecHandlers } : {}),
+			...(cursorOnToolResult ? { cursorOnToolResult } : {}),
 			transformToolCallArguments: this.#transformToolCallArguments,
 			intentTracing: this.#intentTracing,
 			appendOnlyContext: this.#appendOnlyContext,
@@ -1384,6 +1512,12 @@ export class Agent {
 				if (this.#activeRunId !== runId) return false;
 				return this.#shouldPause?.() === true;
 			},
+			maintainContext: this.#maintainContext
+				? async (context, lifecycle) => {
+						if (this.#activeRunId !== runId) return "not-needed";
+						return (await this.#maintainContext?.(context, lifecycle)) ?? "not-needed";
+					}
+				: undefined,
 			telemetry: this.#telemetry,
 		};
 
@@ -1391,8 +1525,8 @@ export class Agent {
 
 		try {
 			const stream = messages
-				? agentLoop(messages, context, config, abortController.signal, this.streamFn)
-				: agentLoopContinue(context, config, abortController.signal, this.streamFn);
+				? agentLoop(messages, context, config, abortController.signal, this.streamFn, !fallbackManaged)
+				: agentLoopContinue(context, config, abortController.signal, this.streamFn, !fallbackManaged);
 
 			for await (const event of stream) {
 				if (this.#activeRunId !== runId) {
@@ -1412,6 +1546,9 @@ export class Agent {
 						break;
 
 					case "message_end":
+						if (fallbackManaged && this.#cursorToolResultBuffer.length > 0) {
+							throw new ManagedCursorInvariantError();
+						}
 						partial = null;
 						// Check if this is an assistant message with buffered Cursor tool results.
 						// If so, split the message to emit tool results at the correct position.
@@ -1444,9 +1581,18 @@ export class Agent {
 						break;
 
 					case "agent_end":
+						if (fallbackManaged && managedOutcome) {
+							continue;
+						}
 						this.#state.isStreaming = false;
 						this.#state.streamMessage = null;
-						break;
+						if (event.stopReason === "maintenance") {
+							maintenanceInterrupted = true;
+							this.#emit(event);
+							continue;
+						}
+						this.#finalizeRun(managedLogicalRunOwner ?? runId, event);
+						continue;
 				}
 
 				// Emit to listeners
@@ -1456,6 +1602,15 @@ export class Agent {
 			if (this.#activeRunId !== runId) {
 				return;
 			}
+			if (managedOutcome) {
+				if (managedDecision?.type === "terminal") {
+					this.requestRunTerminal(managedLogicalRunOwner ?? runId, managedDecision.terminal);
+				} else if (managedOutcome.type === "run_terminal") {
+					this.requestRunTerminal(managedLogicalRunOwner ?? runId, { stopReason: managedOutcome.reason });
+				} else if (managedDecision?.type !== "retry") {
+					this.#finalizeRun(managedLogicalRunOwner ?? runId);
+				}
+			}
 
 			// Handle any remaining partial message
 			if (partial && partial.role === "assistant" && Array.isArray(partial.content) && partial.content.length > 0) {
@@ -1494,23 +1649,59 @@ export class Agent {
 				},
 				stopReason: abortController.signal.aborted ? "aborted" : "error",
 				errorMessage: err?.message || String(err),
+				errorStatus: extractHttpStatusFromError({ status: err?.errorStatus }) ?? extractHttpStatusFromError(err),
 				timestamp: Date.now(),
 			} as AgentMessage;
 
-			this.appendMessage(errorMsg);
 			this.#state.error = err?.message || String(err);
-			this.#emit({ type: "agent_end", messages: [errorMsg] });
+			this.requestRunTerminal(managedLogicalRunOwner ?? runId, {
+				stopReason: abortController.signal.aborted ? "cancelled" : "error",
+				messages: [errorMsg],
+			});
 		} finally {
+			let continuation: ManagedAttemptContinuation | undefined;
+			if (managedOutcome?.type === "retryable_discarded" && managedDecision?.type === "retry") {
+				continuation = managedDecision.continuation;
+			}
+			const ownership: ManagedAttemptContinuationOwnership = {
+				runId,
+				logicalRunId: managedLogicalRunOwner ?? runId,
+				generation: continuationGeneration,
+				isCurrent: () => this.#continuationGeneration === continuationGeneration && this.#activeRunId === undefined,
+			};
 			if (this.#activeRunId === runId) {
 				this.#state.isStreaming = false;
 				this.#state.streamMessage = null;
 				this.#state.pendingToolCalls = new Set<string>();
 				this.#abortController = undefined;
 				this.#activeRunId = undefined;
+				this.#activeFallbackManaged = false;
 				this.#resolveRunningPrompt?.();
 				this.#runningPrompt = undefined;
 				this.#resolveRunningPrompt = undefined;
 			}
+			if (
+				fallbackManaged &&
+				!continuation &&
+				!maintenanceInterrupted &&
+				this.#managedLogicalRunOwner === managedLogicalRunOwner
+			) {
+				this.#managedLogicalRunOwner = undefined;
+			}
+			if (continuation && ownership.isCurrent()) {
+				try {
+					await continuation(ownership);
+					if (this.#activeRunId === undefined && this.#managedLogicalRunOwner === managedLogicalRunOwner) {
+						this.#managedLogicalRunOwner = undefined;
+					}
+				} catch (err) {
+					if (ownership.isCurrent()) {
+						this.#state.error = err instanceof Error ? err.message : String(err);
+						this.requestRunTerminal(managedLogicalRunOwner ?? runId, { stopReason: "error" });
+						if (this.#managedLogicalRunOwner === managedLogicalRunOwner) this.#managedLogicalRunOwner = undefined;
+					}
+				}
+			}
 		}
 	}
 
@@ -1521,6 +1712,20 @@ export class Agent {
 	}
 
 	/** Calculate total text length from an assistant message's content blocks */
+	#finalizeRun(
+		logicalRunId: ManagedLogicalRunId,
+		event?: Extract<AgentEvent, { type: "agent_end" }>,
+		beforeEvent?: () => void,
+	): void {
+		if (this.#terminalizedLogicalRunIds.has(logicalRunId)) return;
+		this.#terminalizedLogicalRunIds.add(logicalRunId);
+		if (this.#terminalizedLogicalRunIds.size > 256) {
+			this.#terminalizedLogicalRunIds.delete(this.#terminalizedLogicalRunIds.values().next().value!);
+		}
+		beforeEvent?.();
+		if (event) this.#emit(event);
+	}
+
 	#getAssistantTextLength(message: AgentMessage | null): number {
 		if (message?.role !== "assistant" || !Array.isArray(message.content)) {
 			return 0;

package/src/compaction/compaction.ts

@@ -144,6 +144,18 @@ export interface CompactionSettings {
 	remoteEndpoint?: string;
 }
 
+export type RemoteCompactionFallbackHealthEvent =
+	| { kind: "success"; model: string; provider: string }
+	| { kind: "fallback"; model: string; provider: string; error: string };
+
+export interface RemoteCompactionFallbackHealthHooks {
+	recordRemoteCompactionFallback(event: RemoteCompactionFallbackHealthEvent): void;
+}
+
+function isAbortError(error: unknown): boolean {
+	return error instanceof Error && error.name === "AbortError";
+}
+
 export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
 	enabled: true,
 	strategy: "context-full",
@@ -799,6 +811,8 @@ export interface SummaryOptions {
 	providerSessionState?: Map<string, ProviderSessionState>;
 	/** Hint that websocket transport should be preferred when supported by the provider implementation. */
 	preferWebsockets?: boolean;
+	/** Session-owned health sink for remote-compaction fallback transition logging. */
+	remoteCompactionFallbackHealth?: RemoteCompactionFallbackHealthHooks;
 }
 
 /**
@@ -1305,6 +1319,7 @@ export async function compact(
 		sessionId: options?.sessionId,
 		providerSessionState: options?.providerSessionState,
 		preferWebsockets: options?.preferWebsockets,
+		remoteCompactionFallbackHealth: options?.remoteCompactionFallbackHealth,
 	};
 
 	let preserveData = withOpenAiRemoteCompactionPreserveData(previousPreserveData, undefined);
@@ -1331,12 +1346,28 @@ export async function compact(
 					{ authCredentialType: options?.authCredentialType },
 				);
 				preserveData = withOpenAiRemoteCompactionPreserveData(previousPreserveData, remote);
-			} catch (err) {
-				logger.warn("OpenAI remote compaction failed, falling back to local summarization", {
-					error: err instanceof Error ? err.message : String(err),
+				summaryOptions.remoteCompactionFallbackHealth?.recordRemoteCompactionFallback({
+					kind: "success",
 					model: model.id,
 					provider: model.provider,
 				});
+			} catch (err) {
+				if (signal?.aborted || isAbortError(err)) throw err;
+				const error = err instanceof Error ? err.message : String(err);
+				if (summaryOptions.remoteCompactionFallbackHealth) {
+					summaryOptions.remoteCompactionFallbackHealth.recordRemoteCompactionFallback({
+						kind: "fallback",
+						error,
+						model: model.id,
+						provider: model.provider,
+					});
+				} else {
+					logger.warn("OpenAI remote compaction failed, falling back to local summarization", {
+						error,
+						model: model.id,
+						provider: model.provider,
+					});
+				}
 			}
 		}
 	}

package/src/compaction/entries.ts

@@ -115,6 +115,17 @@ export interface ModeChangeEntry extends SessionEntryBase {
 	data?: Record<string, unknown>;
 }
 
+export interface ConfiguredModelChainEntry extends SessionEntryBase {
+	type: "configured_model_chain";
+	role: string;
+	entries: readonly string[];
+	origin: string;
+	identity?: string;
+	explicitHead: boolean;
+	/** Whether this entry removes the configured chain for its role. */
+	cleared?: boolean;
+}
+
 export interface CustomCompactionSessionEntries {}
 
 export type SessionEntry =
@@ -131,6 +142,7 @@ export type SessionEntry =
 	| MCPToolSelectionEntry
 	| SessionInitEntry
 	| ModeChangeEntry
+	| ConfiguredModelChainEntry
 	| CustomCompactionSessionEntries[keyof CustomCompactionSessionEntries];
 
 export interface ReadonlySessionManager {

package/src/compaction/openai.ts

@@ -514,18 +514,14 @@ export async function requestOpenAiRemoteCompaction(
 	});
 
 	if (!response.ok) {
-		const errorText = await response.text().catch(() => "");
-		logger.warn("OpenAI remote compaction failed", {
-			endpoint,
-			status: response.status,
-			statusText: response.statusText,
-			errorText,
-		});
 		throw new Error(`Remote compaction failed (${response.status} ${response.statusText})`);
 	}
 
-	const data = (await response.json()) as { output?: unknown[] } | undefined;
-	const rawOutput = data?.output ?? [];
+	const data = (await response.json()) as { output?: unknown } | undefined;
+	if (!Array.isArray(data?.output)) {
+		throw new Error(`Remote compaction response malformed output (outputType=${typeof data?.output})`);
+	}
+	const rawOutput = data.output;
 	const replacementHistory = rawOutput.filter(
 		(item): item is Record<string, unknown> =>
 			!!item && typeof item === "object" && shouldKeepOpenAiCompactOutputItem(item as Record<string, unknown>),
@@ -539,15 +535,9 @@ export async function requestOpenAiRemoteCompaction(
 		const outputTypes = rawOutput.map(item =>
 			typeof item === "object" && item !== null ? (item as Record<string, unknown>).type : typeof item,
 		);
-		logger.warn("Remote compaction response missing compaction item", {
-			endpoint,
-			model: model.id,
-			provider: model.provider,
-			rawOutputLength: rawOutput.length,
-			outputTypes,
-			replacementHistoryLength: replacementHistory.length,
-		});
-		throw new Error("Remote compaction response missing compaction item");
+		throw new Error(
+			`Remote compaction response missing compaction item (rawOutputLength=${rawOutput.length}, outputTypes=${outputTypes.join(",")}, replacementHistoryLength=${replacementHistory.length})`,
+		);
 	}
 	return { provider: model.provider, replacementHistory, compactionItem };
 }
@@ -572,13 +562,6 @@ export async function requestRemoteCompaction(
 	});
 
 	if (!response.ok) {
-		const errorText = await response.text().catch(() => "");
-		logger.warn("Remote compaction failed", {
-			endpoint,
-			status: response.status,
-			statusText: response.statusText,
-			errorText,
-		});
 		throw new Error(`Remote compaction failed (${response.status} ${response.statusText})`);
 	}