pi-firecode 0.8.1 → 1.0.1

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

@@ -1,144 +0,0 @@
-import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-
-const NATIVE_PROVIDERS = new Set(["openai", "openai-codex"]);
-const NATIVE_APIS = new Set(["openai-responses", "openai-codex-responses"]);
-
-type NativeCompactionApi = "openai-responses" | "openai-codex-responses";
-type RuntimeModel = Model<Api>;
-
-export type ResponsesRequestPayload = {
-	model: string;
-	input: unknown[];
-	instructions?: unknown;
-	[key: string]: unknown;
-};
-
-export type NativeCompactionTarget = {
-	provider: string;
-	api: NativeCompactionApi;
-	model: string;
-	baseUrl: string;
-	responsesUrl: string;
-	currentModel: RuntimeModel;
-	payload?: ResponsesRequestPayload;
-};
-
-export type NativeCompactionRuntime = NativeCompactionTarget & {
-	apiKey: string;
-	headers?: ProviderHeaders;
-};
-
-type TargetFailureReason =
-	| "missing-model"
-	| "unsupported-provider"
-	| "unsupported-api"
-	| "missing-base-url"
-	| "unsupported-payload"
-	| "payload-model-mismatch";
-
-export type NativeCompactionTargetResolution =
-	| { ok: true; target: NativeCompactionTarget }
-	| { ok: false; reason: TargetFailureReason };
-
-export type NativeCompactionRuntimeResolution =
-	| { ok: true; runtime: NativeCompactionRuntime }
-	| { ok: false; reason: "missing-api-key" | "auth-error" };
-
-function isNativeCompactionApi(value: string): value is NativeCompactionApi {
-	return NATIVE_APIS.has(value);
-}
-
-function normalizeBaseUrl(baseUrl: string | undefined): string | undefined {
-	const normalized = baseUrl?.trim().replace(/\/+$/, "");
-	return normalized || undefined;
-}
-
-function buildResponsesUrl(baseUrl: string, api: NativeCompactionApi): string {
-	if (api === "openai-responses") {
-		return baseUrl.endsWith("/responses") ? baseUrl : `${baseUrl}/responses`;
-	}
-	if (baseUrl.endsWith("/codex/responses")) {
-		return baseUrl;
-	}
-	return baseUrl.endsWith("/codex") ? `${baseUrl}/responses` : `${baseUrl}/codex/responses`;
-}
-
-function isResponsesRequestPayload(payload: unknown): payload is ResponsesRequestPayload {
-	if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-		return false;
-	}
-	const candidate = payload as Record<string, unknown>;
-	return typeof candidate.model === "string" && Array.isArray(candidate.input);
-}
-
-export function resolveNativeCompactionTarget(
-	ctx: ExtensionContext,
-	payload?: unknown,
-): NativeCompactionTargetResolution {
-	const currentModel = ctx.model;
-	if (!currentModel) {
-		return { ok: false, reason: "missing-model" };
-	}
-	if (!NATIVE_PROVIDERS.has(currentModel.provider)) {
-		return { ok: false, reason: "unsupported-provider" };
-	}
-	if (!isNativeCompactionApi(currentModel.api)) {
-		return { ok: false, reason: "unsupported-api" };
-	}
-	const baseUrl = normalizeBaseUrl(currentModel.baseUrl);
-	if (!baseUrl) {
-		return { ok: false, reason: "missing-base-url" };
-	}
-	if (payload !== undefined && !isResponsesRequestPayload(payload)) {
-		return { ok: false, reason: "unsupported-payload" };
-	}
-	if (payload !== undefined && payload.model !== currentModel.id) {
-		return { ok: false, reason: "payload-model-mismatch" };
-	}
-
-	return {
-		ok: true,
-		target: {
-			provider: currentModel.provider,
-			api: currentModel.api,
-			model: currentModel.id,
-			baseUrl,
-			responsesUrl: buildResponsesUrl(baseUrl, currentModel.api),
-			currentModel,
-			payload,
-		},
-	};
-}
-
-export async function resolveNativeCompactionRuntime(
-	ctx: ExtensionContext,
-	target: NativeCompactionTarget,
-): Promise<NativeCompactionRuntimeResolution> {
-	const registry = ctx.modelRegistry as unknown as {
-		getApiKeyAndHeaders?: (model: RuntimeModel) => Promise<
-			| { ok: true; apiKey?: string; headers?: ProviderHeaders }
-			| { ok: false; error: string }
-		>;
-	};
-	if (typeof registry.getApiKeyAndHeaders !== "function") {
-		return { ok: false, reason: "missing-api-key" };
-	}
-
-	try {
-		const auth = await registry.getApiKeyAndHeaders(target.currentModel);
-		if (!auth.ok || !auth.apiKey) {
-			return { ok: false, reason: "missing-api-key" };
-		}
-		return {
-			ok: true,
-			runtime: {
-				...target,
-				apiKey: auth.apiKey,
-				headers: auth.headers,
-			},
-		};
-	} catch {
-		return { ok: false, reason: "auth-error" };
-	}
-}

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

