pi-firecode 0.8.0

package/provider/openai-native/src/extension.ts

@@ -0,0 +1,93 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	loadOpenAINativeSettings,
+	togglePriority,
+	type OpenAINativeSettings,
+} from "./config";
+import { compactWithOpenAINative } from "./native-compaction";
+import { FAST_STATUS_KEY, fastModeEnabled, supportsFastMode } from "./options";
+import { rewriteOpenAIProviderRequest } from "./request-pipeline";
+
+const VERBOSITY_FLAG = "verbosity";
+
+function updateFastStatus(ctx: ExtensionContext, settings: OpenAINativeSettings): void {
+	if (!ctx.hasUI) {
+		return;
+	}
+	ctx.ui.setStatus(
+		FAST_STATUS_KEY,
+		fastModeEnabled(ctx.model, settings) ? ctx.ui.theme.fg("warning", "⚡ fast") : undefined,
+	);
+}
+
+function notifyUnsupportedFastMode(ctx: ExtensionContext): void {
+	ctx.ui.notify("当前模型不支持加速档", "warning");
+}
+
+export default function openAINativeExtension(
+	pi: ExtensionAPI,
+	configPath: string,
+	fastShortcut = "ctrl+f",
+): void {
+	let loadedSettings = loadOpenAINativeSettings(configPath);
+	let settings = loadedSettings.settings;
+
+	function toggleFastMode(ctx: ExtensionContext): void {
+		if (!ctx.model) {
+			return;
+		}
+		if (!supportsFastMode(ctx.model)) {
+			notifyUnsupportedFastMode(ctx);
+			return;
+		}
+
+		try {
+			const result = togglePriority(ctx.model.provider, configPath);
+			loadedSettings = result.loaded;
+			settings = loadedSettings.settings;
+			updateFastStatus(ctx, settings);
+			ctx.ui.notify(`加速档：${result.enabled ? "开" : "关"}`, "info");
+		} catch (error) {
+			ctx.ui.notify(`加速档保存失败：${error instanceof Error ? error.message : String(error)}`, "error");
+		}
+	}
+
+	pi.registerFlag(VERBOSITY_FLAG, {
+		description: "覆盖 OpenAI 回答详略：low、medium、high",
+		type: "string",
+	});
+	pi.registerCommand("fast", {
+		description: "开关当前 OpenAI 系供应商的加速档",
+		handler: async (_args, ctx) => {
+			toggleFastMode(ctx);
+		},
+	});
+	pi.registerShortcut(fastShortcut as never, {
+		description: "开关加速档",
+		handler: toggleFastMode,
+	});
+
+	pi.on("session_start", (_event, ctx) => {
+		if (loadedSettings.warnings.length > 0 && ctx.hasUI) {
+			ctx.ui.notify(`FireCode openai 配置：${loadedSettings.warnings[0]}`, "warning");
+		}
+		updateFastStatus(ctx, settings);
+	});
+
+	pi.on("model_select", (_event, ctx) => updateFastStatus(ctx, settings));
+	pi.on("session_before_compact", (event, ctx) => {
+		if (!settings.nativeCompaction) {
+			return undefined;
+		}
+		return compactWithOpenAINative(event, ctx);
+	});
+	pi.on("before_provider_request", (event, ctx) => {
+		const nextPayload = rewriteOpenAIProviderRequest(event.payload, ctx, settings, pi.getFlag(VERBOSITY_FLAG));
+		return nextPayload === event.payload ? undefined : nextPayload;
+	});
+	pi.on("session_shutdown", (_event, ctx) => {
+		if (ctx.hasUI) {
+			ctx.ui.setStatus(FAST_STATUS_KEY, undefined);
+		}
+	});
+}

package/provider/openai-native/src/native-compaction.ts

