@fased/fased 0.1.55 → 0.1.57

package/dist/agents/openai-codex-app-server.js

@@ -0,0 +1,524 @@
+import { resolveFasedAgentPackageRootSync } from "../infra/fased-root.js";
+import { resolvePluginInstallDir } from "../plugins/install.js";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { createAssistantMessageEventStream } from "@mariozechner/pi-ai/compat";
+import readline from "node:readline";
+
+//#region src/agents/openai-codex-app-server.ts
+const OPENAI_CODEX_APP_SERVER_VERSION = "0.144.1";
+const DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function decodeJwtPayload(token) {
+	const encoded = token.split(".")[1];
+	if (!encoded) {
+		return null;
+	}
+	try {
+		const parsed = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function extractOpenAICodexAccountId(token) {
+	const payload = decodeJwtPayload(token);
+	const auth = payload?.["https://api.openai.com/auth"];
+	if (!isRecord(auth)) {
+		return null;
+	}
+	const accountId = auth.chatgpt_account_id;
+	return typeof accountId === "string" && accountId.trim() ? accountId.trim() : null;
+}
+function stateDir() {
+	return process.env.FASED_STATE_DIR?.trim() || path.join(process.env.HOME?.trim() || os.homedir(), ".fased");
+}
+function executableName() {
+	return process.platform === "win32" ? "codex.exe" : "codex";
+}
+function codexExecutableCandidates() {
+	const configured = process.env.FASED_CODEX_BIN?.trim();
+	const componentRoot = resolvePluginInstallDir("openai-runtime");
+	const packageRoot = resolveFasedAgentPackageRootSync({
+		moduleUrl: import.meta.url,
+		argv1: process.argv[1],
+		cwd: process.cwd()
+	});
+	const candidates = [
+		configured,
+		path.join(componentRoot, "node_modules", ".bin", executableName()),
+		path.join(componentRoot, "node_modules", "@openai", "codex", "bin", executableName()),
+		packageRoot ? path.join(packageRoot, "extensions", "runtime-openai", "node_modules", ".bin", executableName()) : undefined
+	].filter((value) => Boolean(value));
+	return [...new Set(candidates)];
+}
+function resolveOpenAICodexExecutable() {
+	const explicitlyConfigured = process.env.FASED_CODEX_BIN?.trim();
+	for (const candidate of codexExecutableCandidates()) {
+		try {
+			if (!fs.statSync(candidate).isFile()) {
+				continue;
+			}
+			if (explicitlyConfigured && candidate === explicitlyConfigured) {
+				return candidate;
+			}
+			const resolved = fs.realpathSync(candidate);
+			let current = path.dirname(resolved);
+			for (let depth = 0; depth < 6; depth += 1) {
+				try {
+					const parsed = JSON.parse(fs.readFileSync(path.join(current, "package.json"), "utf8"));
+					if (parsed.name === "@openai/codex") {
+						if (parsed.version === OPENAI_CODEX_APP_SERVER_VERSION) {
+							return candidate;
+						}
+						break;
+					}
+				} catch {}
+				const parent = path.dirname(current);
+				if (parent === current) {
+					break;
+				}
+				current = parent;
+			}
+		} catch {}
+	}
+	return null;
+}
+function managedCodexHome() {
+	const directory = path.join(stateDir(), "runtime", "openai-codex");
+	fs.mkdirSync(directory, {
+		recursive: true,
+		mode: 448
+	});
+	return directory;
+}
+var CodexAppServerClient = class {
+	constructor(command) {
+		this.pending = new Map();
+		this.notificationListeners = new Set();
+		this.nextId = 1;
+		this.closedError = null;
+		this.child = spawn(command, [
+			"app-server",
+			"--stdio",
+			"--disable",
+			"shell_tool",
+			"--config",
+			"web_search=\"disabled\""
+		], {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				CODEX_HOME: managedCodexHome()
+			}
+		});
+		this.lines = readline.createInterface({ input: this.child.stdout });
+		this.lines.on("line", (line) => this.handleLine(line));
+		this.child.once("error", (error) => this.closeWithError(error));
+		this.child.once("exit", (code, signal) => {
+			if (!this.closedError && (code !== 0 || signal)) {
+				this.closeWithError(new Error(`OpenAI sign-in runtime exited (code=${String(code)}, signal=${String(signal)})`));
+			}
+		});
+	}
+	onNotification(listener) {
+		this.notificationListeners.add(listener);
+		return () => this.notificationListeners.delete(listener);
+	}
+	async request(method, params = {}, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+		if (this.closedError) {
+			throw this.closedError;
+		}
+		const id = this.nextId++;
+		const promise = new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(id);
+				reject(new Error(`OpenAI sign-in runtime timed out waiting for ${method}`));
+			}, timeoutMs);
+			timer.unref?.();
+			this.pending.set(id, {
+				resolve,
+				reject,
+				timer
+			});
+		});
+		this.child.stdin.write(`${JSON.stringify({
+			id,
+			method,
+			params
+		})}\n`);
+		return await promise;
+	}
+	respond(id, result) {
+		this.child.stdin.write(`${JSON.stringify({
+			id,
+			result
+		})}\n`);
+	}
+	close() {
+		this.lines.close();
+		this.child.kill("SIGTERM");
+	}
+	handleLine(line) {
+		let message;
+		try {
+			message = JSON.parse(line);
+		} catch {
+			return;
+		}
+		if (message.id !== undefined && !message.method) {
+			const request = this.pending.get(message.id);
+			if (!request) {
+				return;
+			}
+			this.pending.delete(message.id);
+			clearTimeout(request.timer);
+			if (message.error) {
+				request.reject(new Error(message.error.message || "OpenAI sign-in runtime request failed"));
+			} else {
+				request.resolve(message.result);
+			}
+			return;
+		}
+		for (const listener of this.notificationListeners) {
+			listener(message);
+		}
+	}
+	closeWithError(error) {
+		this.closedError = error;
+		for (const request of this.pending.values()) {
+			clearTimeout(request.timer);
+			request.reject(error);
+		}
+		this.pending.clear();
+	}
+};
+async function initializeClient(client, token) {
+	const accountId = extractOpenAICodexAccountId(token);
+	if (!accountId) {
+		throw new Error("OpenAI sign-in token does not contain a ChatGPT account ID");
+	}
+	await client.request("initialize", {
+		clientInfo: {
+			name: "fased",
+			title: "Fased Agent",
+			version: OPENAI_CODEX_APP_SERVER_VERSION
+		},
+		capabilities: { experimentalApi: true }
+	});
+	await client.request("account/login/start", {
+		type: "chatgptAuthTokens",
+		accessToken: token,
+		chatgptAccountId: accountId,
+		chatgptPlanType: null
+	});
+	client.onNotification((message) => {
+		if (message.id === undefined || message.method !== "account/chatgptAuthTokens/refresh") {
+			return;
+		}
+		client.respond(message.id, {
+			accessToken: token,
+			chatgptAccountId: accountId,
+			chatgptPlanType: null
+		});
+	});
+}
+function parseAppServerModels(value) {
+	if (!isRecord(value) || !Array.isArray(value.data)) {
+		return [];
+	}
+	return value.data.flatMap((entry) => {
+		if (!isRecord(entry) || typeof entry.id !== "string" || !entry.id.trim()) {
+			return [];
+		}
+		const efforts = Array.isArray(entry.supportedReasoningEfforts) ? entry.supportedReasoningEfforts.flatMap((item) => isRecord(item) && typeof item.reasoningEffort === "string" ? [item.reasoningEffort] : []) : [];
+		const modalities = Array.isArray(entry.inputModalities) ? entry.inputModalities.filter((item) => item === "text" || item === "image") : [];
+		return [{
+			id: entry.id.trim(),
+			displayName: typeof entry.displayName === "string" && entry.displayName.trim() ? entry.displayName.trim() : entry.id.trim(),
+			...typeof entry.description === "string" && entry.description.trim() ? { description: entry.description.trim() } : {},
+			hidden: entry.hidden === true,
+			inputModalities: modalities.length > 0 ? modalities : ["text"],
+			supportedReasoningEfforts: efforts,
+			...typeof entry.defaultReasoningEffort === "string" ? { defaultReasoningEffort: entry.defaultReasoningEffort } : {}
+		}];
+	});
+}
+async function listOpenAICodexAppServerModels(params) {
+	const executable = params.executable ?? (params.resolveExecutable ? await params.resolveExecutable() : resolveOpenAICodexExecutable());
+	if (!executable) {
+		throw new Error("OpenAI sign-in runtime is not installed. Run `fased components install openai-runtime`.");
+	}
+	const client = new CodexAppServerClient(executable);
+	try {
+		await initializeClient(client, params.token);
+		return parseAppServerModels(await client.request("model/list", { includeHidden: false }, 15e3)).filter((model) => !model.hidden);
+	} finally {
+		client.close();
+	}
+}
+function contentText(content) {
+	if (typeof content === "string") {
+		return content;
+	}
+	if (!Array.isArray(content)) {
+		return "";
+	}
+	return content.flatMap((part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("\n");
+}
+function renderConversationContext(context) {
+	const messages = context.messages;
+	const latestUserIndex = messages.findLastIndex((message) => message.role === "user");
+	const latest = latestUserIndex >= 0 ? messages[latestUserIndex] : undefined;
+	const prior = messages.slice(0, Math.max(0, latestUserIndex));
+	const transcript = prior.map((message) => {
+		if (message.role === "toolResult") {
+			return `Tool ${message.toolName}: ${contentText(message.content)}`;
+		}
+		return `${message.role === "assistant" ? "Assistant" : "User"}: ${contentText(message.content)}`;
+	}).filter((value) => !value.endsWith(": ")).join("\n\n");
+	const instructions = [
+		context.systemPrompt?.trim(),
+		transcript ? `Conversation before the current user message:\n${transcript}` : "",
+		"Answer the current user message directly. Fased tools are unavailable in this transport turn."
+	].filter(Boolean).join("\n\n");
+	return {
+		instructions,
+		prompt: latest ? contentText(latest.content) : "Continue the conversation."
+	};
+}
+function emptyUsage() {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+}
+function readUsageNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function parseThreadTokenUsage(value) {
+	if (!isRecord(value)) {
+		return null;
+	}
+	const last = isRecord(value.last) ? value.last : null;
+	if (!last) {
+		return null;
+	}
+	const input = readUsageNumber(last.inputTokens);
+	const output = readUsageNumber(last.outputTokens);
+	const cacheRead = readUsageNumber(last.cachedInputTokens);
+	const totalTokens = readUsageNumber(last.totalTokens) || input + output;
+	return {
+		input,
+		output,
+		cacheRead,
+		cacheWrite: 0,
+		totalTokens,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+}
+function createOpenAICodexAppServerStreamFn(params) {
+	return (model, context, options) => {
+		const eventStream = createAssistantMessageEventStream();
+		const stream = eventStream;
+		void (async () => {
+			const output = {
+				role: "assistant",
+				content: [],
+				api: model.api,
+				provider: model.provider,
+				model: model.id,
+				usage: emptyUsage(),
+				stopReason: "stop",
+				timestamp: Date.now()
+			};
+			let client;
+			try {
+				const token = options?.apiKey?.trim() || (await params?.resolveToken?.())?.trim();
+				if (!token) {
+					throw new Error("OpenAI ChatGPT sign-in is required");
+				}
+				const executable = params?.resolveExecutable ? await params.resolveExecutable() : resolveOpenAICodexExecutable();
+				if (!executable) {
+					throw new Error("OpenAI sign-in runtime is not installed. Run `fased components install openai-runtime`.");
+				}
+				client = new CodexAppServerClient(executable);
+				await initializeClient(client, token);
+				const { instructions, prompt } = renderConversationContext(context);
+				const started = await client.request("thread/start", {
+					model: model.id,
+					cwd: process.cwd(),
+					approvalPolicy: "never",
+					sandbox: "read-only",
+					ephemeral: true,
+					baseInstructions: instructions,
+					config: {
+						web_search: "disabled",
+						features: { shell_tool: false }
+					}
+				});
+				const thread = isRecord(started.thread) ? started.thread : null;
+				const threadId = typeof thread?.id === "string" ? thread.id : "";
+				if (!threadId) {
+					throw new Error("OpenAI sign-in runtime did not create a thread");
+				}
+				let text = "";
+				let settled = false;
+				let settle;
+				let reject;
+				const completed = new Promise((resolve, rejectPromise) => {
+					settle = resolve;
+					reject = rejectPromise;
+				});
+				stream.push({
+					type: "start",
+					partial: output
+				});
+				const unsubscribe = client.onNotification((message) => {
+					if (message.id !== undefined && message.method) {
+						client?.respond(message.id, {
+							contentItems: [{
+								type: "inputText",
+								text: "Tool unavailable in this Fased turn."
+							}],
+							success: false
+						});
+						return;
+					}
+					if (message.method === "item/agentMessage/delta") {
+						const delta = typeof message.params?.delta === "string" ? message.params.delta : "";
+						if (!delta) {
+							return;
+						}
+						if (text.length === 0) {
+							output.content = [{
+								type: "text",
+								text: ""
+							}];
+							stream.push({
+								type: "text_start",
+								contentIndex: 0,
+								partial: output
+							});
+						}
+						text += delta;
+						output.content[0] = {
+							type: "text",
+							text
+						};
+						stream.push({
+							type: "text_delta",
+							contentIndex: 0,
+							delta,
+							partial: output
+						});
+						return;
+					}
+					if (message.method === "thread/tokenUsage/updated") {
+						const usage = parseThreadTokenUsage(message.params?.tokenUsage);
+						if (usage) {
+							output.usage = usage;
+						}
+						return;
+					}
+					if (message.method !== "turn/completed" || settled) {
+						return;
+					}
+					const turn = isRecord(message.params?.turn) ? message.params.turn : null;
+					settled = true;
+					if (turn?.status === "completed") {
+						settle();
+					} else {
+						const error = isRecord(turn?.error) ? turn.error : null;
+						const status = typeof turn?.status === "string" ? turn.status : "unknown";
+						reject(new Error(typeof error?.message === "string" ? error.message : `OpenAI sign-in turn ended with status ${status}`));
+					}
+				});
+				await client.request("turn/start", {
+					threadId,
+					input: [{
+						type: "text",
+						text: prompt,
+						text_elements: []
+					}],
+					...options?.reasoning ? { effort: options.reasoning } : {}
+				});
+				const abort = () => reject(new Error("Request was aborted"));
+				options?.signal?.addEventListener("abort", abort, { once: true });
+				try {
+					await Promise.race([completed, new Promise((_, rejectTimeout) => {
+						const timer = setTimeout(() => rejectTimeout(new Error("OpenAI sign-in turn timed out")), DEFAULT_REQUEST_TIMEOUT_MS);
+						timer.unref?.();
+					})]);
+				} finally {
+					options?.signal?.removeEventListener("abort", abort);
+					unsubscribe();
+				}
+				if (text.length > 0) {
+					stream.push({
+						type: "text_end",
+						contentIndex: 0,
+						content: text,
+						partial: output
+					});
+				}
+				stream.push({
+					type: "done",
+					reason: "stop",
+					message: output
+				});
+				stream.end();
+			} catch (error) {
+				const failed = {
+					...output,
+					stopReason: options?.signal?.aborted ? "aborted" : "error",
+					errorMessage: error instanceof Error ? error.message : String(error)
+				};
+				stream.push({
+					type: "error",
+					reason: failed.stopReason,
+					error: failed
+				});
+				stream.end();
+			} finally {
+				client?.close();
+			}
+		})();
+		return eventStream;
+	};
+}
+function isOpenAICodexAppServerModel(model) {
+	return model.provider === "openai-codex" && model.compat?.responsesLite === true;
+}
+const testing = {
+	parseAppServerModels,
+	parseThreadTokenUsage,
+	renderConversationContext
+};
+
+//#endregion
+export { createOpenAICodexAppServerStreamFn, listOpenAICodexAppServerModels, resolveOpenAICodexExecutable };

package/dist/agents/openai-codex-runtime-component.js

@@ -0,0 +1,39 @@
+import { VERSION } from "../version.js";
+import { resolveOpenAICodexExecutable } from "./openai-codex-app-server.js";
+import { installCapabilityComponent } from "../capabilities/install.js";
+
+//#region src/agents/openai-codex-runtime-component.ts
+const OPENAI_RUNTIME_COMPONENT_ID = "openai-runtime";
+function hasConfiguredOpenAICodexProfile(config) {
+	return Object.values(config.auth?.profiles ?? {}).some((profile) => profile?.provider === "openai-codex");
+}
+async function ensureOpenAICodexRuntimeComponent(params) {
+	const resolveExecutable = params.resolveExecutable ?? resolveOpenAICodexExecutable;
+	const existing = resolveExecutable();
+	if (existing) {
+		return {
+			config: params.config,
+			executable: existing,
+			installed: false,
+			slotWarnings: []
+		};
+	}
+	const installed = await (params.installComponent ?? installCapabilityComponent)({
+		id: OPENAI_RUNTIME_COMPONENT_ID,
+		config: params.config,
+		packageSpec: `@fased/openai-runtime@${params.version ?? VERSION}`
+	});
+	const executable = resolveExecutable();
+	if (!executable) {
+		throw new Error("OpenAI sign-in runtime installation completed without an executable. Run `fased components install openai-runtime` and retry.");
+	}
+	return {
+		config: installed.config,
+		executable,
+		installed: true,
+		slotWarnings: installed.slotWarnings
+	};
+}
+
+//#endregion
+export { OPENAI_RUNTIME_COMPONENT_ID, ensureOpenAICodexRuntimeComponent, hasConfiguredOpenAICodexProfile };

package/dist/agents/pi-embedded-runner/compact.js

@@ -19,13 +19,13 @@ import { enqueueCommandInLane } from "../../process/command-queue.js";
 import { resolveSignalReactionLevel } from "../../signal/reaction-level.js";
 import { resolveTelegramInlineButtonsScope } from "../../telegram/inline-buttons.js";
 import { resolveTelegramReactionLevel } from "../../telegram/reaction-level.js";
+import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone } from "../date-time.js";
 import { buildModelAliasLines } from "../model-alias-lines.js";
-import { resolveModel } from "./model.js";
+import { resolveModelForExecution } from "./model.js";
 import { buildTtsSystemPromptHint } from "../../tts/tts.js";
 import { isReasoningTagProvider } from "../../utils/provider-utils.js";
 import { makeBootstrapWarn, resolveBootstrapContextForRun } from "../bootstrap-files.js";
 import { listChannelSupportedActions, resolveChannelMessageToolHints } from "../channel-tools.js";
-import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone } from "../date-time.js";
 import { resolveFasedAgentDocsPath } from "../docs-path.js";
 import { createPreparedEmbeddedPiSettingsManager } from "../pi-project-settings.js";
 import { detectRuntimeShell } from "../shell-utils.js";
@@ -177,7 +177,7 @@ async function compactEmbeddedPiSessionDirect(params) {
 	};
 	const agentDir = params.agentDir ?? resolveFasedAgentAgentDir();
 	await ensureFasedAgentModelsJson(params.config, agentDir);
-	const { model, error, authStorage, modelRegistry } = resolveModel(provider, modelId, agentDir, params.config);
+	const { model, error, authStorage, modelRegistry } = await resolveModelForExecution(provider, modelId, agentDir, params.config);
 	if (!model) {
 		const reason = error ?? `Unknown model: ${provider}/${modelId}`;
 		return fail(reason);