pi-firecode 0.8.0

package/provider/openai-native/src/compact-client.ts

@@ -0,0 +1,362 @@
+import type { NativeCompactionRuntime } from "./native-runtime";
+import type { NativeCompactionRequest } from "./responses-input";
+
+const JSON_CONTENT_TYPE = "application/json";
+const COMPACTION_TRIGGER = { type: "compaction_trigger" } as const;
+const RETAINED_MESSAGE_TOKEN_BUDGET = 64_000;
+
+type ParsedOutput = {
+	output: Record<string, unknown>[];
+	createdAt?: unknown;
+};
+
+type ParsedFailure = {
+	reason: "input-too-large" | "response-failed";
+	detail?: string;
+};
+
+export type NativeCompactionFailureReason =
+	| "aborted"
+	| "network-error"
+	| "non-2xx"
+	| "empty-body"
+	| "invalid-json"
+	| "malformed-response"
+	| "missing-compaction"
+	| "input-too-large"
+	| "response-failed";
+
+export type NativeCompactionResult =
+	| {
+			ok: true;
+			compactedWindow: unknown[];
+			createdAt?: string;
+	  }
+	| {
+			ok: false;
+			reason: NativeCompactionFailureReason;
+			status?: number;
+			detail?: string;
+	  };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isAbortError(error: unknown): boolean {
+	return (
+		(error instanceof DOMException && error.name === "AbortError") ||
+		(error instanceof Error && (error.name === "AbortError" || error.name === "ABORT_ERR"))
+	);
+}
+
+function normalizeResponseTimestamp(value: unknown): string | undefined {
+	if (typeof value === "number" && Number.isFinite(value)) {
+		const milliseconds = value > 1_000_000_000_000 ? value : value * 1000;
+		return new Date(milliseconds).toISOString();
+	}
+	if (typeof value !== "string" || !value.trim()) {
+		return undefined;
+	}
+	const parsed = Date.parse(value);
+	return Number.isNaN(parsed) ? value.trim() : new Date(parsed).toISOString();
+}
+
+function errorMessage(value: unknown): string | undefined {
+	if (!isRecord(value)) {
+		return undefined;
+	}
+	if (typeof value.message === "string" && value.message.trim()) {
+		return value.message.trim();
+	}
+	if (isRecord(value.error)) {
+		return errorMessage(value.error);
+	}
+	if (isRecord(value.response)) {
+		return errorMessage(value.response);
+	}
+	return undefined;
+}
+
+function providerError(value: unknown): Record<string, unknown> | undefined {
+	if (!isRecord(value)) {
+		return undefined;
+	}
+	if (isRecord(value.error)) {
+		return value.error;
+	}
+	return providerError(value.response);
+}
+
+function parseFailedResponse(value: unknown): ParsedFailure | undefined {
+	if (!isRecord(value)) {
+		return undefined;
+	}
+	const response = isRecord(value.response) ? value.response : value;
+	if (value.type !== "response.failed" && value.type !== "error" && response.status !== "failed") {
+		return undefined;
+	}
+	const error = providerError(value);
+	const code = typeof error?.code === "string" ? error.code : undefined;
+	const detail = error ? JSON.stringify(error) : errorMessage(value);
+	return {
+		reason: code === "context_length_exceeded" ? "input-too-large" : "response-failed",
+		...(detail ? { detail } : {}),
+	};
+}
+
+function parseErrorDetail(responseText: string): string | undefined {
+	try {
+		return errorMessage(JSON.parse(responseText));
+	} catch {
+		return undefined;
+	}
+}
+
+function isOutputArray(value: unknown): value is Record<string, unknown>[] {
+	return Array.isArray(value) && value.every(isRecord);
+}
+
+function parseJsonOutput(value: unknown): ParsedOutput | undefined {
+	if (!isRecord(value) || !isOutputArray(value.output)) {
+		return undefined;
+	}
+	return { output: value.output, createdAt: value.created_at };
+}
+
+function parseSseOutput(responseText: string): ParsedOutput | ParsedFailure | undefined {
+	let completed: ParsedOutput | undefined;
+	const streamedItems: Record<string, unknown>[] = [];
+	let failure: ParsedFailure | undefined;
+	for (const block of responseText.split(/\r?\n\r?\n/)) {
+		const data = block
+			.split(/\r?\n/)
+			.filter((line) => line.startsWith("data:"))
+			.map((line) => line.slice(5).trimStart())
+			.join("\n");
+		if (!data || data === "[DONE]") {
+			continue;
+		}
+		let event: unknown;
+		try {
+			event = JSON.parse(data);
+		} catch {
+			continue;
+		}
+		if (!isRecord(event)) {
+			continue;
+		}
+		if (event.type === "response.output_item.done" && isRecord(event.item)) {
+			streamedItems.push(event.item);
+			continue;
+		}
+		if (event.type === "response.completed") {
+			completed = parseJsonOutput(event.response) ?? {
+				output: [],
+				createdAt: isRecord(event.response) ? event.response.created_at : undefined,
+			};
+			continue;
+		}
+		failure = parseFailedResponse(event) ?? failure;
+	}
+	if (completed?.output.length) {
+		return completed;
+	}
+	if (completed && streamedItems.length > 0) {
+		return { output: streamedItems, createdAt: completed.createdAt };
+	}
+	return failure;
+}
+
+function parseResponseOutput(responseText: string):
+	| { ok: true; parsed: ParsedOutput }
+	| { ok: false; reason: "invalid-json" | "malformed-response" | ParsedFailure["reason"]; detail?: string } {
+	const trimmed = responseText.trim();
+	if (trimmed.startsWith("{")) {
+		try {
+			const value = JSON.parse(trimmed);
+			const failure = parseFailedResponse(value);
+			if (failure) {
+				return { ok: false, ...failure };
+			}
+			const parsed = parseJsonOutput(value);
+			if (parsed) {
+				return { ok: true, parsed };
+			}
+			const detail = errorMessage(value);
+			return { ok: false, reason: "malformed-response", ...(detail ? { detail } : {}) };
+		} catch {
+			return { ok: false, reason: "invalid-json" };
+		}
+	}
+
+	const sse = parseSseOutput(trimmed);
+	if (sse && "output" in sse) {
+		return { ok: true, parsed: sse };
+	}
+	return sse
+		? { ok: false, ...sse }
+		: { ok: false, reason: "malformed-response" };
+}
+
+function estimateSerializedTokens(value: unknown): number {
+	return Math.ceil(JSON.stringify(value).length / 4);
+}
+
+function isRetainedInputItem(value: unknown): value is Record<string, unknown> {
+	return isRecord(value) && (value.role === "user" || value.role === "developer" || value.role === "system");
+}
+
+function itemText(item: Record<string, unknown>): string {
+	if (typeof item.content === "string") {
+		return item.content;
+	}
+	if (!Array.isArray(item.content)) {
+		return "";
+	}
+	return item.content
+		.filter(isRecord)
+		.map((part) => (typeof part.text === "string" ? part.text : ""))
+		.join("");
+}
+
+function estimateTokens(item: Record<string, unknown>): number {
+	return Math.max(1, Math.ceil(itemText(item).length / 4));
+}
+
+function buildCompactedWindow(input: unknown[], compactionItem: Record<string, unknown>): unknown[] {
+	const retained: Record<string, unknown>[] = [];
+	let remaining = RETAINED_MESSAGE_TOKEN_BUDGET;
+	for (let index = input.length - 1; index >= 0 && remaining > 0; index--) {
+		const item = input[index];
+		if (!isRetainedInputItem(item)) {
+			continue;
+		}
+		const tokens = estimateTokens(item);
+		if (tokens > remaining) {
+			continue;
+		}
+		retained.push(structuredClone(item));
+		remaining -= tokens;
+	}
+	retained.reverse();
+	return [...retained, structuredClone(compactionItem)];
+}
+
+function decodeJwtPayload(token: string): Record<string, unknown> | undefined {
+	const parts = token.split(".");
+	if (parts.length !== 3) {
+		return undefined;
+	}
+	try {
+		const payload = JSON.parse(Buffer.from(parts[1]!, "base64url").toString("utf8"));
+		return isRecord(payload) ? payload : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function codexAccountId(token: string): string | undefined {
+	const authClaims = decodeJwtPayload(token)?.["https://api.openai.com/auth"];
+	if (!isRecord(authClaims) || typeof authClaims.chatgpt_account_id !== "string") {
+		return undefined;
+	}
+	return authClaims.chatgpt_account_id.trim() || undefined;
+}
+
+function buildHeaders(runtime: NativeCompactionRuntime): Record<string, string> {
+	const headers = new Headers(runtime.currentModel.headers ?? {});
+	for (const [key, value] of Object.entries(runtime.headers ?? {})) {
+		if (value === null) headers.delete(key);
+		else headers.set(key, value);
+	}
+	headers.set("accept", "text/event-stream, application/json");
+	headers.set("content-type", JSON_CONTENT_TYPE);
+	if (!headers.has("authorization")) {
+		headers.set("authorization", `Bearer ${runtime.apiKey}`);
+	}
+	if (runtime.provider === "openai-codex") {
+		const accountId = codexAccountId(runtime.apiKey);
+		if (accountId) {
+			headers.set("chatgpt-account-id", accountId);
+		}
+		headers.set("originator", "pi");
+		headers.set("user-agent", `pi (${process.platform}; ${process.arch})`);
+		headers.set("openai-beta", "responses=experimental");
+	}
+	return Object.fromEntries(headers.entries());
+}
+
+export async function executeNativeCompaction(args: {
+	runtime: NativeCompactionRuntime;
+	request: NativeCompactionRequest;
+	signal?: AbortSignal;
+}): Promise<NativeCompactionResult> {
+	const { runtime, request, signal } = args;
+	if (signal?.aborted) {
+		return { ok: false, reason: "aborted" };
+	}
+
+	try {
+		const input = [...request.input, COMPACTION_TRIGGER];
+		const inputTokens = estimateSerializedTokens(request.instructions) + estimateSerializedTokens(input);
+		const outputReserve = runtime.currentModel.maxTokens;
+		const contextWindow = runtime.currentModel.contextWindow;
+		if (inputTokens + outputReserve > contextWindow) {
+			return {
+				ok: false,
+				reason: "input-too-large",
+				detail: `estimated input exceeds the model context window (${inputTokens} input + ${outputReserve} output reserve > ${contextWindow} tokens)`,
+			};
+		}
+		const response = await fetch(runtime.responsesUrl, {
+			method: "POST",
+			headers: buildHeaders(runtime),
+			body: JSON.stringify({
+				model: request.model,
+				instructions: request.instructions,
+				input,
+				store: false,
+				stream: true,
+			}),
+			signal,
+		});
+		const responseText = await response.text();
+		if (!response.ok) {
+			const detail = parseErrorDetail(responseText);
+			return {
+				ok: false,
+				reason: "non-2xx",
+				status: response.status,
+				...(detail ? { detail } : {}),
+			};
+		}
+		if (!responseText.trim()) {
+			return { ok: false, reason: "empty-body", status: response.status };
+		}
+
+		const parsed = parseResponseOutput(responseText);
+		if (!parsed.ok) {
+			return { ...parsed, status: response.status };
+		}
+
+		const compactionItems = parsed.parsed.output.filter((item) => item.type === "compaction");
+		if (compactionItems.length !== 1) {
+			return { ok: false, reason: "missing-compaction", status: response.status };
+		}
+
+		return {
+			ok: true,
+			compactedWindow: buildCompactedWindow(request.input, compactionItems[0]!),
+			createdAt: normalizeResponseTimestamp(parsed.parsed.createdAt),
+		};
+	} catch (error) {
+		return isAbortError(error)
+			? { ok: false, reason: "aborted" }
+			: {
+					ok: false,
+					reason: "network-error",
+					detail: error instanceof Error ? error.message : String(error),
+				};
+	}
+}

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

@@ -0,0 +1,297 @@
+import { closeSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { parseJsonc } from "../../../jsonc.js";
+
+const TEXT_VERBOSITIES = ["low", "medium", "high"] as const;
+
+export type TextVerbosity = (typeof TEXT_VERBOSITIES)[number];
+
+export type OpenAIProviderSettings = {
+	textVerbosity?: TextVerbosity;
+	priority?: true;
+};
+
+export type OpenAINativeSettings = {
+	nativeCompaction: boolean;
+	providers: Record<string, OpenAIProviderSettings>;
+};
+
+export type LoadedOpenAINativeSettings = {
+	settings: OpenAINativeSettings;
+	warnings: string[];
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isTextVerbosity(value: unknown): value is TextVerbosity {
+	return typeof value === "string" && TEXT_VERBOSITIES.includes(value as TextVerbosity);
+}
+
+function createDefaultSettings(): OpenAINativeSettings {
+	return {
+		nativeCompaction: false,
+		providers: {},
+	};
+}
+
+function readConfig(configPath: string): Record<string, unknown> {
+	const parsed = parseJsonc(readFileSync(configPath, "utf8"));
+	if (!isRecord(parsed)) {
+		throw new Error("expected a JSON object");
+	}
+	return parsed;
+}
+
+/** 只替换名为 key 的对象，文件其余部分（含注释）原样保留。 */
+function replaceKeyedObject(text: string, key: string, value: unknown): string | undefined {
+	const marker = new RegExp(`"${key}"\\s*:\\s*\\{`);
+	const match = marker.exec(text);
+	if (!match) return undefined;
+	const brace = text.indexOf("{", match.index + match[0].length - 1);
+	if (brace < 0) return undefined;
+
+	let depth = 0;
+	let inString = false;
+	let escape = false;
+	for (let index = brace; index < text.length; index++) {
+		const char = text[index];
+		if (inString) {
+			if (escape) escape = false;
+			else if (char === "\\") escape = true;
+			else if (char === '"') inString = false;
+			continue;
+		}
+		if (char === '"') {
+			inString = true;
+			continue;
+		}
+		if (char === "{") depth += 1;
+		else if (char === "}") {
+			depth -= 1;
+			if (depth !== 0) continue;
+			const lineStart = text.lastIndexOf("\n", match.index) + 1;
+			const indent = text.slice(lineStart, match.index);
+			const pretty = JSON.stringify(value, null, "\t")
+				.split("\n")
+				.map((line, lineIndex) => (lineIndex === 0 ? line : indent + line))
+				.join("\n");
+			return text.slice(0, brace) + pretty + text.slice(index + 1);
+		}
+	}
+	return undefined;
+}
+
+/** firecode/config.jsonc 用 `openai` 节；单测仍可用独立的 native 文件。 */
+function openaiRoot(root: Record<string, unknown>): Record<string, unknown> {
+	return isRecord(root.openai) ? root.openai : root;
+}
+
+function isFirecodeConfig(root: Record<string, unknown>): boolean {
+	return "openai" in root || "presets" in root || "keys" in root || "features" in root;
+}
+
+function parseProviderSettings(
+	provider: string,
+	value: unknown,
+	warnings: string[],
+): OpenAIProviderSettings | undefined {
+	if (!isRecord(value)) {
+		warnings.push(`providers.${provider}: expected an object.`);
+		return undefined;
+	}
+
+	const settings: OpenAIProviderSettings = {};
+	if (value.textVerbosity !== undefined) {
+		if (isTextVerbosity(value.textVerbosity)) {
+			settings.textVerbosity = value.textVerbosity;
+		} else {
+			warnings.push(`providers.${provider}.textVerbosity: expected low, medium, or high.`);
+		}
+	}
+	if (value.priority !== undefined) {
+		if (typeof value.priority === "boolean") {
+			if (value.priority) {
+				settings.priority = true;
+			}
+		} else {
+			warnings.push(`providers.${provider}.priority: expected a boolean.`);
+		}
+	}
+
+	return Object.keys(settings).length > 0 ? settings : undefined;
+}
+
+function parseSettings(root: Record<string, unknown>): LoadedOpenAINativeSettings {
+	const warnings: string[] = [];
+	const settings = createDefaultSettings();
+	if (root.nativeCompaction !== undefined) {
+		if (typeof root.nativeCompaction === "boolean") {
+			settings.nativeCompaction = root.nativeCompaction;
+		} else {
+			warnings.push("nativeCompaction: expected a boolean.");
+		}
+	}
+	if (root.providers === undefined) {
+		return { settings, warnings };
+	}
+	if (!isRecord(root.providers)) {
+		warnings.push("providers: expected an object.");
+		return { settings, warnings };
+	}
+
+	for (const [provider, value] of Object.entries(root.providers)) {
+		if (!provider.trim()) {
+			warnings.push("providers: provider name cannot be empty.");
+			continue;
+		}
+		const providerSettings = parseProviderSettings(provider, value, warnings);
+		if (providerSettings) {
+			settings.providers[provider] = providerSettings;
+		}
+	}
+
+	return { settings, warnings };
+}
+
+function serializeSettings(settings: OpenAINativeSettings): Record<string, unknown> {
+	const providers: Record<string, OpenAIProviderSettings> = {};
+	for (const [provider, providerSettings] of Object.entries(settings.providers)) {
+		providers[provider] = {
+			...(providerSettings.textVerbosity ? { textVerbosity: providerSettings.textVerbosity } : {}),
+			...(providerSettings.priority ? { priority: true } : {}),
+		};
+	}
+
+	return {
+		nativeCompaction: settings.nativeCompaction,
+		providers,
+	};
+}
+
+function isProcessRunning(processId: number): boolean {
+	if (!Number.isSafeInteger(processId) || processId <= 0) {
+		return false;
+	}
+
+	try {
+		process.kill(processId, 0);
+		return true;
+	} catch (error) {
+		return (error as NodeJS.ErrnoException).code === "EPERM";
+	}
+}
+
+function acquireConfigLock(lockPath: string): number {
+	try {
+		return openSync(lockPath, "wx", 0o600);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "EEXIST") {
+			throw error;
+		}
+	}
+
+	const processId = Number.parseInt(readFileSync(lockPath, "utf8"), 10);
+	if (!Number.isSafeInteger(processId) || isProcessRunning(processId)) {
+		throw new Error("config is being updated by another Pi process");
+	}
+
+	rmSync(lockPath, { force: true });
+	return openSync(lockPath, "wx", 0o600);
+}
+
+function writeConfig(
+	configPath: string,
+	settings: OpenAINativeSettings,
+	firecodeRoot?: Record<string, unknown>,
+): void {
+	const serialized = serializeSettings(settings);
+	let text: string;
+	if (firecodeRoot) {
+		const original = readFileSync(configPath, "utf8");
+		text = replaceKeyedObject(original, "openai", serialized)
+			?? `${JSON.stringify({ ...firecodeRoot, openai: serialized }, null, "\t")}\n`;
+	} else {
+		text = `${JSON.stringify(serialized, null, 2)}\n`;
+	}
+	const temporaryPath = `${configPath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+	try {
+		writeFileSync(temporaryPath, text, {
+			encoding: "utf8",
+			mode: 0o600,
+		});
+		renameSync(temporaryPath, configPath);
+	} finally {
+		rmSync(temporaryPath, { force: true });
+	}
+}
+
+function withConfigLock<T>(configPath: string, action: () => T): T {
+	const lockPath = `${configPath}.lock`;
+	const lockDescriptor = acquireConfigLock(lockPath);
+	writeFileSync(lockDescriptor, `${process.pid}\n`, "utf8");
+	try {
+		return action();
+	} finally {
+		closeSync(lockDescriptor);
+		rmSync(lockPath, { force: true });
+	}
+}
+
+export function loadOpenAINativeSettings(configPath: string): LoadedOpenAINativeSettings {
+	try {
+		return parseSettings(openaiRoot(readConfig(configPath)));
+	} catch (error) {
+		return {
+			settings: createDefaultSettings(),
+			warnings: [`config.json: ${error instanceof Error ? error.message : String(error)}`],
+		};
+	}
+}
+
+export function togglePriority(
+	provider: string,
+	configPath: string,
+): { enabled: boolean; loaded: LoadedOpenAINativeSettings } {
+	if (!provider.trim()) {
+		throw new Error("provider name cannot be empty");
+	}
+
+	return withConfigLock(configPath, () => {
+		const root = readConfig(configPath);
+		const loaded = parseSettings(openaiRoot(root));
+		const providerSettings = loaded.settings.providers[provider] ?? {};
+		const enabled = providerSettings.priority !== true;
+		const providers = {
+			...loaded.settings.providers,
+			[provider]: {
+				...providerSettings,
+				...(enabled ? { priority: true as const } : {}),
+			},
+		};
+
+		if (!enabled) {
+			delete providers[provider].priority;
+			if (Object.keys(providers[provider]).length === 0) {
+				delete providers[provider];
+			}
+		}
+
+		const settings: OpenAINativeSettings = {
+			nativeCompaction: loaded.settings.nativeCompaction,
+			providers,
+		};
+		writeConfig(configPath, settings, isFirecodeConfig(root) ? root : undefined);
+		return {
+			enabled,
+			loaded: { settings, warnings: loaded.warnings },
+		};
+	});
+}
+
+export function providerSettings(
+	settings: OpenAINativeSettings,
+	provider: string | undefined,
+): OpenAIProviderSettings | undefined {
+	return provider ? settings.providers[provider] : undefined;
+}