@howaboua/pi-codex-conversion 1.5.5-dev.25.f80a775 → 1.5.5

package/src/adapter/compact-client.ts

@@ -1,257 +0,0 @@
-import type { NativeCompactionRuntime } from "./compaction-runtime.ts";
-import type { NativeCompactionRequestBody } from "./serializer.ts";
-
-const JSON_CONTENT_TYPE = "application/json";
-
-type CompactResponseEnvelope = {
-	id?: string;
-	created_at?: number | string;
-	output: unknown[];
-	[key: string]: unknown;
-};
-
-export type NativeCompactionClientFailureReason =
-	| "aborted"
-	| "network-error"
-	| "non-2xx"
-	| "empty-body"
-	| "invalid-json"
-	| "malformed-response"
-	| "empty-output";
-
-export type NativeCompactionClientSuccess = {
-	ok: true;
-	status: number;
-	compactedWindow: unknown[];
-	compactResponseId?: string;
-	createdAt?: string;
-	response: CompactResponseEnvelope;
-};
-
-export type NativeCompactionClientFailure = {
-	ok: false;
-	reason: NativeCompactionClientFailureReason;
-	status?: number;
-	errorMessage?: string;
-	responseText?: string;
-	responseJson?: unknown;
-};
-
-export type NativeCompactionClientResult = NativeCompactionClientSuccess | NativeCompactionClientFailure;
-
-export type ExecuteNativeCompactionOptions = {
-	runtime: NativeCompactionRuntime;
-	request: NativeCompactionRequestBody;
-	signal?: AbortSignal;
-};
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return !!value && 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") {
-		return undefined;
-	}
-
-	const trimmed = value.trim();
-	if (!trimmed) {
-		return undefined;
-	}
-
-	const parsed = Date.parse(trimmed);
-	return Number.isNaN(parsed) ? trimmed : new Date(parsed).toISOString();
-}
-
-function isCompactOutputItem(value: unknown): value is Record<string, unknown> {
-	return isRecord(value);
-}
-
-function isCompactResponseEnvelope(value: unknown): value is CompactResponseEnvelope {
-	return isRecord(value) && Array.isArray(value.output) && value.output.every(isCompactOutputItem);
-}
-
-function decodeJwtPayload(token: string): Record<string, unknown> | undefined {
-	const parts = token.split(".");
-	if (parts.length !== 3) {
-		return undefined;
-	}
-
-	try {
-		const payloadText = Buffer.from(parts[1]!, "base64url").toString("utf8");
-		const payload = JSON.parse(payloadText);
-		return isRecord(payload) ? payload : undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-function extractCodexAccountId(token: string): string | undefined {
-	const payload = decodeJwtPayload(token);
-	const authClaims = payload?.["https://api.openai.com/auth"];
-	if (!isRecord(authClaims)) {
-		return undefined;
-	}
-
-	const accountId = authClaims.chatgpt_account_id;
-	return typeof accountId === "string" && accountId.trim().length > 0 ? accountId.trim() : undefined;
-}
-
-function buildCodexUserAgent(): string {
-	const platform = typeof process !== "undefined" ? process.platform : "browser";
-	const arch = typeof process !== "undefined" ? process.arch : "unknown";
-	return `pi (${platform}; ${arch})`;
-}
-
-function extractBearerToken(headers: Headers): string | undefined {
-	const authorization = headers.get("authorization")?.trim();
-	const match = authorization?.match(/^Bearer\s+(.+)$/i);
-	return match?.[1]?.trim() || undefined;
-}
-
-function toHeaders(runtime: NativeCompactionRuntime): Record<string, string> {
-	const headers = new Headers(runtime.currentModel.headers ?? {});
-	for (const [key, value] of Object.entries(runtime.headers ?? {})) {
-		headers.set(key, value);
-	}
-	headers.set("accept", JSON_CONTENT_TYPE);
-	headers.set("content-type", JSON_CONTENT_TYPE);
-	if (runtime.apiKey) {
-		headers.set("authorization", `Bearer ${runtime.apiKey}`);
-	}
-
-	if (runtime.provider === "openai-codex") {
-		const accountId = extractCodexAccountId(runtime.apiKey ?? extractBearerToken(headers) ?? "");
-		if (accountId) {
-			headers.set("chatgpt-account-id", accountId);
-		}
-		headers.set("originator", "pi");
-		headers.set("user-agent", buildCodexUserAgent());
-		headers.set("openai-beta", "responses=experimental");
-	}
-
-	return Object.fromEntries(headers.entries());
-}
-
-export async function executeNativeCompaction(
-	options: ExecuteNativeCompactionOptions,
-): Promise<NativeCompactionClientResult> {
-	const { runtime, request, signal } = options;
-	const headers = toHeaders(runtime);
-
-	if (signal?.aborted) {
-		const aborted: NativeCompactionClientFailure = {
-			ok: false,
-			reason: "aborted",
-		};
-		return aborted;
-	}
-
-	try {
-		const response = await fetch(runtime.compactUrl, {
-			method: "POST",
-			headers,
-			body: JSON.stringify(request),
-			signal,
-		});
-		const responseText = await response.text();
-
-		if (!response.ok) {
-			let responseJson: unknown;
-			if (responseText.trim().length > 0) {
-				try {
-					responseJson = JSON.parse(responseText);
-				} catch {
-					responseJson = undefined;
-				}
-			}
-
-			const failure: NativeCompactionClientFailure = {
-				ok: false,
-				reason: "non-2xx",
-				status: response.status,
-				responseText: responseText || undefined,
-				responseJson,
-			};
-			return failure;
-		}
-
-		if (!responseText.trim()) {
-			const failure: NativeCompactionClientFailure = {
-				ok: false,
-				reason: "empty-body",
-				status: response.status,
-			};
-			return failure;
-		}
-
-		let parsed: unknown;
-		try {
-			parsed = JSON.parse(responseText);
-		} catch (error) {
-			const failure: NativeCompactionClientFailure = {
-				ok: false,
-				reason: "invalid-json",
-				status: response.status,
-				errorMessage: error instanceof Error ? error.message : String(error),
-				responseText,
-			};
-			return failure;
-		}
-
-		if (!isCompactResponseEnvelope(parsed)) {
-			const failure: NativeCompactionClientFailure = {
-				ok: false,
-				reason: "malformed-response",
-				status: response.status,
-				responseJson: parsed,
-			};
-			return failure;
-		}
-
-		if (parsed.output.length === 0) {
-			const failure: NativeCompactionClientFailure = {
-				ok: false,
-				reason: "empty-output",
-				status: response.status,
-				responseJson: parsed,
-			};
-			return failure;
-		}
-
-		const success: NativeCompactionClientSuccess = {
-			ok: true,
-			status: response.status,
-			compactedWindow: [...parsed.output],
-			compactResponseId: typeof parsed.id === "string" && parsed.id.trim() ? parsed.id.trim() : undefined,
-			createdAt: normalizeResponseTimestamp(parsed.created_at),
-			response: parsed,
-		};
-		return success;
-	} catch (error) {
-		const failure: NativeCompactionClientFailure = isAbortError(error)
-			? {
-				ok: false,
-				reason: "aborted",
-			}
-			: {
-				ok: false,
-				reason: "network-error",
-				errorMessage: error instanceof Error ? error.message : String(error),
-			};
-
-		return failure;
-	}
-}

package/src/adapter/compaction-output.ts

@@ -1,80 +0,0 @@
-const COMPACTION_ITEM_TYPES = new Set(["compaction", "compaction_summary"]);
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return !!value && typeof value === "object" && !Array.isArray(value);
-}
-
-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)) {
-		const clone: Record<string, unknown> = {};
-		for (const [key, nested] of Object.entries(value)) {
-			clone[key] = cloneStructuredValue(nested);
-		}
-		return clone;
-	}
-	throw new Error(`Unsupported structured compact output value: ${typeof value}`);
-}
-
-function cloneCompactedOutputItem(item: Record<string, unknown>): Record<string, unknown> | undefined {
-	try {
-		return cloneStructuredValue(item) as Record<string, unknown>;
-	} catch {
-		return undefined;
-	}
-}
-
-export function shouldKeepCompactedOutputItem(item: unknown): item is Record<string, unknown> {
-	return isRecord(item) && typeof item.type === "string";
-}
-
-export function sanitizeCompactedWindow(output: readonly unknown[]): Record<string, unknown>[] {
-	const sanitized: Record<string, unknown>[] = [];
-	for (const item of output) {
-		if (!shouldKeepCompactedOutputItem(item)) continue;
-		const cloned = cloneCompactedOutputItem(item);
-		if (cloned) sanitized.push(cloned);
-	}
-	return sanitized;
-}
-
-export function extractCompactionSummaryText(compactedWindow: readonly unknown[]): string | undefined {
-	for (const item of compactedWindow) {
-		if (!isRecord(item) || typeof item.type !== "string" || !COMPACTION_ITEM_TYPES.has(item.type)) continue;
-		if (typeof item.encrypted_content === "string" && item.encrypted_content.trim().length > 0) return item.encrypted_content.trim();
-	}
-	return undefined;
-}
-
-export function hasCompactionOutputItem(compactedWindow: readonly unknown[]): boolean {
-	return compactedWindow.some((item) => isRecord(item) && typeof item.type === "string" && COMPACTION_ITEM_TYPES.has(item.type));
-}
-
-function describeOutputItem(item: unknown): string {
-	if (!isRecord(item)) return typeof item;
-	const type = typeof item.type === "string" ? item.type : "<missing-type>";
-	const role = typeof item.role === "string" ? `/${item.role}` : "";
-	const content = Array.isArray(item.content) ? ` content=${item.content.length}` : "";
-	const keys = Object.keys(item).sort().slice(0, 8).join(",");
-	return `${type}${role}${content} keys=[${keys}]`;
-}
-
-export function summarizeCompactionOutputForDiagnostics(rawOutput: readonly unknown[], sanitizedOutput: readonly unknown[]): string {
-	const rawTypes = rawOutput.map((item) => isRecord(item) && typeof item.type === "string" ? item.type : typeof item);
-	const sanitizedTypes = sanitizedOutput.map((item) => isRecord(item) && typeof item.type === "string" ? item.type : typeof item);
-	const rawCounts = countValues(rawTypes);
-	const sanitizedCounts = countValues(sanitizedTypes);
-	const sample = rawOutput.slice(0, 8).map((item, index) => `${index}: ${describeOutputItem(item)}`).join("; ");
-	return `raw=${rawOutput.length} {${rawCounts}}; sanitized=${sanitizedOutput.length} {${sanitizedCounts}}; sample=${sample || "<empty>"}`;
-}
-
-function countValues(values: readonly string[]): string {
-	const counts = new Map<string, number>();
-	for (const value of values) counts.set(value, (counts.get(value) ?? 0) + 1);
-	return Array.from(counts.entries()).map(([value, count]) => `${value}:${count}`).join(", ");
-}