@@ -1,85 +0,0 @@
-import type { Api, Model } from "@earendil-works/pi-ai";
-import { providerSettings, type OpenAINativeSettings, type TextVerbosity } from "./config";
-
-export const FAST_STATUS_KEY = "pi-openai-native-fast";
-
-const OPENAI_RESPONSES_APIS = new Set(["openai-responses", "openai-codex-responses"]);
-const PRIORITY_MODEL_IDS = new Set([
-	"gpt-5.4",
-	"gpt-5.4-mini",
-	"gpt-5.5",
-	"gpt-5.6-sol",
-	"gpt-5.6-terra",
-	"gpt-5.6-luna",
-]);
-
-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 value === "low" || value === "medium" || value === "high";
-}
-
-function isOpenAIResponsesModel(model: Model<Api> | undefined): model is Model<Api> {
-	return model !== undefined && OPENAI_RESPONSES_APIS.has(model.api);
-}
-
-export function supportsFastMode(model: Model<Api> | undefined): boolean {
-	if (!model) return false;
-	if (model.provider === "xai") return true;
-	return isOpenAIResponsesModel(model) && PRIORITY_MODEL_IDS.has(model.id);
-}
-
-export function fastModeEnabled(model: Model<Api> | undefined, settings: OpenAINativeSettings): boolean {
-	if (!model || !supportsFastMode(model)) {
-		return false;
-	}
-	return providerSettings(settings, model.provider)?.priority === true;
-}
-
-function resolveTextVerbosity(
-	model: Model<Api>,
-	settings: OpenAINativeSettings,
-	verbosityOverride: unknown,
-): TextVerbosity | undefined {
-	if (verbosityOverride !== undefined) {
-		return isTextVerbosity(verbosityOverride) ? verbosityOverride : undefined;
-	}
-	return providerSettings(settings, model.provider)?.textVerbosity;
-}
-
-export function applyOpenAIOptions(
-	payload: Record<string, unknown>,
-	model: Model<Api> | undefined,
-	settings: OpenAINativeSettings,
-	verbosityOverride: unknown,
-): Record<string, unknown> {
-	const configuredProvider = model ? providerSettings(settings, model.provider) : undefined;
-	let nextPayload = payload;
-
-	// verbosity 只属于 OpenAI Responses；xAI Completions 没有这个字段。
-	if (isOpenAIResponsesModel(model)) {
-		const textVerbosity = resolveTextVerbosity(model, settings, verbosityOverride);
-		if (textVerbosity && (!isRecord(payload.text) || payload.text.verbosity !== textVerbosity)) {
-			nextPayload = {
-				...nextPayload,
-				text: {
-					...(isRecord(nextPayload.text) ? nextPayload.text : {}),
-					verbosity: textVerbosity,
-				},
-			};
-		}
-	}
-
-	if (
-		(isOpenAIResponsesModel(model) || model?.provider === "xai") &&
-		configuredProvider?.priority &&
-		payload.service_tier !== "priority"
-	) {
-		nextPayload = nextPayload === payload ? { ...nextPayload } : nextPayload;
-		nextPayload.service_tier = "priority";
-	}
-
-	return nextPayload;
-}

package/provider/openai-native/src/request-pipeline.ts

