pi-codebuddy-sdk 0.4.5 → 0.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-codebuddy-sdk",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Pi extension that uses CodeBuddy (via Agent SDK) as a model provider and adds an AskCodebuddy tool.",
   "author": "slahser",
   "license": "MIT",
@@ -32,9 +32,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@tencent-ai/agent-sdk": "^0.3.0",
+    "@tencent-ai/agent-sdk": "^0.3.259",
     "change-case": "^5.4.4",
-    "typebox": "^1.3.0"
+    "typebox": "^1.3.33"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.85.1",
@@ -45,9 +45,9 @@
     "@earendil-works/pi-ai": "^0.85.1",
     "@earendil-works/pi-coding-agent": "^0.85.1",
     "@earendil-works/pi-tui": "^0.85.1",
-    "@types/node": "^24.13.2",
-    "tsx": "^4.22.4",
-    "typescript": "^6.0.3"
+    "@types/node": "^26.6.1",
+    "tsx": "^4.23.13",
+    "typescript": "^7.0.2"
   },
   "pi": {
     "extensions": [

package/src/index.ts

@@ -11,6 +11,7 @@ import { dirname, join } from "path";
 import { PROVIDER_ID, messageContentToText, convertPiMessages } from "./convert.js";
 import { buildModels, codebuddyModelId, FALLBACK_MODELS, rawModelsFromSdk, resolveModel as _resolveModel, type PiModel } from "./models.js";
 import { readModelsCache, writeModelsCache } from "./models-cache.js";
+import { readTranscript } from "./transcript-compat.js";
 import { MCP_SERVER_NAME, MCP_TOOL_PREFIX, buildCodebuddySystemPrompt } from "./skills.js";
 import { verifyWrittenSession as _verifyWrittenSession } from "./session-verify.js";
 import { extractAllToolResults as _extractAllToolResults, type McpResult } from "./extract-tool-results.js";
@@ -100,6 +101,76 @@ function diagDump(label: string, data: Record<string, unknown>) {
 	debug(`DIAG: ${label} (see ${redactForLog(DIAG_LOG_PATH)})`);
 }
 
+// --- SDK transport teardown guard (issue #10) ---
+//
+// @tencent-ai/agent-sdk dispatches late `control_request`/`mcp_message` frames
+// fire-and-forget: `handleLine()` calls `this.handleMcpMessageRequest(req)`
+// without awaiting or catching it. When the CLI subprocess has just been torn
+// down (interrupt → retry), the response path throws
+// `Error: Transport not started` from `writeLine()` inside an *unowned* async
+// function → unhandledRejection → the host escalates it to `fatal` and exits.
+//
+// Upstream still ships the unguarded call as of 0.3.259, so we patch the
+// transport prototype once per process: errors from a half-dead transport are
+// undeliverable anyway and must be swallowed, not crash the session.
+const patchedTransportPrototypes = new WeakSet<object>();
+
+function noteTransportTeardown(where: string, err: unknown): void {
+	debug(`transport guard: swallowed ${where} failure during teardown: ${err instanceof Error ? err.message : String(err)}`);
+	diagDump("transport_teardown_swallowed", {
+		where,
+		message: err instanceof Error ? err.message : String(err),
+		stack: err instanceof Error ? err.stack?.split("\n").slice(0, 6).join(" | ") ?? null : null,
+	});
+}
+
+function installTransportTeardownGuard(sdkQuery: unknown): void {
+	const transport = (sdkQuery as { transport?: unknown } | null | undefined)?.transport;
+	if (!transport || typeof transport !== "object") return;
+	const proto = Object.getPrototypeOf(transport) as Record<string, unknown> | null;
+	if (!proto || patchedTransportPrototypes.has(proto)) return;
+
+	const originalHandle = proto.handleMcpMessageRequest;
+	if (typeof originalHandle === "function") {
+		proto.handleMcpMessageRequest = function (this: unknown, request: unknown) {
+			try {
+				return Promise.resolve(originalHandle.call(this, request)).catch((err: unknown) => {
+					noteTransportTeardown("handleMcpMessageRequest", err);
+				});
+			} catch (err) {
+				// Synchronous throw before a promise exists — same teardown class.
+				noteTransportTeardown("handleMcpMessageRequest(sync)", err);
+				return undefined;
+			}
+		};
+	}
+
+	const originalSendError = proto.sendControlErrorResponse;
+	if (typeof originalSendError === "function") {
+		proto.sendControlErrorResponse = function (this: unknown, requestId: unknown, error: unknown) {
+			try {
+				return (originalSendError as (...a: unknown[]) => unknown).call(this, requestId, error);
+			} catch (err) {
+				noteTransportTeardown("sendControlErrorResponse", err);
+			}
+		};
+	}
+
+	patchedTransportPrototypes.add(proto);
+	debug("transport guard: installed on SDK ProcessTransport prototype");
+}
+
+/** Create an SDK query and immediately arm the transport teardown guard. */
+function startQuery(args: Parameters<typeof query>[0]): ReturnType<typeof query> {
+	const q = query(args);
+	try {
+		installTransportTeardownGuard(q);
+	} catch (err) {
+		debug(`transport guard: install failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	return q;
+}
+
 // --- Constants ---
 
 // Global key to prevent re-registration of the provider across module reloads.
@@ -343,13 +414,14 @@ async function runIsolatedSummary(
 	};
 
 	try {
-		const promptText = extractIsolatedSummaryPrompt(context.messages);
+		const view = readTranscript(context);
+		const promptText = extractIsolatedSummaryPrompt(view.messages);
 		const cwd = (options as { cwd?: string } | undefined)?.cwd ?? process.cwd();
 		const codebuddyExecutable = loadConfig(cwd).provider?.pathToCodebuddyCode;
 		const cliModel = codebuddyModelId(model);
 		debug(`compact summary: spawn model=${cliModel} registeredModel=${model.id} promptLen=${promptText.length}`);
 
-		sdkQuery = query({
+		sdkQuery = startQuery({
 			prompt: promptText,
 			options: {
 				cwd,
@@ -358,7 +430,7 @@ async function runIsolatedSummary(
 				strictMcpConfig: true,
 				settingSources: [] as SettingSource[],
 				persistSession: false,
-				systemPrompt: context.systemPrompt,
+				systemPrompt: view.systemPrompt,
 				model: cliModel,
 				maxTurns: 1,
 				...(codebuddyExecutable ? { pathToCodebuddyCode: codebuddyExecutable } : {}),
@@ -524,6 +596,7 @@ function syncSharedSession(
 	cwd: string,
 	customToolNameToSdk?: Map<string, string>,
 	modelId?: string,
+	isReentrant?: boolean,
 ): SyncResult {
 	const priorMessages = messages.slice(0, -1); // everything before the new user prompt
 
@@ -548,13 +621,37 @@ function syncSharedSession(
 		}
 	}
 	// Only reachable when needsRebuild is false — user-facing history rewrites
-	// (/compact, session_tree, /new, fork) always set needsRebuild or clear
-	// sharedSession before the next syncSharedSession call. In practice this
-	// fires only for isolated compact-summary subprocesses.
+	// (/compact, session_tree, /new, fork) usually set needsRebuild or clear
+	// sharedSession before the next syncSharedSession call. The remaining case is
+	// a pi-side history rewrite that did NOT flag us: a branch summary after an
+	// interrupted turn (a retry whose abort never reached the provider), which
+	// makes pi's visible history shorter than our cursor.
 	if (sharedSession && !sharedSession.needsRebuild && priorMessages.length < sharedSession.cursor) {
-		debug(`Case 1 synthetic: clean start for shorter context, preserving shared session ${sharedSession.sessionId.slice(0, 8)}, cursor=${sharedSession.cursor}`);
-		debug(`syncResult: path=clean-start preserve-shared sessionId=${sharedSession.sessionId} cursor=${sharedSession.cursor}`);
-		return { sessionId: null, preserveSharedSession: true };
+		// Top-level call with real history left: falling through to a clean start
+		// would send only the final user message with no `resume`, so the model
+		// answers as if the conversation never happened (issue #10). Rewrite the
+		// shared session from the truncated history instead — the turn keeps
+		// whatever context pi still has. forceRotate avoids racing a CLI
+		// subprocess that may still be writing to the old session file.
+		if (priorMessages.length > 0 && !isReentrant) {
+			const dropped = sharedSession.cursor - priorMessages.length;
+			const sessionId = sharedSession.sessionId;
+			debug(`Case 1 synthetic: history shrank by ${dropped} (${priorMessages.length} < cursor ${sharedSession.cursor}) — rebuilding shared session ${sessionId.slice(0, 8)} instead of clean start`);
+			piUI?.notify(
+				`CodeBuddy SDK: conversation history shrank by ${dropped} message(s) — rebuilding session context instead of starting fresh (see ${ISSUES_URL}#issue-comments if the reply still lacks context)`,
+				"warning",
+			);
+			diagDump("history_shrank_rebuild", { dropped, priorMessages: priorMessages.length, cursor: sharedSession.cursor, sessionId });
+			sharedSession = { ...sharedSession, needsRebuild: true, forceRotate: true };
+			// fall through to REBUILD below
+		} else {
+			// No prior history (isolated compact-summary prompt) or a reentrant
+			// subagent call: nothing to rebuild from, or rewriting would clobber
+			// the parent's shared session. Keep the ephemeral clean start.
+			debug(`Case 1 synthetic: clean start for shorter context (prior=${priorMessages.length}, reentrant=${Boolean(isReentrant)}), preserving shared session ${sharedSession.sessionId.slice(0, 8)}, cursor=${sharedSession.cursor}`);
+			debug(`syncResult: path=clean-start preserve-shared sessionId=${sharedSession.sessionId} cursor=${sharedSession.cursor}`);
+			return { sessionId: null, preserveSharedSession: true };
+		}
 	}
 
 	// REBUILD path
@@ -677,7 +774,7 @@ function contextForToolResults(results: McpResult[]): QueryContext | undefined {
 	return undefined;
 }
 
-function resolveMcpTools(context: Context, excludeToolName?: string): {
+function resolveMcpTools(declaredTools: Tool[] | undefined, excludeToolName?: string): {
 	mcpTools: Tool[];
 	customToolNameToSdk: Map<string, string>;
 	customToolNameToPi: Map<string, string>;
@@ -686,9 +783,9 @@ function resolveMcpTools(context: Context, excludeToolName?: string): {
 	const customToolNameToSdk = new Map<string, string>();
 	const customToolNameToPi = new Map<string, string>();
 
-	if (!context.tools) return { mcpTools, customToolNameToSdk, customToolNameToPi };
+	if (!declaredTools) return { mcpTools, customToolNameToSdk, customToolNameToPi };
 
-	for (const tool of context.tools) {
+	for (const tool of declaredTools) {
 		if (tool.name === excludeToolName) continue;
 		const sdkName = `${MCP_TOOL_PREFIX}${tool.name}`;
 		mcpTools.push(tool);
@@ -1092,8 +1189,12 @@ async function consumeQuery(
 function streamCodebuddySdk(model: Model<any>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
 	const stream = newAssistantMessageEventStream();
 
+	// Upstream #9548: pi-ai >= 0.85.2 passes a normalized transcript (prompt + tools carried by
+	// system messages). Read both shapes so this provider works before and after that change.
+	const { messages: convoMessages, systemPrompt: baseSystemPrompt, tools: declaredTools } = readTranscript(context);
+
 	// DEBUG: trace followUp message triggering
-	const lastMsgRole = context.messages[context.messages.length - 1]?.role;
+	const lastMsgRole = convoMessages[convoMessages.length - 1]?.role;
 	debug(`provider: streamCodebuddySdk called, activeQuery=${!!ctx().activeQuery}, lastMsgRole=${lastMsgRole}, isReentrant=${ctx().activeQuery !== null}`);
 
 	const activeQuery = ctx().activeQuery !== null;
@@ -1101,7 +1202,7 @@ function streamCodebuddySdk(model: Model<any>, context: Context, options?: Simpl
 	const resultCtx = allResults.length > 0 ? contextForToolResults(allResults) : undefined;
 	const isReentrantUserQuery = activeQuery && lastMsgRole === "user" && allResults.length === 0;
 	if (isReentrantUserQuery) {
-		debug(`provider: active query user-only call treated as reentrant fresh query, waitingHandlers=${ctx().pendingToolCalls.size}, ctx.msgs=${context.messages.length}`);
+		debug(`provider: active query user-only call treated as reentrant fresh query, waitingHandlers=${ctx().pendingToolCalls.size}, ctx.msgs=${convoMessages.length}`);
 	}
 
 	// --- Tool result delivery ---
@@ -1111,7 +1212,7 @@ function streamCodebuddySdk(model: Model<any>, context: Context, options?: Simpl
 	if (resultCtx) {
 		claimCurrentPiStream(stream, "tool-result", resultCtx);
 		resultCtx.resetTurnState(model);
-		debug(`provider: tool results, ${allResults.length} results, ${resultCtx.pendingToolCalls.size} waiting handlers, ctx.msgs=${context.messages.length}`);
+		debug(`provider: tool results, ${allResults.length} results, ${resultCtx.pendingToolCalls.size} waiting handlers, ctx.msgs=${convoMessages.length}`);
 		for (const result of allResults) {
 			const id = result.toolCallId;
 			if (id && resultCtx.pendingToolCalls.has(id)) {
@@ -1130,8 +1231,15 @@ function streamCodebuddySdk(model: Model<any>, context: Context, options?: Simpl
 			}
 		}
 		if (resultCtx.pendingToolCalls.size > 0) {
-			debug(`WARNING: ${resultCtx.pendingToolCalls.size} MCP handlers still waiting after delivering ${allResults.length} results`);
-			piUI?.notify(`CodeBuddy SDK: ${resultCtx.pendingToolCalls.size} tool handler(s) still waiting — provider may be stuck`, "warning");
+		debug(`WARNING: ${resultCtx.pendingToolCalls.size} MCP handlers still waiting after delivering ${allResults.length} results`);
+		// The wedged turn cannot be unwedged in place: retrying tears down the
+		// CLI subprocess while its control pipe is still alive (issue #10). Exit
+		// and resume the session instead — the local transcript is intact.
+		piUI?.notify(
+			`CodeBuddy SDK: ${resultCtx.pendingToolCalls.size} tool handler(s) still waiting — provider may be stuck. ` +
+			`Prefer exiting and resuming this session over retrying in place, or the reply may lose context.`,
+			"warning",
+		);
 		}
 
 		// Detect user messages (steer/followUp) that pi injected into context
@@ -1143,25 +1251,25 @@ function streamCodebuddySdk(model: Model<any>, context: Context, options?: Simpl
 		// The bridge can't forward these mid-query (the SDK query is in progress),
 		// so we save them for replay as continuation queries after consumeQuery ends.
 		if (lastMsgRole === "user") {
-			const userPrompt = extractUserPrompt(context.messages);
+			const userPrompt = extractUserPrompt(convoMessages);
 			if (userPrompt) {
 				resultCtx.deferredUserMessages.push(userPrompt);
 				debug(`provider: deferred user message for replay after query (len=${userPrompt.length})`);
 			}
 		}
 
-		if (sharedSession) sharedSession.cursor = context.messages.length;
-		resultCtx.latestCursor = Math.max(resultCtx.latestCursor, context.messages.length);
+		if (sharedSession) sharedSession.cursor = convoMessages.length;
+		resultCtx.latestCursor = Math.max(resultCtx.latestCursor, convoMessages.length);
 		return stream;
 	}
 
 	// --- Orphaned tool result (e.g. user aborted a tool call) ---
 	// The query is gone but pi still delivered the result. Nothing to do — just
 	// emit end_turn so pi waits for the next real user message.
-	const lastMsg = context.messages[context.messages.length - 1];
+	const lastMsg = convoMessages[convoMessages.length - 1];
 	if (lastMsg?.role === "toolResult") {
 		debug(`provider: orphaned tool result after abort, emitting end_turn`);
-		if (sharedSession) sharedSession.cursor = context.messages.length;
+		if (sharedSession) sharedSession.cursor = convoMessages.length;
 		const c = ctx();  // capture current context for the microtask
 		queueMicrotask(() => {
 			c.resetTurnState(model);
@@ -1189,24 +1297,24 @@ function streamCodebuddySdk(model: Model<any>, context: Context, options?: Simpl
 	queryCtx.resetTurnState(model);
 	queryCtx.latestCursor = 0;
 
-	const { mcpTools, customToolNameToSdk, customToolNameToPi } = resolveMcpTools(context, askCodebuddyToolName);
+	const { mcpTools, customToolNameToSdk, customToolNameToPi } = resolveMcpTools(declaredTools, askCodebuddyToolName);
 	const cwd = (options as { cwd?: string } | undefined)?.cwd ?? process.cwd();
-	const syncResult = syncSharedSession(context.messages, cwd, customToolNameToSdk, model.id);
+	const syncResult = syncSharedSession(convoMessages, cwd, customToolNameToSdk, model.id, Boolean(isReentrant));
 	const { sessionId: resumeSessionId } = syncResult;
-	const promptBlocks = extractUserPromptBlocks(context.messages);
-	let promptText = extractUserPrompt(context.messages) ?? "";
+	const promptBlocks = extractUserPromptBlocks(convoMessages);
+	let promptText = extractUserPrompt(convoMessages) ?? "";
 
 	// Guard: empty prompt means the last context message isn't a user message.
 	// This should never happen with per-query state — dump diagnostics if it does.
 	if (!promptText && !promptBlocks) {
 		diagDump("empty_prompt", {
-			contextLength: context.messages.length,
+			contextLength: convoMessages.length,
 			lastMsgRole: lastMsg?.role,
 			isReentrant,
 			activeQueryContexts: activeQueryContexts.size,
 			activeQueryExists: queryCtx.activeQuery !== null,
 			sharedSession: sharedSession ? { sessionId: sharedSession.sessionId.slice(0, 8), cursor: sharedSession.cursor } : null,
-			messageRoles: context.messages.map((m, i) => `[${i}]${m.role}`).join(" "),
+			messageRoles: convoMessages.map((m, i) => `[${i}]${m.role}`).join(" "),
 		});
 		// Recover: use a continuation prompt so the SDK doesn't send an empty text block
 		promptText = "[continue]";
@@ -1218,7 +1326,7 @@ function streamCodebuddySdk(model: Model<any>, context: Context, options?: Simpl
 	const mcpServers = buildMcpServers(mcpTools, queryCtx);
 	const appendSystemPrompt = providerSettings.appendSystemPrompt !== false;
 	const systemPrompt = appendSystemPrompt
-		? buildCodebuddySystemPrompt(context.systemPrompt)
+		? buildCodebuddySystemPrompt(baseSystemPrompt)
 		: undefined;
 
 	// MCP auto-loading suppression: CC reads MCP servers from ~/.claude.json (top-level
@@ -1264,7 +1372,7 @@ function streamCodebuddySdk(model: Model<any>, context: Context, options?: Simpl
 	};
 
 	debug("provider: fresh query",
-		`model=${cliModel} msgs=${context.messages.length} tools=${mcpTools.length}`,
+		`model=${cliModel} msgs=${convoMessages.length} tools=${mcpTools.length}`,
 		`resume=${resumeSessionId?.slice(0, 8) ?? "none"} effort=${effort ?? "default"}`,
 		`appendSys=${appendSystemPrompt} strictMcp=${strictMcpConfigEnabled}`,
 		`promptLen=${promptText.length}${promptBlocks ? " [+images]" : ""}`);
@@ -1292,7 +1400,7 @@ function streamCodebuddySdk(model: Model<any>, context: Context, options?: Simpl
 
 	void (async () => {
 		await ensureModelsDiscovered();
-		sdkQuery = query({ prompt, options: queryOptions });
+		sdkQuery = startQuery({ prompt, options: queryOptions });
 		queryCtx.activeQuery = sdkQuery;
 		activeQueryContexts.add(queryCtx);
 
@@ -1324,7 +1432,7 @@ function streamCodebuddySdk(model: Model<any>, context: Context, options?: Simpl
 				}
 				debug(`provider: query done, ignoring captured session ${capturedSessionId?.slice(0, 8) ?? "none"} to preserve shared session`);
 			} else if (sessionId) {
-				const cursor = Math.max(context.messages.length, queryCtx.latestCursor, sharedSession?.cursor ?? 0);
+				const cursor = Math.max(convoMessages.length, queryCtx.latestCursor, sharedSession?.cursor ?? 0);
 				debug(`provider: query done, session=${sessionId.slice(0, 8)}, cursor=${cursor}`);
 				sharedSession = { sessionId, cursor, cwd };
 			}
@@ -1341,7 +1449,7 @@ function streamCodebuddySdk(model: Model<any>, context: Context, options?: Simpl
 				}
 
 				const contOptions = { ...queryOptions, resume: resumeId, ...makeCliDebugOptions("continuation") };
-				const contQuery = query({ prompt: steerPrompt, options: contOptions });
+				const contQuery = startQuery({ prompt: steerPrompt, options: contOptions });
 				queryCtx.activeQuery = contQuery;
 				debug(`provider: continuation query, model=${cliModel}, resume=${resumeId.slice(0, 8)}, promptLen=${steerPrompt.length}`);
 
@@ -1468,7 +1576,7 @@ async function promptAndWait(
 		`isolated=${options?.isolated ?? false} resume=${resumeSessionId?.slice(0, 8) ?? "none"}`,
 		`sysPrompt=${Boolean(askSystemPrompt)} promptLen=${prompt.length}`);
 
-	const sdkQuery = query({
+	const sdkQuery = startQuery({
 		prompt,
 		options: {
 			cwd,
@@ -1580,7 +1688,7 @@ let discoverInFlight: Promise<void> | null = null;
 async function discoverModels(pi: ExtensionAPI): Promise<void> {
 	await withSdkGate(async () => {
 		try {
-			const q = query({ prompt: " ", options: { maxTurns: 0, permissionMode: "bypassPermissions", tools: [] } });
+			const q = startQuery({ prompt: " ", options: { maxTurns: 0, permissionMode: "bypassPermissions", tools: [] } });
 			const supported = await q.supportedModels();
 			await q.return().catch(() => {});
 			if (!supported.length) return;

package/src/transcript-compat.ts

@@ -0,0 +1,81 @@
+import * as piAi from "@earendil-works/pi-ai";
+import type { Message, Tool } from "@earendil-works/pi-ai";
+
+// Upstream #9548 ("Mid conversation system messages") folds `Context.systemPrompt` and
+// `Context.tools` into the transcript's system messages, so provider-facing code receives a
+// `TranscriptContext` that only carries `messages`. This module reads both shapes so the
+// provider keeps working on pi-ai <= 0.85.1 and >= 0.85.2 without a hard version bump.
+
+export interface TranscriptView {
+	/** Conversation messages with system messages removed (the pre-#9548 shape). */
+	messages: Message[];
+	/** Rendered system prompt, or undefined when the request carries none. */
+	systemPrompt: string | undefined;
+	/** Tool declarations available for this request. */
+	tools: Tool[] | undefined;
+}
+
+type MaybeTranscript = {
+	messages: Message[];
+	systemPrompt?: string;
+	tools?: Tool[];
+};
+
+const ai = piAi as unknown as Record<string, unknown>;
+
+function textOfContent(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) {
+		return content
+			.map((part) =>
+				part && typeof part === "object" && typeof (part as { text?: unknown }).text === "string"
+					? (part as { text: string }).text
+					: "",
+			)
+			.join("");
+	}
+	return "";
+}
+
+/**
+ * Read the system prompt, tool declarations, and conversation from a request context that
+ * may be either a legacy `Context` or a normalized `TranscriptContext`.
+ */
+export function readTranscript(context: MaybeTranscript): TranscriptView {
+	const messages = Array.isArray(context.messages) ? context.messages : [];
+
+	// Legacy shape (pi-ai <= 0.85.1): prompt and tools are top-level fields.
+	if (typeof context.systemPrompt === "string" || Array.isArray(context.tools)) {
+		return { messages, systemPrompt: context.systemPrompt, tools: context.tools };
+	}
+
+	// Normalized shape (pi-ai >= 0.85.2): replay the transcript through upstream helpers.
+	const collapseSystemMessages = ai.collapseSystemMessages as
+		| ((c: { messages: Message[] }) => { messages: Message[] })
+		| undefined;
+	const getCurrentSystemPrompt = ai.getCurrentSystemPrompt as ((m: readonly unknown[]) => string) | undefined;
+	const getCurrentTools = ai.getCurrentTools as ((m: readonly unknown[]) => Tool[]) | undefined;
+	if (
+		typeof collapseSystemMessages === "function" &&
+		typeof getCurrentSystemPrompt === "function" &&
+		typeof getCurrentTools === "function"
+	) {
+		const collapsed = collapseSystemMessages({ messages });
+		return {
+			messages: collapsed.messages.filter((message) => (message as { role?: string }).role !== "system"),
+			systemPrompt: getCurrentSystemPrompt(collapsed.messages) || undefined,
+			tools: getCurrentTools(collapsed.messages),
+		};
+	}
+
+	// No upstream helpers available: best-effort replay of the leading system message.
+	const systemMessages = messages.filter((message) => (message as { role?: string }).role === "system");
+	const conversation = messages.filter((message) => (message as { role?: string }).role !== "system");
+	const head = systemMessages[0] as (Message & { content?: unknown; toolsAdded?: Tool[] }) | undefined;
+	if (!head) return { messages: conversation, systemPrompt: undefined, tools: undefined };
+	return {
+		messages: conversation,
+		systemPrompt: textOfContent(head.content) || undefined,
+		tools: head.toolsAdded,
+	};
+}