pi-openai-toolkit 0.5.0 → 0.7.0

package/src/payload-rewrite.ts

@@ -7,6 +7,7 @@ import type {
 	SessionMessageEntry,
 } from "@earendil-works/pi-coding-agent";
 import type { ResponsesCompatibleRequestPayload } from "./runtime";
+import { rewritePayloadWithDeferredToolCarryover } from "./deferred-tool-carryover";
 import type { NativeCompactionEntry } from "./types";
 import {
 	compareResponsesInputParity,
@@ -503,6 +504,25 @@ function buildNativeReplaySegmentsInternal<TApi extends Api>(args: {
 		postCompactionTailMessages,
 		actualPostCompactionTail,
 	);
+	const baseRewrittenPayload: ResponsesCompatibleRequestPayload = {
+		...args.payload,
+		...(freshPreamble.instructions !== undefined ? { instructions: freshPreamble.instructions } : {}),
+		input: [
+			...freshPreamble.leadingInput,
+			...compactedWindow,
+			...actualPostCompactionTail,
+			...freshPreamble.trailingInput,
+		],
+	};
+	const carryoverRewrite = rewritePayloadWithDeferredToolCarryover({
+		payload: baseRewrittenPayload,
+		carryover: details.deferredToolCarryover,
+		compactionEntryId: args.compactionEntry.id,
+		checkpointEndIndex: freshPreamble.leadingInput.length + compactedWindow.length,
+		compat: args.model.compat as
+			| { supportsAdditionalTools?: boolean; supportsToolSearch?: boolean }
+			| undefined,
+	});
 
 	return {
 		ok: true,
@@ -517,23 +537,9 @@ function buildNativeReplaySegmentsInternal<TApi extends Api>(args: {
 			compactedWindow,
 			postCompactionTail,
 			originalPiReplayInput,
-			replayInput: [
-				...freshPreamble.leadingInput,
-				...compactedWindow,
-				...actualPostCompactionTail,
-				...freshPreamble.trailingInput,
-			],
-		},
-		rewrittenPayload: {
-			...args.payload,
-			...(freshPreamble.instructions !== undefined ? { instructions: freshPreamble.instructions } : {}),
-			input: [
-				...freshPreamble.leadingInput,
-				...compactedWindow,
-				...actualPostCompactionTail,
-				...freshPreamble.trailingInput,
-			],
+			replayInput: carryoverRewrite.payload.input,
 		},
+		rewrittenPayload: carryoverRewrite.payload,
 	};
 }
 

package/src/types.ts

@@ -1,10 +1,9 @@
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { CompactionEntry, CompactionResult, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { CompactionEntry, CompactionResult, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
 
 export const TOOLKIT_ID = "pi-openai-toolkit";
 export const COMPACTION_EXTENSION_ID = `${TOOLKIT_ID}:compaction`;
 export const WEB_SEARCH_EXTENSION_ID = `${TOOLKIT_ID}:web-search`;
-export const REASONING_TRANSLATION_EXTENSION_ID = `${TOOLKIT_ID}:reasoning-translation`;
 export const DEFAULT_ARTIFACT_ROOT = "~/.pi/agent/artifacts/pi-openai-toolkit/compaction";
 export const REDACTED_VALUE = "[REDACTED]";
 /**
@@ -37,6 +36,15 @@ export type DebugArtifactKind =
 	| "compaction-event"
 	| "lifecycle";
 
+export type CompactionContinuationMode = "inline" | "followUp" | "off";
+
+export type AutoCompactionConfig = {
+	enabled: boolean;
+	continuation: CompactionContinuationMode;
+	unsupportedFallback: "followUp" | "off";
+	reserveTokens?: number;
+};
+
 export type CompactionConfig = {
 	enabled: boolean;
 	/**
@@ -56,6 +64,8 @@ export type CompactionConfig = {
 	model?: string;
 	/** Thinking level passed to pi's native compact() when the fallback model runs. */
 	thinkingLevel: ThinkingLevel;
+	/** Threshold-triggered compaction and same-tool-loop continuation policy. */
+	autoCompaction: AutoCompactionConfig;
 	/** Subset of RESPONSES_COMPACT_CAPABLE_APIS that should use remote compaction. */
 	responsesApis: string[];
 	notifyOnLoad: boolean;
@@ -72,19 +82,9 @@ export type WebSearchConfig = {
 	models: string[];
 };
 
-export type ReasoningTranslationConfig = {
-	enabled: boolean;
-	/** Exact provider/model keys whose thinking output may be translated. */
-	models: string[];
-	/** Separate provider/model-id used only for translation requests. */
-	model?: string;
-	targetLanguage: string;
-};
-
 export type ToolkitConfig = {
 	compaction: CompactionConfig;
 	webSearch: WebSearchConfig;
-	reasoningTranslation: ReasoningTranslationConfig;
 };
 
 export type LoadedToolkitConfig = {
@@ -146,10 +146,21 @@ export type NativeCompactionIdentity = {
 	baseUrl: string;
 };
 
+export const CACHE_STACK_ACTIVATION_ENTRY_TYPE = "pi-cache-stack.activation-state.v1" as const;
+
+export type DeferredToolCarryoverV1 = {
+	version: 1;
+	source: typeof CACHE_STACK_ACTIVATION_ENTRY_TYPE;
+	toolNames: string[];
+	catalogHash?: string;
+};
+
 export type NativeCompactionDetails = NativeCompactionIdentity & {
 	strategy: NativeCompactionStrategy;
 	/** Actual producer of the opaque checkpoint; absent on legacy same-model entries. */
 	compactionModel?: NativeCompactionIdentity;
+	/** Cache-stack activation state captured at this opaque checkpoint. */
+	deferredToolCarryover?: DeferredToolCarryoverV1;
 	compactedWindow: unknown[];
 	compactResponseId?: string;
 	createdAt: string;
@@ -160,6 +171,7 @@ export type NativeCompactionEntry = CompactionEntry<NativeCompactionDetails>;
 
 export type CreateNativeCompactionDetailsInput = NativeCompactionIdentity & {
 	compactionModel?: NativeCompactionIdentity;
+	deferredToolCarryover?: DeferredToolCarryoverV1;
 	compactedWindow: unknown[];
 	compactResponseId?: string;
 	createdAt?: string;
@@ -273,6 +285,64 @@ export function isNativeCompactionIdentity(value: unknown): value is NativeCompa
 	);
 }
 
+export function isDeferredToolCarryover(value: unknown): value is DeferredToolCarryoverV1 {
+	if (!isRecord(value) || value.version !== 1 || value.source !== CACHE_STACK_ACTIVATION_ENTRY_TYPE) {
+		return false;
+	}
+
+	return (
+		Array.isArray(value.toolNames) &&
+		value.toolNames.every((name) => isNonEmptyString(name)) &&
+		(value.catalogHash === undefined || typeof value.catalogHash === "string")
+	);
+}
+
+function normalizeDeferredToolCarryover(value: DeferredToolCarryoverV1): DeferredToolCarryoverV1 {
+	if (!isDeferredToolCarryover(value)) {
+		throw new Error("Invalid deferred tool carryover");
+	}
+
+	return {
+		version: 1,
+		source: CACHE_STACK_ACTIVATION_ENTRY_TYPE,
+		toolNames: [...new Set(value.toolNames.map((name) => name.trim()).filter(Boolean))].sort(),
+		...(typeof value.catalogHash === "string" ? { catalogHash: value.catalogHash } : {}),
+	};
+}
+
+function decodeCacheStackActivationState(value: unknown): DeferredToolCarryoverV1 | undefined {
+	if (!isRecord(value) || value.version !== 1 || typeof value.catalogHash !== "string") {
+		return undefined;
+	}
+	if (!Array.isArray(value.activatedTools) || !value.activatedTools.every((name) => typeof name === "string")) {
+		return undefined;
+	}
+
+	return normalizeDeferredToolCarryover({
+		version: 1,
+		source: CACHE_STACK_ACTIVATION_ENTRY_TYPE,
+		toolNames: value.activatedTools,
+		catalogHash: value.catalogHash,
+	});
+}
+
+/** Read only the latest valid cache-stack activation snapshot on this branch. */
+export function getLatestDeferredToolCarryover(
+	entries: readonly SessionEntry[],
+): DeferredToolCarryoverV1 | undefined {
+	for (let index = entries.length - 1; index >= 0; index -= 1) {
+		const entry = entries[index];
+		if (entry?.type !== "custom" || entry.customType !== CACHE_STACK_ACTIVATION_ENTRY_TYPE) {
+			continue;
+		}
+
+		const decoded = decodeCacheStackActivationState(entry.data);
+		if (decoded) return decoded;
+	}
+
+	return undefined;
+}
+
 export function isNativeCompactionDetails(value: unknown): value is NativeCompactionDetails {
 	if (!isRecord(value) || !isNativeCompactionIdentity(value)) {
 		return false;
@@ -283,6 +353,7 @@ export function isNativeCompactionDetails(value: unknown): value is NativeCompac
 		(candidate.strategy === LEGACY_NATIVE_COMPACTION_STRATEGY ||
 			candidate.strategy === REMOTE_V2_COMPACTION_STRATEGY) &&
 		(candidate.compactionModel === undefined || isNativeCompactionIdentity(candidate.compactionModel)) &&
+		(candidate.deferredToolCarryover === undefined || isDeferredToolCarryover(candidate.deferredToolCarryover)) &&
 		Array.isArray(candidate.compactedWindow) &&
 		candidate.compactedWindow.every(isCompactedWindowItem) &&
 		isNonEmptyString(candidate.createdAt) &&
@@ -310,6 +381,9 @@ export function createNativeCompactionDetails(input: CreateNativeCompactionDetai
 				baseUrl: normalizeString(input.compactionModel.baseUrl),
 			}
 			: undefined,
+		deferredToolCarryover: input.deferredToolCarryover
+			? normalizeDeferredToolCarryover(input.deferredToolCarryover)
+			: undefined,
 		compactedWindow: input.compactedWindow.map((item) => cloneStructuredValue(item)),
 		compactResponseId: isNonEmptyString(input.compactResponseId) ? normalizeString(input.compactResponseId) : undefined,
 		createdAt: isNonEmptyString(input.createdAt) ? normalizeString(input.createdAt) : new Date().toISOString(),
@@ -336,12 +410,20 @@ export function createNativeCompactionResult(
 	};
 }
 
+export const DEFAULT_AUTO_COMPACTION_CONFIG: AutoCompactionConfig = {
+	enabled: true,
+	continuation: "inline",
+	unsupportedFallback: "followUp",
+	reserveTokens: undefined,
+};
+
 export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
 	enabled: true,
 	allowCompactionContinuityBreak: false,
 	remoteCompactModel: undefined,
 	model: undefined,
 	thinkingLevel: "off",
+	autoCompaction: { ...DEFAULT_AUTO_COMPACTION_CONFIG },
 	responsesApis: [...RESPONSES_COMPACT_CAPABLE_APIS],
 	notifyOnLoad: false,
 	debug: false,
@@ -356,15 +438,7 @@ export const DEFAULT_WEB_SEARCH_CONFIG: WebSearchConfig = {
 	models: [],
 };
 
-export const DEFAULT_REASONING_TRANSLATION_CONFIG: ReasoningTranslationConfig = {
-	enabled: true,
-	models: [],
-	model: undefined,
-	targetLanguage: "Simplified Chinese",
-};
-
 export const DEFAULT_TOOLKIT_CONFIG: ToolkitConfig = {
 	compaction: DEFAULT_COMPACTION_CONFIG,
 	webSearch: DEFAULT_WEB_SEARCH_CONFIG,
-	reasoningTranslation: DEFAULT_REASONING_TRANSLATION_CONFIG,
 };

package/tsconfig.check.json

@@ -14,11 +14,12 @@
   "include": [
     "extensions/compaction.ts",
     "extensions/web-search.ts",
-    "extensions/reasoning-translation.ts",
     "src/compact-client.ts",
     "src/config.ts",
     "src/debug.ts",
     "src/details-store.ts",
+    "src/deferred-tool-carryover.ts",
+    "src/inline-compaction.ts",
     "src/extension-runtime.ts",
     "src/native-fallback.ts",
     "src/payload-rewrite.ts",
@@ -32,12 +33,6 @@
     "src/web-search/extension.ts",
     "src/web-search/payload.ts",
     "src/web-search/prompt.ts",
-    "src/web-search/types.ts",
-    "src/reasoning-translation/client.ts",
-    "src/reasoning-translation/extension.ts",
-    "src/reasoning-translation/persistence.ts",
-    "src/reasoning-translation/segmenter.ts",
-    "src/reasoning-translation/state.ts",
-    "src/reasoning-translation/types.ts"
+    "src/web-search/types.ts"
   ]
 }

package/extensions/reasoning-translation.ts

@@ -1,2 +0,0 @@
-export { default } from "../src/reasoning-translation/extension.ts";
-export { registerReasoningTranslationExtension } from "../src/reasoning-translation/extension.ts";

package/src/reasoning-translation/client.ts

@@ -1,187 +0,0 @@
-import type { Api, AssistantMessage, Context, Model, Provider, Usage } from "@earendil-works/pi-ai";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { parseModelSpec } from "../runtime";
-import { MAX_TRANSLATION_OUTPUT_TOKENS, TRANSLATION_TIMEOUT_MS } from "./types";
-
-export type TranslatorFailureReason =
-	| "invalid-model-spec"
-	| "model-not-found"
-	| "provider-not-found"
-	| "auth-failed"
-	| "aborted"
-	| "request-failed"
-	| "empty-output";
-
-export type TranslateSegmentResult =
-	| { ok: true; text: string; usage?: Usage }
-	| { ok: false; reason: TranslatorFailureReason; errorMessage?: string };
-
-export type ResolvedTranslator = {
-	model: Model<Api>;
-	provider: Provider;
-	apiKey?: string;
-	headers?: Record<string, string | null>;
-	env?: Record<string, string>;
-};
-
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function isAbortError(error: unknown): boolean {
-	return (
-		(error instanceof DOMException && error.name === "AbortError") ||
-		(error instanceof Error && (error.name === "AbortError" || error.name === "ABORT_ERR"))
-	);
-}
-
-export function buildTranslationPrompt(targetLanguage: string): string {
-	return [
-		`Translate the following reasoning into ${targetLanguage}.`,
-		"Return only the faithful translation, with no summary, explanation, commentary, or added content.",
-		"Preserve code, commands, file paths, URLs, identifiers, formatting markers, and technical terms exactly unless they must be translated for grammatical context.",
-	].join(" ");
-}
-
-export async function resolveTranslator(
-	ctx: ExtensionContext,
-	modelSpec: string | undefined,
-): Promise<ResolvedTranslator | { ok: false; reason: TranslatorFailureReason; errorMessage?: string }> {
-	if (!modelSpec) return { ok: false, reason: "invalid-model-spec" };
-	const parsed = parseModelSpec(modelSpec);
-	if (!parsed) return { ok: false, reason: "invalid-model-spec" };
-
-	let model: Model<Api> | undefined;
-	try {
-		model = ctx.modelRegistry.find(parsed.provider, parsed.modelId);
-	} catch (error) {
-		return { ok: false, reason: "model-not-found", errorMessage: errorMessage(error) };
-	}
-	if (!model) {
-		return { ok: false, reason: "model-not-found" };
-	}
-
-	let provider: Provider | undefined;
-	try {
-		provider = ctx.modelRegistry.getProvider(parsed.provider);
-	} catch (error) {
-		return { ok: false, reason: "provider-not-found", errorMessage: errorMessage(error) };
-	}
-	if (!provider) {
-		return { ok: false, reason: "provider-not-found" };
-	}
-
-	try {
-		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-		if (!auth.ok) return { ok: false, reason: "auth-failed", errorMessage: auth.error };
-		return {
-			// Auth resolution may provide an OAuth-specific endpoint. The provider
-			// receives the effective model directly, so preserve that base URL while
-			// disabling reasoning on the cloned translator model.
-			model: {
-				...model,
-				...(auth.baseUrl ? { baseUrl: auth.baseUrl } : {}),
-				reasoning: false,
-			},
-			provider,
-			apiKey: auth.apiKey,
-			headers: auth.headers,
-			env: auth.env,
-		};
-	} catch (error) {
-		return { ok: false, reason: "auth-failed", errorMessage: errorMessage(error) };
-	}
-}
-
-function extractText(message: AssistantMessage): string {
-	return message.content
-		.filter((content): content is Extract<AssistantMessage["content"][number], { type: "text" }> => content.type === "text")
-		.map((content) => content.text)
-		.join("")
-		.trim();
-}
-
-export async function translateSegment(args: {
-	translator: ResolvedTranslator;
-	targetLanguage: string;
-	sourceSegment: string;
-	signal: AbortSignal;
-}): Promise<TranslateSegmentResult> {
-	if (args.signal.aborted) return { ok: false, reason: "aborted" };
-
-	const context: Context = {
-		systemPrompt: buildTranslationPrompt(args.targetLanguage),
-		messages: [{ role: "user", content: args.sourceSegment, timestamp: Date.now() }],
-	};
-
-	const controller = new AbortController();
-	let rejectAbort: ((reason?: unknown) => void) | undefined;
-	let timedOut = false;
-	const abortPromise = new Promise<never>((_, reject) => {
-		rejectAbort = reject;
-	});
-	const onAbort = () => {
-		controller.abort();
-		rejectAbort?.(new DOMException("Translation request aborted", "AbortError"));
-	};
-	args.signal.addEventListener("abort", onAbort, { once: true });
-	let timeoutId: ReturnType<typeof setTimeout> | undefined;
-
-	try {
-		// Keep the call safe even when a ResolvedTranslator is supplied by a test
-		// seam or another internal caller instead of resolveTranslator().
-		const effectiveModel = args.translator.model.reasoning
-			? { ...args.translator.model, reasoning: false }
-			: args.translator.model;
-		const stream = args.translator.provider.streamSimple(effectiveModel, context, {
-			apiKey: args.translator.apiKey,
-			headers: args.translator.headers,
-			env: args.translator.env,
-			signal: controller.signal,
-			timeoutMs: TRANSLATION_TIMEOUT_MS,
-			maxTokens: Math.max(1, Math.min(args.translator.model.maxTokens, MAX_TRANSLATION_OUTPUT_TOKENS)),
-		});
-		const timeoutPromise = new Promise<never>((_, reject) => {
-			timeoutId = setTimeout(() => {
-				timedOut = true;
-				controller.abort();
-				reject(new Error(`Translation request timed out after ${TRANSLATION_TIMEOUT_MS} ms.`));
-			}, TRANSLATION_TIMEOUT_MS);
-		});
-		const message = await Promise.race([stream.result(), abortPromise, timeoutPromise]);
-		if (args.signal.aborted) return { ok: false, reason: "aborted" };
-		if (timedOut) {
-			return {
-				ok: false,
-				reason: "request-failed",
-				errorMessage: `Translation request timed out after ${TRANSLATION_TIMEOUT_MS} ms.`,
-			};
-		}
-		if (message.stopReason === "aborted") {
-			return { ok: false, reason: "request-failed", errorMessage: "Translator aborted the request." };
-		}
-		if (message.stopReason !== "stop" && message.stopReason !== "length") {
-			return { ok: false, reason: "request-failed", errorMessage: message.errorMessage };
-		}
-		const text = extractText(message);
-		return text.length > 0
-			? { ok: true, text, usage: message.usage }
-			: { ok: false, reason: "empty-output" };
-	} catch (error) {
-		if (args.signal.aborted) return { ok: false, reason: "aborted" };
-		if (timedOut) {
-			return {
-				ok: false,
-				reason: "request-failed",
-				errorMessage: `Translation request timed out after ${TRANSLATION_TIMEOUT_MS} ms.`,
-			};
-		}
-		if (isAbortError(error)) {
-			return { ok: false, reason: "request-failed", errorMessage: errorMessage(error) };
-		}
-		return { ok: false, reason: "request-failed", errorMessage: errorMessage(error) };
-	} finally {
-		if (timeoutId !== undefined) clearTimeout(timeoutId);
-		args.signal.removeEventListener("abort", onAbort);
-	}
-}

package/src/reasoning-translation/extension.ts

@@ -1,105 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { loadToolkitConfig } from "../config";
-import type { LoadedToolkitConfig } from "../types";
-import { ReasoningTranslationState } from "./state";
-
-function refreshThinkingDisplay(ctx: ExtensionContext | undefined): void {
-	if (!ctx || ctx.mode !== "tui" || !ctx.hasUI) return;
-	try {
-		// Pi exposes no direct transcript invalidation API. Calling the public
-		// setter rebuilds assistant components and reruns transformers, while the
-		// no-argument form avoids leaving "Translating…" as the global hidden label.
-		ctx.ui.setHiddenThinkingLabel();
-	} catch {
-		// A display refresh is additive; never break the main model stream.
-	}
-}
-
-function restoreThinkingDisplay(ctx: ExtensionContext | undefined): void {
-	if (!ctx || ctx.mode !== "tui" || !ctx.hasUI) return;
-	try {
-		ctx.ui.setHiddenThinkingLabel();
-	} catch {
-		// Shutdown/reload must remain failure-open.
-	}
-}
-
-export function registerReasoningTranslationExtension(
-	pi: ExtensionAPI,
-	loadConfig: typeof loadToolkitConfig = loadToolkitConfig,
-): void {
-	let latestContext: ExtensionContext | undefined;
-	const state = new ReasoningTranslationState({
-		onDisplayChanged: () => refreshThinkingDisplay(latestContext),
-		appendEntry: (customType, data) => pi.appendEntry(customType, data),
-	});
-
-	pi.registerMarkdownTransformer((markdown, context) => {
-		if (context.messageType !== "assistant-thinking" || latestContext?.mode !== "tui") return markdown;
-		return state.lookupDisplay(markdown) ?? markdown;
-	});
-
-	pi.on("session_start", (_event, ctx) => {
-		latestContext = ctx;
-		state.abortActive();
-		const { config } = loadConfig() as LoadedToolkitConfig;
-		state.hydrate(ctx, config.reasoningTranslation);
-	});
-
-	pi.on("session_tree", (_event, ctx) => {
-		latestContext = ctx;
-		state.abortActive();
-		const { config } = loadConfig() as LoadedToolkitConfig;
-		state.hydrate(ctx, config.reasoningTranslation);
-	});
-
-	pi.on("session_before_switch", () => {
-		state.abortActive();
-	});
-
-	pi.on("session_before_fork", () => {
-		state.abortActive();
-	});
-
-	pi.on("session_before_tree", () => {
-		state.abortActive();
-	});
-
-	pi.on("session_shutdown", (_event, ctx) => {
-		if (latestContext === ctx) latestContext = undefined;
-		state.abortActive();
-		restoreThinkingDisplay(ctx);
-	});
-
-	pi.on("model_select", (_event, ctx) => {
-		latestContext = ctx;
-		state.abortActive();
-		const { config } = loadConfig() as LoadedToolkitConfig;
-		state.setDisplayEligibility(ctx, config.reasoningTranslation);
-	});
-
-	pi.on("message_start", (event, ctx) => {
-		latestContext = ctx;
-		const { config } = loadConfig() as LoadedToolkitConfig;
-		state.beginMessage(event.message, ctx, config.reasoningTranslation);
-	});
-
-	pi.on("message_update", (event, ctx) => {
-		latestContext = ctx;
-		if (ctx.mode !== "tui") return;
-		const update = event.assistantMessageEvent;
-		if (update.type !== "thinking_delta" && update.type !== "thinking_end") return;
-		state.handleMessageUpdate(event.message, update.type, update.contentIndex);
-	});
-
-	pi.on("message_end", (event, ctx) => {
-		latestContext = ctx;
-		if (ctx.mode !== "tui") return;
-		state.finishMessage(event.message);
-	});
-
-}
-
-export default function reasoningTranslationExtension(pi: ExtensionAPI): void {
-	registerReasoningTranslationExtension(pi);
-}

package/src/reasoning-translation/persistence.ts

@@ -1,73 +0,0 @@
-import { createHash } from "node:crypto";
-import type { AssistantMessage } from "@earendil-works/pi-ai";
-import type { SessionEntry } from "@earendil-works/pi-coding-agent";
-import {
-	REASONING_TRANSLATION_ENTRY_TYPE,
-	type ReasoningTranslationEntryV1,
-	cloneUsage,
-	isReasoningTranslationEntry,
-} from "./types";
-
-export type ThinkingRunProjection = {
-	runKey: number;
-	sourceMarkdown: string;
-};
-
-export function projectThinkingRuns(message: Pick<AssistantMessage, "content">): ThinkingRunProjection[] {
-	const runs: ThinkingRunProjection[] = [];
-	for (let index = 0; index < message.content.length; index++) {
-		const content = message.content[index];
-		if (content.type !== "thinking") continue;
-
-		const runKey = index;
-		const blocks: string[] = [];
-		for (; index < message.content.length; index++) {
-			const block = message.content[index];
-			if (block.type !== "thinking") break;
-			const thinking = block.thinking.trim();
-			if (thinking) blocks.push(thinking);
-		}
-		index--;
-		if (blocks.length > 0) {
-			runs.push({ runKey, sourceMarkdown: blocks.join("\n\n") });
-		}
-	}
-	return runs;
-}
-
-export function hashThinkingMarkdown(sourceMarkdown: string): string {
-	return createHash("sha256").update(sourceMarkdown, "utf8").digest("hex");
-}
-
-export function createReasoningTranslationEntry(args: {
-	sourceMarkdown: string;
-	displayText: string;
-	targetLanguage: string;
-	translator: { provider: string; model: string };
-	usage?: import("@earendil-works/pi-ai").Usage;
-}): ReasoningTranslationEntryV1 {
-	return {
-		version: 1,
-		sourceHash: hashThinkingMarkdown(args.sourceMarkdown),
-		displayText: args.displayText,
-		targetLanguage: args.targetLanguage,
-		translator: { ...args.translator },
-		usage: cloneUsage(args.usage),
-	};
-}
-
-export function replayReasoningTranslations(
-	entries: readonly SessionEntry[],
-): Map<string, ReasoningTranslationEntryV1> {
-	const translations = new Map<string, ReasoningTranslationEntryV1>();
-	for (const entry of entries) {
-		if (entry.type !== "custom" || entry.customType !== REASONING_TRANSLATION_ENTRY_TYPE) continue;
-		if (!isReasoningTranslationEntry(entry.data)) continue;
-		translations.set(entry.data.sourceHash, {
-			...entry.data,
-			translator: { ...entry.data.translator },
-			usage: cloneUsage(entry.data.usage),
-		});
-	}
-	return translations;
-}