@fased/fased 0.1.54 → 0.1.56

package/dist/plugins/manifest.js

@@ -1,7 +1,7 @@
 import { isRecord } from "../utils.js";
 import { openBoundaryFileSync } from "../infra/boundary-file-read.js";
 import { MANIFEST_KEY } from "../project.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 import JSON5 from "json5";
 
@@ -169,7 +169,7 @@ function normalizeChannelConfigs(value) {
 function resolvePluginManifestPath(rootDir) {
 	for (const filename of PLUGIN_MANIFEST_FILENAMES) {
 		const candidate = path.join(rootDir, filename);
-		if (fs.existsSync(candidate)) {
+		if (syncFs.existsSync(candidate)) {
 			return candidate;
 		}
 	}
@@ -198,7 +198,7 @@ function loadPluginManifest(rootDir) {
 	}
 	let raw;
 	try {
-		raw = JSON5.parse(fs.readFileSync(opened.fd, "utf-8"));
+		raw = JSON5.parse(syncFs.readFileSync(opened.fd, "utf-8"));
 	} catch (err) {
 		return {
 			ok: false,
@@ -206,7 +206,7 @@ function loadPluginManifest(rootDir) {
 			manifestPath
 		};
 	} finally {
-		fs.closeSync(opened.fd);
+		syncFs.closeSync(opened.fd);
 	}
 	if (!isRecord(raw)) {
 		return {

package/dist/plugins/path-safety.js

@@ -1,5 +1,5 @@
 import { isPathInside as isPathInside$1 } from "../infra/path-guards.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 
 //#region src/plugins/path-safety.ts
 function isPathInside(baseDir, targetPath) {
@@ -11,7 +11,7 @@ function safeRealpathSync(targetPath, cache) {
 		return cached;
 	}
 	try {
-		const resolved = fs.realpathSync(targetPath);
+		const resolved = syncFs.realpathSync(targetPath);
 		cache?.set(targetPath, resolved);
 		return resolved;
 	} catch {
@@ -20,7 +20,7 @@ function safeRealpathSync(targetPath, cache) {
 }
 function safeStatSync(targetPath) {
 	try {
-		return fs.statSync(targetPath);
+		return syncFs.statSync(targetPath);
 	} catch {
 		return null;
 	}

package/dist/plugins/runtime/index.js

@@ -20,7 +20,6 @@ import { resolveEffectiveMessagesConfig, resolveHumanDelayConfig } from "../../a
 import { mediaKindFromMime } from "../../media/constants.js";
 import { detectMime } from "../../media/mime.js";
 import { isVoiceCompatibleAudio } from "../../media/audio.js";
-import { textToSpeechTelephony } from "../../tts/tts.js";
 import { getImageMetadata, resizeToJpeg } from "../../media/image-ops.js";
 import { createMemoryGetTool, createMemorySearchTool } from "../../agents/tools/memory-tool.js";
 import { chunkByNewline, chunkMarkdownText, chunkMarkdownTextWithMode, chunkText, chunkTextWithMode, resolveChunkMode, resolveTextChunkLimit } from "../../auto-reply/chunk.js";
@@ -65,6 +64,7 @@ import "../../signal/index.js";
 import { auditTelegramGroupMembership, collectTelegramUnmentionedGroupIds } from "../../telegram/audit.js";
 import { getActiveWebListener } from "../../web/active-listener.js";
 import { formatNativeDependencyHint } from "./native-deps.js";
+import { textToSpeechTelephony } from "../../tts/tts.js";
 import { createRequire } from "node:module";
 
 //#region src/plugins/runtime/index.ts

package/dist/plugins/status-cache.js

@@ -1,4 +1,4 @@
-import fs from "node:fs";
+import syncFs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createHash } from "node:crypto";
@@ -7,7 +7,7 @@ import { createHash } from "node:crypto";
 const CACHE_SCHEMA_VERSION = 2;
 function statMtimeMs(filePath) {
 	try {
-		return fs.statSync(filePath).mtimeMs;
+		return syncFs.statSync(filePath).mtimeMs;
 	} catch {
 		return null;
 	}
@@ -23,7 +23,7 @@ function canonicalize(value) {
 }
 function configFingerprint(configPath) {
 	try {
-		const parsed = JSON.parse(fs.readFileSync(configPath, "utf8"));
+		const parsed = JSON.parse(syncFs.readFileSync(configPath, "utf8"));
 		return createHash("sha256").update(JSON.stringify(canonicalize({ plugins: parsed.plugins }))).digest("hex");
 	} catch {
 		return createHash("sha256").update("missing-config").digest("hex");
@@ -41,9 +41,9 @@ function readCurrentPackageVersion(argv1) {
 		return null;
 	}
 	try {
-		const entry = fs.realpathSync(argv1);
+		const entry = syncFs.realpathSync(argv1);
 		const packagePath = path.join(path.dirname(entry), "package.json");
-		const parsed = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+		const parsed = JSON.parse(syncFs.readFileSync(packagePath, "utf8"));
 		return typeof parsed.version === "string" ? parsed.version : null;
 	} catch {
 		return null;
@@ -53,7 +53,7 @@ function readValidPluginStatusCache(params) {
 	const cachePath = params.cachePath ?? resolvePluginStatusCachePath();
 	const configPath = params.configPath ?? resolvePluginStatusConfigPath();
 	try {
-		const parsed = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+		const parsed = JSON.parse(syncFs.readFileSync(cachePath, "utf8"));
 		if (parsed.schemaVersion !== CACHE_SCHEMA_VERSION || parsed.packageVersion !== params.packageVersion || parsed.configPath !== configPath || parsed.configFingerprint !== configFingerprint(configPath) || !Array.isArray(parsed.plugins) || !Array.isArray(parsed.diagnostics)) {
 			return null;
 		}
@@ -96,16 +96,16 @@ function writePluginStatusCache(params) {
 			source: diagnostic.source
 		}))
 	};
-	fs.mkdirSync(path.dirname(cachePath), {
+	syncFs.mkdirSync(path.dirname(cachePath), {
 		recursive: true,
 		mode: 448
 	});
 	const temporaryPath = `${cachePath}.tmp-${process.pid}`;
-	fs.writeFileSync(temporaryPath, `${JSON.stringify(cache)}\n`, {
+	syncFs.writeFileSync(temporaryPath, `${JSON.stringify(cache)}\n`, {
 		encoding: "utf8",
 		mode: 384
 	});
-	fs.renameSync(temporaryPath, cachePath);
+	syncFs.renameSync(temporaryPath, cachePath);
 }
 
 //#endregion

package/dist/plugins/update.js

@@ -3,7 +3,7 @@ import { openBoundaryFileSync } from "../infra/boundary-file-read.js";
 import { installPluginFromNpmSpec, resolvePluginInstallDir } from "./install.js";
 import { resolveBundledPluginSources } from "./bundled-sources.js";
 import { buildNpmResolutionInstallFields, recordPluginInstall } from "./installs.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/plugins/update.ts
@@ -86,14 +86,14 @@ async function readInstalledPackageVersion(dir, opts) {
 		return undefined;
 	}
 	try {
-		const raw = fs.readFileSync(opened.fd, "utf-8");
+		const raw = syncFs.readFileSync(opened.fd, "utf-8");
 		const parsed = JSON.parse(raw);
 		return typeof parsed.version === "string" ? parsed.version : undefined;
 	} catch (err) {
 		opts?.logger?.warn?.(`Could not inspect installed package for "${opts.pluginId ?? path.basename(dir)}": package.json is unreadable (${formatUpdateError(err)}). Continuing update with unknown current version.`);
 		return undefined;
 	} finally {
-		fs.closeSync(opened.fd);
+		syncFs.closeSync(opened.fd);
 	}
 }
 function pathsEqual(left, right) {

package/dist/plugins/web-search-install-catalog.js

@@ -1,7 +1,7 @@
 import { CONFIG_DIR, isRecord, resolveUserPath } from "../utils.js";
 import { resolveFasedAgentPackageRootSync } from "../infra/fased-root.js";
 import { enablePluginInConfig } from "./enable.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 
 //#region src/plugins/web-search-install-catalog.ts
@@ -48,11 +48,11 @@ function parseCatalogEntries(raw) {
 function loadCatalogEntriesFromPaths(paths) {
 	const entries = [];
 	for (const resolved of paths) {
-		if (!fs.existsSync(resolved)) {
+		if (!syncFs.existsSync(resolved)) {
 			continue;
 		}
 		try {
-			const payload = JSON.parse(fs.readFileSync(resolved, "utf-8"));
+			const payload = JSON.parse(syncFs.readFileSync(resolved, "utf-8"));
 			entries.push(...parseCatalogEntries(payload));
 		} catch {}
 	}

package/dist/providers/github-copilot-model-discovery.js

@@ -0,0 +1,51 @@
+import { resolveCopilotApiToken } from "./github-copilot-token.js";
+import { listProfilesForProvider } from "../agents/auth-profiles/profiles.js";
+import { resolveApiKeyForProfile } from "../agents/auth-profiles/oauth.js";
+import "../agents/auth-profiles.js";
+import { buildCopilotIdeHeaders } from "../agents/copilot-dynamic-headers.js";
+import { parseGenericModelSnapshotsFromModelsResponse } from "./refresh.js";
+
+//#region src/providers/github-copilot-model-discovery.ts
+const GITHUB_COPILOT_ROUTE = "github-copilot";
+const DISCOVERY_TIMEOUT_MS = 8e3;
+function modelsUrl(baseUrl) {
+	return `${baseUrl.replace(/\/+$/, "")}/models`;
+}
+async function discoverGitHubCopilotModels(params) {
+	const profileId = listProfilesForProvider(params.store, GITHUB_COPILOT_ROUTE)[0];
+	if (!profileId) {
+		return [];
+	}
+	const resolved = await resolveApiKeyForProfile({
+		cfg: params.cfg,
+		store: params.store,
+		profileId,
+		agentDir: params.agentDir
+	});
+	if (!resolved?.apiKey) {
+		return [];
+	}
+	const fetchImpl = params.fetchImpl ?? fetch;
+	const copilot = await resolveCopilotApiToken({
+		githubToken: resolved.apiKey,
+		fetchImpl
+	});
+	const response = await fetchImpl(modelsUrl(copilot.baseUrl), {
+		headers: {
+			Accept: "application/json",
+			Authorization: `Bearer ${copilot.token}`,
+			...buildCopilotIdeHeaders({ includeApiVersion: true })
+		},
+		signal: AbortSignal.timeout(DISCOVERY_TIMEOUT_MS)
+	});
+	if (!response.ok) {
+		throw new Error(`GitHub Copilot model discovery failed (${response.status})`);
+	}
+	return parseGenericModelSnapshotsFromModelsResponse(await response.json()).map((model) => ({
+		...model,
+		source: "github-copilot-account"
+	}));
+}
+
+//#endregion
+export { discoverGitHubCopilotModels };

package/dist/providers/litellm-models.js

@@ -42,4 +42,4 @@ function buildLitellmModelCapabilityOverrides(routeId = "litellm") {
 }
 
 //#endregion
-export { LITELLM_BASE_URL, LITELLM_DEFAULT_MODEL_ID, LITELLM_DEFAULT_MODEL_REF, LITELLM_MODEL_CATALOG, LITELLM_MODEL_IDS, LITELLM_MODEL_REFS, buildLitellmModelCapabilityOverrides, buildLitellmModelDefinition };
+export { LITELLM_BASE_URL, LITELLM_DEFAULT_MODEL_ID, LITELLM_MODEL_IDS, LITELLM_MODEL_REFS };

package/dist/providers/openai-codex-model-discovery.js

@@ -0,0 +1,166 @@
+import { normalizeThinkLevel } from "../shared/model-thinking.js";
+import { listProfilesForProvider } from "../agents/auth-profiles/profiles.js";
+import { resolveApiKeyForProfile } from "../agents/auth-profiles/oauth.js";
+import "../agents/auth-profiles.js";
+import { listOpenAICodexAppServerModels } from "../agents/openai-codex-app-server.js";
+
+//#region src/providers/openai-codex-model-discovery.ts
+const OPENAI_CODEX_MODELS_URL = "https://chatgpt.com/backend-api/codex/models";
+const OPENAI_CODEX_ROUTE = "openai-codex";
+const OPENAI_CODEX_CATALOG_CLIENT_VERSION = "0.144.0";
+const DISCOVERY_TIMEOUT_MS = 8e3;
+function decodeJwtPayload(token) {
+	const encoded = token.split(".")[1];
+	if (!encoded) {
+		return null;
+	}
+	try {
+		return JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+	} catch {
+		return null;
+	}
+}
+function extractChatGptAccountId(token) {
+	const payload = decodeJwtPayload(token);
+	const auth = payload?.["https://api.openai.com/auth"];
+	if (!auth || typeof auth !== "object" || Array.isArray(auth)) {
+		return null;
+	}
+	const accountId = auth.chatgpt_account_id;
+	return typeof accountId === "string" && accountId.trim() ? accountId.trim() : null;
+}
+function positiveInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+function inputModalities(value) {
+	if (!Array.isArray(value)) {
+		return ["text"];
+	}
+	const values = value.filter((entry) => entry === "text" || entry === "image");
+	return values.length > 0 ? values : ["text"];
+}
+function modelCapabilities(model) {
+	const rawLevels = Array.isArray(model.supported_reasoning_levels) ? model.supported_reasoning_levels : [];
+	const thinkingLevels = rawLevels.flatMap((entry) => {
+		if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+			return [];
+		}
+		const effort = entry.effort;
+		const normalized = typeof effort === "string" ? normalizeThinkLevel(effort) : undefined;
+		return normalized ? [normalized] : [];
+	});
+	const defaultThinkingLevel = typeof model.default_reasoning_level === "string" ? normalizeThinkLevel(model.default_reasoning_level) : undefined;
+	return {
+		tools: true,
+		json: true,
+		streaming: true,
+		...thinkingLevels.length > 0 ? { thinkingLevels } : {},
+		...defaultThinkingLevel ? { defaultThinkingLevel } : {},
+		thinkingMode: "openai-reasoning-effort",
+		reasoningBudgetSupported: thinkingLevels.length > 0
+	};
+}
+function parseModels(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return [];
+	}
+	const models = value.models;
+	if (!Array.isArray(models)) {
+		return [];
+	}
+	return models.flatMap((entry) => {
+		if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+			return [];
+		}
+		const model = entry;
+		const id = typeof model.slug === "string" ? model.slug.trim() : "";
+		if (!id || model.visibility !== "list") {
+			return [];
+		}
+		const capabilities = modelCapabilities(model);
+		return [{
+			id,
+			name: typeof model.display_name === "string" && model.display_name.trim() ? model.display_name.trim().replace(/-(Sol|Terra|Luna|Mini)$/i, " $1") : id,
+			input: inputModalities(model.input_modalities),
+			reasoning: true,
+			tools: capabilities.tools,
+			json: capabilities.json,
+			thinkingLevels: capabilities.thinkingLevels,
+			defaultThinkingLevel: capabilities.defaultThinkingLevel,
+			thinkingMode: capabilities.thinkingMode,
+			reasoningBudgetSupported: capabilities.reasoningBudgetSupported,
+			contextWindow: positiveInteger(model.context_window),
+			responsesLite: model.use_responses_lite === true,
+			source: "openai-codex-account"
+		}];
+	});
+}
+function parseAppServerModels(models) {
+	return models.map((model) => {
+		const thinkingLevels = model.supportedReasoningEfforts.flatMap((effort) => {
+			const normalized = normalizeThinkLevel(effort);
+			return normalized ? [normalized] : [];
+		});
+		const defaultThinkingLevel = normalizeThinkLevel(model.defaultReasoningEffort);
+		const responsesLite = /^gpt-5\.6-(?:sol|terra|luna)$/i.test(model.id);
+		return {
+			id: model.id,
+			name: model.displayName.replace(/-(Sol|Terra|Luna|Mini)$/i, " $1"),
+			input: model.inputModalities,
+			reasoning: thinkingLevels.length > 0,
+			tools: !responsesLite,
+			json: !responsesLite,
+			thinkingLevels,
+			...defaultThinkingLevel ? { defaultThinkingLevel } : {},
+			thinkingMode: "openai-reasoning-effort",
+			reasoningBudgetSupported: false,
+			responsesLite,
+			source: "openai-codex-app-server"
+		};
+	});
+}
+async function discoverOpenAICodexModels(params) {
+	const profileId = listProfilesForProvider(params.store, OPENAI_CODEX_ROUTE)[0];
+	if (!profileId) {
+		return [];
+	}
+	const resolved = await resolveApiKeyForProfile({
+		cfg: params.cfg,
+		store: params.store,
+		profileId,
+		agentDir: params.agentDir
+	});
+	if (!resolved?.apiKey) {
+		return [];
+	}
+	const accountId = extractChatGptAccountId(resolved.apiKey);
+	if (!accountId) {
+		throw new Error("OpenAI sign-in token does not contain a ChatGPT account ID");
+	}
+	if (!params.fetchImpl) {
+		return parseAppServerModels(await (params.listAppServerModels ?? listOpenAICodexAppServerModels)({ token: resolved.apiKey }));
+	}
+	const url = new URL(OPENAI_CODEX_MODELS_URL);
+	url.searchParams.set("client_version", OPENAI_CODEX_CATALOG_CLIENT_VERSION);
+	const response = await (params.fetchImpl ?? fetch)(url, {
+		headers: {
+			authorization: `Bearer ${resolved.apiKey}`,
+			"chatgpt-account-id": accountId,
+			originator: "fased",
+			accept: "application/json"
+		},
+		signal: AbortSignal.timeout(DISCOVERY_TIMEOUT_MS)
+	});
+	if (!response.ok) {
+		throw new Error(`OpenAI account model discovery failed (${response.status})`);
+	}
+	return parseModels(await response.json());
+}
+const testing = {
+	extractChatGptAccountId,
+	parseAppServerModels,
+	parseModels
+};
+
+//#endregion
+export { discoverOpenAICodexModels };