@@ -1,21 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { OpenAINativeSettings } from "./config";
-import { replayOpenAINative } from "./native-compaction";
-import { applyOpenAIOptions } from "./options";
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-export function rewriteOpenAIProviderRequest(
-	payload: unknown,
-	ctx: ExtensionContext,
-	settings: OpenAINativeSettings,
-	verbosityOverride: unknown,
-): unknown {
-	let nextPayload = settings.nativeCompaction ? replayOpenAINative(payload, ctx) ?? payload : payload;
-	if (isRecord(nextPayload)) {
-		nextPayload = applyOpenAIOptions(nextPayload, ctx.model, settings, verbosityOverride);
-	}
-	return nextPayload;
-}

package/provider/openai-native/src/responses-input.ts

@@ -1,433 +0,0 @@
-import { createHash } from "node:crypto";
-import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import { convertToLlm } from "@earendil-works/pi-coding-agent";
-import type {
-	Api,
-	AssistantMessage,
-	ImageContent,
-	Message,
-	Model,
-	TextContent,
-	ThinkingContent,
-	ToolCall,
-	ToolResultMessage,
-	UserMessage,
-} from "@earendil-works/pi-ai";
-/** Pi session messages to OpenAI Responses input. Pi does not export this converter. */
-export type AssistantPhase = "commentary" | "final_answer";
-
-type ResponsesTextInputItem = {
-	type: "input_text";
-	text: string;
-};
-
-type ResponsesImageInputItem = {
-	type: "input_image";
-	detail: "auto";
-	image_url: string;
-};
-
-export type ResponsesInputContentItem = ResponsesTextInputItem | ResponsesImageInputItem;
-
-export type ResponsesInputMessageItem = {
-	role: "user" | "developer" | "system";
-	content: ResponsesInputContentItem[] | string;
-};
-
-export type ResponsesAssistantOutputItem = {
-	type: "message";
-	role: "assistant";
-	content: Array<{
-		type: "output_text";
-		text: string;
-		annotations: [];
-	}>;
-	status: "completed";
-	id: string;
-	phase?: AssistantPhase;
-};
-
-export type ResponsesFunctionCallItem = {
-	type: "function_call";
-	id?: string;
-	call_id: string;
-	name: string;
-	arguments: string;
-};
-
-export type ResponsesFunctionCallOutputItem = {
-	type: "function_call_output";
-	call_id: string;
-	output: ResponsesInputContentItem[] | string;
-};
-
-export type ResponsesReasoningItem = Record<string, unknown>;
-
-export type ResponsesInputItem =
-	| ResponsesInputMessageItem
-	| ResponsesAssistantOutputItem
-	| ResponsesFunctionCallItem
-	| ResponsesFunctionCallOutputItem
-	| ResponsesReasoningItem;
-
-export type NativeCompactionRequest = {
-	model: string;
-	input: unknown[];
-	instructions: string;
-};
-
-export type SerializeResponsesMessagesOptions = {
-	instructions?: string;
-	includeInstructionsInInput?: boolean;
-};
-
-type ParsedTextSignature = {
-	id: string;
-	phase?: AssistantPhase;
-};
-
-const SYNTHETIC_TOOL_RESULT_TEXT = "No result provided";
-
-function sanitizeSurrogates(text: string): string {
-	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
-}
-
-export function serializeMessagesToCompactRequest<TApi extends Api>(args: {
-	model: Model<TApi>;
-	messages: AgentMessage[];
-	instructions: string;
-}): NativeCompactionRequest {
-	return {
-		model: args.model.id,
-		input: serializeMessagesToResponsesInput(args.model, args.messages),
-		instructions: sanitizeSurrogates(args.instructions),
-	};
-}
-
-export function serializeMessagesToResponsesInput<TApi extends Api>(
-	model: Model<TApi>,
-	messages: AgentMessage[],
-	options: SerializeResponsesMessagesOptions = {},
-): ResponsesInputItem[] {
-	const transformedMessages = transformMessagesForResponses(convertToLlm(messages), model);
-	const input: ResponsesInputItem[] = [];
-
-	if (options.includeInstructionsInInput && options.instructions) {
-		input.push({
-			role: model.reasoning ? "developer" : "system",
-			content: sanitizeSurrogates(options.instructions),
-		});
-	}
-
-	let messageIndex = 0;
-	for (const message of transformedMessages) {
-		if (message.role === "user") {
-			const item = serializeUserMessage(message, model);
-			if (item) {
-				input.push(item);
-			}
-			messageIndex++;
-			continue;
-		}
-
-		if (message.role === "assistant") {
-			const items = serializeAssistantMessage(message, messageIndex);
-			if (items.length > 0) {
-				input.push(...items);
-			}
-			messageIndex++;
-			continue;
-		}
-
-		input.push(serializeToolResultMessage(message, model));
-		messageIndex++;
-	}
-
-	return input;
-}
-
-function normalizeAssistantContent<TApi extends Api>(
-	message: AssistantMessage,
-	model: Model<TApi>,
-): AssistantMessage["content"] {
-	const isSameModel =
-		message.provider === model.provider && message.api === model.api && message.model === model.id;
-	const content: AssistantMessage["content"] = [];
-
-	for (const block of message.content) {
-		if (block.type === "thinking") {
-			if (block.redacted) {
-				if (isSameModel) content.push(block);
-				continue;
-			}
-			if (isSameModel) {
-				if (block.thinkingSignature) content.push(block);
-				continue;
-			}
-			if (block.thinking.trim()) {
-				content.push({ type: "text", text: block.thinking });
-			}
-			continue;
-		}
-
-		if (block.type === "text" && !isSameModel) {
-			content.push({ type: "text", text: block.text });
-			continue;
-		}
-
-		content.push(block);
-	}
-
-	return content;
-}
-
-function transformMessagesForResponses<TApi extends Api>(messages: Message[], model: Model<TApi>): Message[] {
-	const transformed: Message[] = [];
-	let pendingToolCalls: ToolCall[] = [];
-	let existingToolResultIds = new Set<string>();
-
-	for (const message of messages) {
-		if (message.role === "assistant") {
-			if (pendingToolCalls.length > 0) {
-				transformed.push(...createSyntheticToolResults(pendingToolCalls, existingToolResultIds));
-				pendingToolCalls = [];
-				existingToolResultIds = new Set<string>();
-			}
-			if (message.stopReason === "error" || message.stopReason === "aborted") {
-				continue;
-			}
-
-			const normalizedContent = normalizeAssistantContent(message, model);
-			transformed.push({ ...message, content: normalizedContent });
-			const toolCalls = normalizedContent.filter(isToolCallBlock);
-			if (toolCalls.length > 0) {
-				pendingToolCalls = toolCalls;
-				existingToolResultIds = new Set<string>();
-			}
-			continue;
-		}
-
-		if (message.role === "toolResult") {
-			existingToolResultIds.add(message.toolCallId);
-			transformed.push(message);
-			continue;
-		}
-
-		if (pendingToolCalls.length > 0) {
-			transformed.push(...createSyntheticToolResults(pendingToolCalls, existingToolResultIds));
-			pendingToolCalls = [];
-			existingToolResultIds = new Set<string>();
-		}
-		transformed.push(message);
-	}
-
-	return transformed;
-}
-
-function createSyntheticToolResults(
-	pendingToolCalls: readonly ToolCall[],
-	existingToolResultIds: ReadonlySet<string>,
-): ToolResultMessage[] {
-	const syntheticResults: ToolResultMessage[] = [];
-
-	for (const toolCall of pendingToolCalls) {
-		if (existingToolResultIds.has(toolCall.id)) {
-			continue;
-		}
-
-		syntheticResults.push({
-			role: "toolResult",
-			toolCallId: toolCall.id,
-			toolName: toolCall.name,
-			content: [{ type: "text", text: SYNTHETIC_TOOL_RESULT_TEXT }],
-			isError: true,
-			timestamp: Date.now(),
-		});
-	}
-
-	return syntheticResults;
-}
-
-function serializeUserMessage<TApi extends Api>(
-	message: UserMessage,
-	model: Model<TApi>,
-): ResponsesInputMessageItem | undefined {
-	const contentItems = normalizeUserContent(message.content).flatMap((item) => serializeUserContentItem(item, model));
-	if (contentItems.length === 0) {
-		return undefined;
-	}
-
-	return {
-		role: "user",
-		content: contentItems,
-	};
-}
-
-function serializeUserContentItem<TApi extends Api>(
-	item: TextContent | ImageContent,
-	model: Model<TApi>,
-): ResponsesInputContentItem[] {
-	if (item.type === "text") {
-		return [{ type: "input_text", text: sanitizeSurrogates(item.text) }];
-	}
-
-	if (!model.input.includes("image")) {
-		return [];
-	}
-
-	return [
-		{
-			type: "input_image",
-			detail: "auto",
-			image_url: `data:${item.mimeType};base64,${item.data}`,
-		},
-	];
-}
-
-function serializeAssistantMessage(message: AssistantMessage, messageIndex: number): ResponsesInputItem[] {
-	const items: ResponsesInputItem[] = [];
-
-	for (const block of message.content) {
-		if (block.type === "thinking") {
-			const reasoningItem = parseReasoningItem(block);
-			if (reasoningItem) {
-				items.push(reasoningItem);
-			}
-			continue;
-		}
-
-		if (block.type === "text") {
-			const signature = parseTextSignature(block.textSignature);
-			items.push({
-				type: "message",
-				role: "assistant",
-				content: [{ type: "output_text", text: sanitizeSurrogates(block.text), annotations: [] }],
-				status: "completed",
-				id: normalizeAssistantMessageId(signature?.id, messageIndex),
-				phase: signature?.phase,
-			});
-			continue;
-		}
-
-		const [callId, rawItemId] = block.id.split("|");
-		items.push({
-			type: "function_call",
-			id: rawItemId,
-			call_id: callId,
-			name: block.name,
-			arguments: JSON.stringify(block.arguments),
-		});
-	}
-
-	return items;
-}
-
-function serializeToolResultMessage<TApi extends Api>(
-	message: ToolResultMessage,
-	model: Model<TApi>,
-): ResponsesFunctionCallOutputItem {
-	const [callId] = message.toolCallId.split("|");
-	const textOutput = message.content
-		.filter((item): item is TextContent => item.type === "text")
-		.map((item) => sanitizeSurrogates(item.text))
-		.join("\n");
-	const hasImages = message.content.some((item) => item.type === "image");
-	const hasText = textOutput.length > 0;
-
-	if (hasImages && model.input.includes("image")) {
-		const output: ResponsesInputContentItem[] = [];
-		if (hasText) {
-			output.push({ type: "input_text", text: textOutput });
-		}
-		for (const item of message.content) {
-			if (item.type !== "image") {
-				continue;
-			}
-			output.push({
-				type: "input_image",
-				detail: "auto",
-				image_url: `data:${item.mimeType};base64,${item.data}`,
-			});
-		}
-		return {
-			type: "function_call_output",
-			call_id: callId,
-			output,
-		};
-	}
-
-	return {
-		type: "function_call_output",
-		call_id: callId,
-		output: hasText ? textOutput : "(see attached image)",
-	};
-}
-
-function normalizeUserContent(content: UserMessage["content"]): Array<TextContent | ImageContent> {
-	return typeof content === "string" ? [{ type: "text", text: content }] : content;
-}
-
-function parseReasoningItem(block: ThinkingContent): ResponsesReasoningItem | undefined {
-	if (!block.thinkingSignature) {
-		return undefined;
-	}
-
-	try {
-		const parsed = JSON.parse(block.thinkingSignature);
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-			return undefined;
-		}
-		return parsed as ResponsesReasoningItem;
-	} catch {
-		return undefined;
-	}
-}
-
-function parseTextSignature(signature: string | undefined): ParsedTextSignature | undefined {
-	if (!signature) {
-		return undefined;
-	}
-
-	if (!signature.startsWith("{")) {
-		return { id: signature };
-	}
-
-	try {
-		const parsed = JSON.parse(signature);
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-			return undefined;
-		}
-
-		const record = parsed as Record<string, unknown>;
-		if (record.v !== 1 || typeof record.id !== "string") {
-			return undefined;
-		}
-
-		return {
-			id: record.id,
-			phase:
-				record.phase === "commentary" || record.phase === "final_answer"
-					? record.phase
-					: undefined,
-		};
-	} catch {
-		return undefined;
-	}
-}
-
-function normalizeAssistantMessageId(id: string | undefined, messageIndex: number): string {
-	if (!id) {
-		return `msg_${messageIndex}`;
-	}
-
-	if (id.length <= 64) {
-		return id;
-	}
-
-	return `msg_${createHash("sha1").update(id).digest("hex").slice(0, 12)}`;
-}
-
-function isToolCallBlock(block: AssistantMessage["content"][number]): block is ToolCall {
-	return block.type === "toolCall";
-}
-