@@ -0,0 +1,151 @@
+import { buildSessionContext } from "@earendil-works/pi-coding-agent";
+import type { CompactionResult, ExtensionContext, SessionBeforeCompactEvent } from "@earendil-works/pi-coding-agent";
+import { executeNativeCompaction, type NativeCompactionResult } from "./compact-client";
+import {
+	cloneStructuredValue,
+	createNativeCompactionDetails,
+	createNativeCompactionResult,
+	resolveLatestNativeCompaction,
+} from "./native-details";
+import { rewriteNativeResponsesPayload, serializeLiveTailToResponsesInput } from "./native-replay";
+import {
+	resolveNativeCompactionRuntime,
+	resolveNativeCompactionTarget,
+	type ResponsesRequestPayload,
+} from "./native-runtime";
+import {
+	serializeMessagesToCompactRequest,
+	type NativeCompactionRequest,
+} from "./responses-input";
+
+type NativeCompactionHookResult = {
+	cancel?: boolean;
+	compaction?: CompactionResult;
+};
+
+function buildCompactionInstructions(systemPrompt: string, customInstructions?: string): string {
+	const guidance = customInstructions?.trim();
+	return guidance
+		? `${systemPrompt}\n\nAdditional user guidance for this manual /compact request:\n${guidance}`
+		: systemPrompt;
+}
+
+function reportCompactionFailure(ctx: ExtensionContext, message: string): void {
+	const fullMessage = `pi-openai-native: ${message}`;
+	if (ctx.hasUI) {
+		ctx.ui.notify(fullMessage, "error");
+		return;
+	}
+	console.error(fullMessage);
+}
+
+function cancelCompaction(ctx: ExtensionContext, message: string): NativeCompactionHookResult {
+	reportCompactionFailure(ctx, message);
+	return { cancel: true };
+}
+
+function failureMessage(result: Extract<NativeCompactionResult, { ok: false }>): string {
+	const status = result.status ? ` (HTTP ${result.status})` : "";
+	const detail = result.detail ? `: ${result.detail}` : "";
+	const message = `native compaction failed: ${result.reason}${status}${detail}`;
+	return message.endsWith(".") ? message : `${message}.`;
+}
+
+export async function compactWithOpenAINative(
+	event: SessionBeforeCompactEvent,
+	ctx: ExtensionContext,
+): Promise<NativeCompactionHookResult | undefined> {
+	if (event.signal.aborted) {
+		return { cancel: true };
+	}
+
+	const target = resolveNativeCompactionTarget(ctx);
+	if (!target.ok) {
+		return undefined;
+	}
+
+	const runtime = await resolveNativeCompactionRuntime(ctx, target.target);
+	if (!runtime.ok) {
+		return cancelCompaction(ctx, `native compaction is unavailable: ${runtime.reason}.`);
+	}
+
+	try {
+		const latestCompaction = resolveLatestNativeCompaction(event.branchEntries, runtime.runtime);
+		let request: NativeCompactionRequest;
+		if (latestCompaction.ok) {
+			const compactedWindow = latestCompaction.entry.details.compactedWindow.map(cloneStructuredValue);
+			request = {
+				model: runtime.runtime.model,
+				input: [
+					...compactedWindow,
+					...serializeLiveTailToResponsesInput({
+						model: runtime.runtime.currentModel,
+						entries: event.branchEntries.slice(latestCompaction.index + 1),
+					}),
+				],
+				instructions: buildCompactionInstructions(ctx.getSystemPrompt(), event.customInstructions),
+			};
+		} else if (latestCompaction.reason === "no-compaction") {
+			request = serializeMessagesToCompactRequest({
+				model: runtime.runtime.currentModel,
+				messages: buildSessionContext(
+					ctx.sessionManager.getEntries(),
+					ctx.sessionManager.getLeafId(),
+				).messages,
+				instructions: buildCompactionInstructions(ctx.getSystemPrompt(), event.customInstructions),
+			});
+		} else {
+			return undefined;
+		}
+
+		const result = await executeNativeCompaction({
+			runtime: runtime.runtime,
+			request,
+			signal: event.signal,
+		});
+		if (!result.ok) {
+			return result.reason === "aborted" ? { cancel: true } : cancelCompaction(ctx, failureMessage(result));
+		}
+
+		return {
+			compaction: createNativeCompactionResult({
+				firstKeptEntryId: event.preparation.firstKeptEntryId,
+				tokensBefore: event.preparation.tokensBefore,
+				details: createNativeCompactionDetails({
+					provider: runtime.runtime.provider,
+					api: runtime.runtime.api,
+					model: runtime.runtime.model,
+					baseUrl: runtime.runtime.baseUrl,
+					compactedWindow: result.compactedWindow,
+					createdAt: result.createdAt,
+				}),
+			}),
+		};
+	} catch (error) {
+		return cancelCompaction(ctx, `native compaction failed: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+
+export function replayOpenAINative(
+	payload: unknown,
+	ctx: ExtensionContext,
+): ResponsesRequestPayload | undefined {
+	const target = resolveNativeCompactionTarget(ctx, payload);
+	if (!target.ok || !target.target.payload) {
+		return undefined;
+	}
+
+	const branchEntries = ctx.sessionManager.getBranch();
+	const latestCompaction = resolveLatestNativeCompaction(branchEntries, target.target);
+	if (!latestCompaction.ok) {
+		return undefined;
+	}
+
+	const rewrite = rewriteNativeResponsesPayload({
+		model: target.target.currentModel,
+		payload: target.target.payload,
+		branchEntries,
+		compactionEntry: latestCompaction.entry,
+	});
+	return rewrite.ok ? rewrite.payload : undefined;
+}

package/provider/openai-native/src/native-details.ts

@@ -0,0 +1,157 @@
+import type { CompactionEntry, CompactionResult, SessionEntry } from "@earendil-works/pi-coding-agent";
+
+export const NATIVE_COMPACTION_STRATEGY = "openai-native-compact";
+export const NATIVE_COMPACTION_SUMMARY = "[OpenAI native compaction checkpoint]";
+
+export type NativeCompactionIdentity = {
+	provider: string;
+	api: string;
+	model: string;
+	baseUrl: string;
+};
+
+export type NativeCompactionDetails = NativeCompactionIdentity & {
+	strategy: typeof NATIVE_COMPACTION_STRATEGY;
+	compactedWindow: unknown[];
+	createdAt: string;
+};
+
+export type NativeCompactionEntry = CompactionEntry<NativeCompactionDetails> & {
+	details: NativeCompactionDetails;
+};
+
+type NativeCompactionResolution =
+	| {
+			ok: true;
+			entry: NativeCompactionEntry;
+			index: number;
+	  }
+	| {
+			ok: false;
+			reason: "no-compaction" | "latest-compaction-not-native" | "latest-native-compaction-mismatch";
+	  };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isNonEmptyString(value: unknown): value is string {
+	return typeof value === "string" && value.trim().length > 0;
+}
+
+function isStructuredValue(value: unknown): boolean {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+		return true;
+	}
+	if (Array.isArray(value)) {
+		return value.every(isStructuredValue);
+	}
+	return isRecord(value) && Object.values(value).every(isStructuredValue);
+}
+
+function isCompactedWindowItem(value: unknown): value is Record<string, unknown> {
+	return isRecord(value) && Object.values(value).every(isStructuredValue);
+}
+
+function hasNativeCompactionIdentity(value: Record<string, unknown>): boolean {
+	return (
+		isNonEmptyString(value.provider) &&
+		isNonEmptyString(value.api) &&
+		isNonEmptyString(value.model) &&
+		isNonEmptyString(value.baseUrl)
+	);
+}
+
+export function cloneStructuredValue(value: unknown): unknown {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+		return value;
+	}
+	if (Array.isArray(value)) {
+		return value.map(cloneStructuredValue);
+	}
+	if (isRecord(value)) {
+		return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [key, cloneStructuredValue(nestedValue)]));
+	}
+	throw new Error(`Unsupported structured value: ${typeof value}`);
+}
+
+export function isNativeCompactionDetails(value: unknown): value is NativeCompactionDetails {
+	if (!isRecord(value) || value.strategy !== NATIVE_COMPACTION_STRATEGY || !hasNativeCompactionIdentity(value)) {
+		return false;
+	}
+
+	return (
+		Array.isArray(value.compactedWindow) &&
+		value.compactedWindow.every(isCompactedWindowItem) &&
+		isNonEmptyString(value.createdAt)
+	);
+}
+
+function isNativeCompactionEntry(value: SessionEntry | undefined): value is NativeCompactionEntry {
+	return value?.type === "compaction" && isNativeCompactionDetails(value.details);
+}
+
+export function createNativeCompactionDetails(input: NativeCompactionIdentity & {
+	compactedWindow: unknown[];
+	createdAt?: string;
+}): NativeCompactionDetails {
+	const identity: NativeCompactionIdentity = {
+		provider: input.provider.trim(),
+		api: input.api.trim(),
+		model: input.model.trim(),
+		baseUrl: input.baseUrl.trim(),
+	};
+	if (!identity.provider || !identity.api || !identity.model || !identity.baseUrl) {
+		throw new Error("Native compaction identity is incomplete");
+	}
+
+	if (!input.compactedWindow.every(isCompactedWindowItem)) {
+		throw new Error("Native compaction window contains an invalid item");
+	}
+
+	return {
+		strategy: NATIVE_COMPACTION_STRATEGY,
+		...identity,
+		compactedWindow: input.compactedWindow.map(cloneStructuredValue),
+		createdAt: isNonEmptyString(input.createdAt) ? input.createdAt.trim() : new Date().toISOString(),
+	};
+}
+
+export function createNativeCompactionResult(input: {
+	firstKeptEntryId: string;
+	tokensBefore: number;
+	details: NativeCompactionDetails;
+}): CompactionResult<NativeCompactionDetails> {
+	return {
+		summary: NATIVE_COMPACTION_SUMMARY,
+		firstKeptEntryId: input.firstKeptEntryId,
+		tokensBefore: input.tokensBefore,
+		details: input.details,
+	};
+}
+
+export function resolveLatestNativeCompaction(
+	entries: readonly SessionEntry[],
+	identity: NativeCompactionIdentity,
+): NativeCompactionResolution {
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (entry?.type !== "compaction") {
+			continue;
+		}
+		if (!isNativeCompactionEntry(entry)) {
+			return { ok: false, reason: "latest-compaction-not-native" };
+		}
+		if (
+			entry.details.provider !== identity.provider ||
+			entry.details.api !== identity.api ||
+			entry.details.model !== identity.model ||
+			entry.details.baseUrl !== identity.baseUrl
+		) {
+			return { ok: false, reason: "latest-native-compaction-mismatch" };
+		}
+		return { ok: true, entry, index };
+	}
+
+	return { ok: false, reason: "no-compaction" };
+}

package/provider/openai-native/src/native-replay.ts

@@ -0,0 +1,253 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type {
+	BranchSummaryEntry,
+	CustomMessageEntry,
+	SessionEntry,
+	SessionMessageEntry,
+} from "@earendil-works/pi-coding-agent";
+import { cloneStructuredValue, type NativeCompactionEntry } from "./native-details";
+import type { ResponsesRequestPayload } from "./native-runtime";
+import {
+	serializeMessagesToResponsesInput,
+	type ResponsesInputContentItem,
+	type ResponsesInputItem,
+	type ResponsesInputMessageItem,
+} from "./responses-input";
+
+export type NativeReplayFailureReason =
+	| "compaction-boundary-not-found"
+	| "first-kept-entry-not-found"
+	| "unsupported-instructions"
+	| "invalid-compacted-window"
+	| "unexpected-compaction-after-boundary"
+	| "expected-pi-replay-mismatch";
+
+export type NativeReplayResult =
+	| { ok: true; payload: ResponsesRequestPayload }
+	| { ok: false; reason: NativeReplayFailureReason };
+
+type FreshPreamble = {
+	leadingInput: ResponsesInputMessageItem[];
+	trailingInput: ResponsesInputMessageItem[];
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isResponsesInputContentItem(value: unknown): value is ResponsesInputContentItem {
+	if (!isRecord(value) || typeof value.type !== "string") {
+		return false;
+	}
+	if (value.type === "input_text") {
+		return typeof value.text === "string";
+	}
+	return value.type === "input_image" && value.detail === "auto" && typeof value.image_url === "string";
+}
+
+function isResponsesInputMessageItem(value: unknown): value is ResponsesInputMessageItem {
+	if (!isRecord(value) || (value.role !== "user" && value.role !== "developer" && value.role !== "system")) {
+		return false;
+	}
+	return typeof value.content === "string" || (Array.isArray(value.content) && value.content.every(isResponsesInputContentItem));
+}
+
+function isPromptEnvelopeItem(value: unknown): value is ResponsesInputMessageItem {
+	return isResponsesInputMessageItem(value) && (value.role === "developer" || value.role === "system");
+}
+
+function cloneInputContent(item: ResponsesInputContentItem): ResponsesInputContentItem {
+	return item.type === "input_text"
+		? { type: "input_text", text: item.text }
+		: { type: "input_image", detail: "auto", image_url: item.image_url };
+}
+
+function cloneInputMessage(item: ResponsesInputMessageItem): ResponsesInputMessageItem {
+	return {
+		role: item.role,
+		content: typeof item.content === "string" ? item.content : item.content.map(cloneInputContent),
+	};
+}
+
+function cloneResponsesInput(items: readonly unknown[]): ResponsesInputItem[] | undefined {
+	try {
+		return items.map((item) => cloneStructuredValue(item) as ResponsesInputItem);
+	} catch {
+		return undefined;
+	}
+}
+
+function cloneCompactedWindow(items: readonly unknown[]): unknown[] | undefined {
+	try {
+		return items.map(cloneStructuredValue);
+	} catch {
+		return undefined;
+	}
+}
+
+function areEquivalentValues(left: unknown, right: unknown): boolean {
+	if (Object.is(left, right)) {
+		return true;
+	}
+	if (Array.isArray(left) || Array.isArray(right)) {
+		return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => areEquivalentValues(item, right[index]));
+	}
+	if (!isRecord(left) || !isRecord(right)) {
+		return false;
+	}
+	const leftKeys = Object.keys(left).sort();
+	const rightKeys = Object.keys(right).sort();
+	return (
+		areEquivalentValues(leftKeys, rightKeys) &&
+		leftKeys.every((key) => areEquivalentValues(left[key], right[key]))
+	);
+}
+
+function toBranchSummaryMessage(entry: BranchSummaryEntry): AgentMessage {
+	return {
+		role: "branchSummary",
+		summary: entry.summary,
+		fromId: entry.fromId,
+		timestamp: new Date(entry.timestamp).getTime(),
+	} as AgentMessage;
+}
+
+function toCustomMessage(entry: CustomMessageEntry): AgentMessage {
+	return {
+		role: "custom",
+		customType: entry.customType,
+		content: entry.content,
+		display: entry.display,
+		details: entry.details,
+		timestamp: new Date(entry.timestamp).getTime(),
+	} as AgentMessage;
+}
+
+function toReplayMessage(entry: SessionEntry): AgentMessage | undefined {
+	if (entry.type === "message") {
+		return (entry as SessionMessageEntry).message;
+	}
+	if (entry.type === "custom_message") {
+		return toCustomMessage(entry);
+	}
+	if (entry.type === "branch_summary") {
+		return toBranchSummaryMessage(entry);
+	}
+	return undefined;
+}
+
+function collectReplayMessages(entries: readonly SessionEntry[]): AgentMessage[] {
+	const messages: AgentMessage[] = [];
+	for (const entry of entries) {
+		const message = toReplayMessage(entry);
+		if (message) {
+			messages.push(message);
+		}
+	}
+	return messages;
+}
+
+function createCompactionSummary(entry: NativeCompactionEntry): AgentMessage {
+	return {
+		role: "compactionSummary",
+		summary: entry.summary,
+		tokensBefore: entry.tokensBefore,
+		timestamp: new Date(entry.timestamp).getTime(),
+	} as AgentMessage;
+}
+
+function extractFreshPreamble(payload: ResponsesRequestPayload): FreshPreamble | undefined {
+	if (payload.instructions !== undefined && typeof payload.instructions !== "string") {
+		return undefined;
+	}
+
+	let leadingBoundary = 0;
+	while (leadingBoundary < payload.input.length && isPromptEnvelopeItem(payload.input[leadingBoundary])) {
+		leadingBoundary += 1;
+	}
+	let trailingBoundary = payload.input.length;
+	while (trailingBoundary > leadingBoundary && isPromptEnvelopeItem(payload.input[trailingBoundary - 1])) {
+		trailingBoundary -= 1;
+	}
+	for (let index = leadingBoundary; index < trailingBoundary; index++) {
+		if (isPromptEnvelopeItem(payload.input[index])) {
+			return undefined;
+		}
+	}
+
+	return {
+		leadingInput: payload.input.slice(0, leadingBoundary).map((item) => cloneInputMessage(item as ResponsesInputMessageItem)),
+		trailingInput: payload.input.slice(trailingBoundary).map((item) => cloneInputMessage(item as ResponsesInputMessageItem)),
+	};
+}
+
+export function serializeLiveTailToResponsesInput<TApi extends Api>(args: {
+	model: Model<TApi>;
+	entries: readonly SessionEntry[];
+}): ResponsesInputItem[] {
+	return serializeMessagesToResponsesInput(args.model, collectReplayMessages(args.entries));
+}
+
+export function rewriteNativeResponsesPayload<TApi extends Api>(args: {
+	model: Model<TApi>;
+	payload: ResponsesRequestPayload;
+	branchEntries: readonly SessionEntry[];
+	compactionEntry: NativeCompactionEntry;
+}): NativeReplayResult {
+	const boundaryIndex = args.branchEntries.findIndex((entry) => entry.id === args.compactionEntry.id);
+	if (boundaryIndex < 0) {
+		return { ok: false, reason: "compaction-boundary-not-found" };
+	}
+	const firstKeptEntryIndex = args.branchEntries.findIndex(
+		(entry, index) => index < boundaryIndex && entry.id === args.compactionEntry.firstKeptEntryId,
+	);
+	if (firstKeptEntryIndex < 0) {
+		return { ok: false, reason: "first-kept-entry-not-found" };
+	}
+
+	const preamble = extractFreshPreamble(args.payload);
+	if (!preamble) {
+		return { ok: false, reason: "unsupported-instructions" };
+	}
+	if (args.branchEntries.slice(boundaryIndex + 1).some((entry) => entry.type === "compaction")) {
+		return { ok: false, reason: "unexpected-compaction-after-boundary" };
+	}
+
+	const compactedWindow = cloneCompactedWindow(args.compactionEntry.details.compactedWindow);
+	if (!compactedWindow) {
+		return { ok: false, reason: "invalid-compacted-window" };
+	}
+
+	const preCompactionEntries = args.branchEntries.slice(firstKeptEntryIndex, boundaryIndex);
+	const postCompactionEntries = args.branchEntries.slice(boundaryIndex + 1);
+	const compactionSummaryInput = serializeMessagesToResponsesInput(args.model, [createCompactionSummary(args.compactionEntry)]);
+	const preCompactionInput = serializeMessagesToResponsesInput(args.model, collectReplayMessages(preCompactionEntries));
+	const postCompactionInput = serializeMessagesToResponsesInput(args.model, collectReplayMessages(postCompactionEntries));
+	const expectedInput = [
+		...preamble.leadingInput,
+		...compactionSummaryInput,
+		...preCompactionInput,
+		...postCompactionInput,
+		...preamble.trailingInput,
+	];
+	if (!areEquivalentValues(args.payload.input, expectedInput)) {
+		return { ok: false, reason: "expected-pi-replay-mismatch" };
+	}
+
+	const tailStart = preamble.leadingInput.length + compactionSummaryInput.length + preCompactionInput.length;
+	const tailEnd = args.payload.input.length - preamble.trailingInput.length;
+	const tail = cloneResponsesInput(args.payload.input.slice(tailStart, tailEnd));
+	if (!tail) {
+		return { ok: false, reason: "expected-pi-replay-mismatch" };
+	}
+
+	return {
+		ok: true,
+		payload: {
+			...args.payload,
+			input: [...preamble.leadingInput, ...compactedWindow, ...tail, ...preamble.trailingInput],
+		},
+	};
+}
+