package/src/adapter/compaction-runtime.ts

@@ -1,272 +0,0 @@
-import type { Api, Model } from "@earendil-works/pi-ai";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-
-export const DEFAULT_SUPPORTED_PROVIDERS = ["openai", "openai-codex"] as const;
-export const DEFAULT_SUPPORTED_APIS = ["openai-responses", "openai-codex-responses"] as const;
-const OPENAI_COMPACT_PATH = "responses/compact";
-const CODEX_COMPACT_PATH = "codex/responses/compact";
-
-type BuiltInSupportedProvider = (typeof DEFAULT_SUPPORTED_PROVIDERS)[number];
-type DefaultSupportedApi = (typeof DEFAULT_SUPPORTED_APIS)[number];
-
-type RuntimeModel = Model<Api>;
-
-type NativeCompactionFailureReason =
-	| "disabled"
-	| "missing-model"
-	| "unsupported-provider"
-	| "unsupported-api"
-	| "missing-base-url"
-	| "missing-api-key"
-	| "unsupported-payload"
-	| "payload-model-mismatch";
-
-export type NativeCompactionSupportOptions = {
-	enabled?: boolean;
-	supportedProviders?: readonly string[];
-	supportedApis?: readonly string[];
-};
-
-export type ResponsesCompatibleRequestPayload = {
-	model: string;
-	input: unknown[];
-	instructions?: unknown;
-	[key: string]: unknown;
-};
-
-export type NativeCompactionRuntime = {
-	provider: string;
-	api: DefaultSupportedApi;
-	apiFamily: DefaultSupportedApi;
-	model: string;
-	baseUrl: string;
-	apiKey?: string;
-	headers?: Record<string, string>;
-	compactPath: string;
-	compactUrl: string;
-	payload?: ResponsesCompatibleRequestPayload;
-	currentModel: RuntimeModel;
-};
-
-export type NativeCompactionEnvironmentFailure = {
-	ok: false;
-	reason: NativeCompactionFailureReason;
-	provider?: string;
-	api?: string;
-	model?: string;
-	baseUrl?: string;
-};
-
-export type NativeCompactionEnvironmentSuccess = {
-	ok: true;
-	runtime: NativeCompactionRuntime;
-};
-
-export type NativeCompactionEnvironmentResolution =
-	| NativeCompactionEnvironmentFailure
-	| NativeCompactionEnvironmentSuccess;
-
-function normalizeConfiguredSet(values: readonly string[] | undefined, defaults: readonly string[]): Set<string> {
-	const source = values && values.length > 0 ? values : defaults;
-	return new Set(source.map((value) => value.trim()).filter((value) => value.length > 0));
-}
-
-export function normalizeBaseUrl(baseUrl: string | undefined | null): string | undefined {
-	const normalized = baseUrl?.trim().replace(/\/+$/, "");
-	return normalized ? normalized : undefined;
-}
-
-function buildOpenAICompactUrl(baseUrl: string): string {
-	const normalized = normalizeBaseUrl(baseUrl) ?? baseUrl;
-	if (normalized.endsWith("/responses")) {
-		return `${normalized}/compact`;
-	}
-	return `${normalized}/${OPENAI_COMPACT_PATH}`;
-}
-
-function buildCodexCompactUrl(baseUrl: string): string {
-	const normalized = normalizeBaseUrl(baseUrl) ?? baseUrl;
-	if (normalized.endsWith("/codex/responses")) {
-		return `${normalized}/compact`;
-	}
-	if (normalized.endsWith("/codex")) {
-		return `${normalized}/responses/compact`;
-	}
-	return `${normalized}/${CODEX_COMPACT_PATH}`;
-}
-
-export function buildCompactUrl(baseUrl: string, api: DefaultSupportedApi): string {
-	return api === "openai-codex-responses" ? buildCodexCompactUrl(baseUrl) : buildOpenAICompactUrl(baseUrl);
-}
-
-export function buildCompactPath(api: DefaultSupportedApi): string {
-	return api === "openai-codex-responses" ? CODEX_COMPACT_PATH : OPENAI_COMPACT_PATH;
-}
-
-export function isSupportedProvider(provider: string): provider is BuiltInSupportedProvider {
-	return (DEFAULT_SUPPORTED_PROVIDERS as readonly string[]).includes(provider);
-}
-
-async function resolveRequestAuth(
-	ctx: ExtensionContext,
-	model: RuntimeModel,
-): Promise<{ apiKey?: string; headers?: Record<string, string> }> {
-	const modelRegistry = ctx.modelRegistry as {
-		getApiKeyAndHeaders?: (currentModel: RuntimeModel) => Promise<
-			| { ok: true; apiKey?: string; headers?: Record<string, string> }
-			| { ok: false; error: string }
-		>;
-	};
-
-	if (typeof modelRegistry.getApiKeyAndHeaders !== "function") {
-		return {};
-	}
-
-	const auth = await modelRegistry.getApiKeyAndHeaders(model);
-	return auth.ok ? { apiKey: auth.apiKey, headers: auth.headers } : {};
-}
-
-export function isSupportedApi(api: string): api is DefaultSupportedApi {
-	return (DEFAULT_SUPPORTED_APIS as readonly string[]).includes(api);
-}
-
-export function isResponsesCompatiblePayload(payload: unknown): payload is ResponsesCompatibleRequestPayload {
-	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 getRuntimeModelDescriptor(model: RuntimeModel | undefined): {
-	provider?: string;
-	api?: string;
-	model?: string;
-	baseUrl?: string;
-} {
-	if (!model) {
-		return {};
-	}
-
-	return {
-		provider: model.provider,
-		api: model.api,
-		model: model.id,
-		baseUrl: normalizeBaseUrl(model.baseUrl),
-	};
-}
-
-export async function resolveNativeCompactionEnvironment(
-	ctx: ExtensionContext,
-	options: NativeCompactionSupportOptions = {},
-	payload?: unknown,
-): Promise<NativeCompactionEnvironmentResolution> {
-	if (options.enabled === false) {
-		return {
-			ok: false,
-			reason: "disabled",
-		};
-	}
-
-	const currentModel = ctx.model;
-	const descriptor = getRuntimeModelDescriptor(currentModel);
-	if (!currentModel || !descriptor.provider || !descriptor.api || !descriptor.model) {
-		return {
-			ok: false,
-			reason: "missing-model",
-			...descriptor,
-		};
-	}
-
-	const supportedProviders = normalizeConfiguredSet(options.supportedProviders, DEFAULT_SUPPORTED_PROVIDERS);
-	if (!supportedProviders.has(descriptor.provider)) {
-		return {
-			ok: false,
-			reason: "unsupported-provider",
-			...descriptor,
-		};
-	}
-
-	const supportedApis = normalizeConfiguredSet(options.supportedApis, DEFAULT_SUPPORTED_APIS);
-	if (!supportedApis.has(descriptor.api)) {
-		return {
-			ok: false,
-			reason: "unsupported-api",
-			...descriptor,
-		};
-	}
-
-	if (!isSupportedApi(descriptor.api)) {
-		return {
-			ok: false,
-			reason: "unsupported-api",
-			...descriptor,
-		};
-	}
-
-	if (!descriptor.baseUrl) {
-		return {
-			ok: false,
-			reason: "missing-base-url",
-			...descriptor,
-		};
-	}
-
-	let requestPayload: ResponsesCompatibleRequestPayload | undefined;
-	if (payload !== undefined) {
-		if (!isResponsesCompatiblePayload(payload)) {
-			return {
-				ok: false,
-				reason: "unsupported-payload",
-				...descriptor,
-			};
-		}
-
-		if (payload.model !== descriptor.model) {
-			return {
-				ok: false,
-				reason: "payload-model-mismatch",
-				...descriptor,
-			};
-		}
-
-		requestPayload = payload;
-	}
-
-	const { apiKey, headers } = await resolveRequestAuth(ctx, currentModel);
-	const hasAuthorizationHeader = Object.entries(headers ?? {}).some(([key, value]) => key.toLowerCase() === "authorization" && value.trim().length > 0);
-	if (!apiKey && !hasAuthorizationHeader) {
-		return {
-			ok: false,
-			reason: "missing-api-key",
-			...descriptor,
-		};
-	}
-
-	return {
-		ok: true,
-		runtime: {
-			provider: descriptor.provider,
-			api: descriptor.api,
-			apiFamily: descriptor.api,
-			model: descriptor.model,
-			baseUrl: descriptor.baseUrl,
-			apiKey,
-			headers,
-			compactPath: buildCompactPath(descriptor.api),
-			compactUrl: buildCompactUrl(descriptor.baseUrl, descriptor.api),
-			payload: requestPayload,
-			currentModel,
-		},
-	};
-}
-
-export async function getNativeCompactionRuntime(
-	ctx: ExtensionContext,
-	options: NativeCompactionSupportOptions = {},
-	payload?: unknown,
-): Promise<NativeCompactionRuntime | undefined> {
-	const resolution = await resolveNativeCompactionEnvironment(ctx, options, payload);
-	return resolution.ok ? resolution.runtime : undefined;
-}