@fased/fased 0.1.55 → 0.1.57

package/config/capability-catalog.json

@@ -147,6 +147,18 @@
       "surface": "Services > Browser",
       "description": "Chrome, Chromium, Brave, Edge, remote CDP, or the extension relay."
     },
+    {
+      "id": "openai-runtime",
+      "label": "OpenAI Sign-In Runtime",
+      "category": "provider",
+      "delivery": "npm-addon",
+      "packageName": "@fased/openai-runtime",
+      "pluginId": "openai-runtime",
+      "restartRequired": false,
+      "docsPath": "/providers/openai",
+      "surface": "Agent > Models",
+      "description": "Official Codex app-server runtime for ChatGPT sign-in model discovery and execution."
+    },
     {
       "id": "ollama",
       "label": "Ollama",

package/dist/agents/authenticated-model-catalog.js

@@ -1,5 +1,5 @@
-import { buildCredentialScopedAllowedModelSet } from "./model-catalog-access.js";
 import { applyRuntimeProviderModelDiscovery, filterCatalogToAuthoritativeAvailability } from "../providers/runtime-model-catalog.js";
+import { buildCredentialScopedAllowedModelSet } from "./model-catalog-access.js";
 
 //#region src/agents/authenticated-model-catalog.ts
 async function resolveAuthenticatedModelCatalog(params) {
@@ -13,7 +13,8 @@ async function resolveAuthenticatedModelCatalog(params) {
 		cfg: params.cfg,
 		store: params.store,
 		routes: initialScope.usableProviders,
-		catalog: initialScope.usableCatalog
+		catalog: initialScope.usableCatalog,
+		agentDir: params.agentDir
 	}), params.store);
 	return buildCredentialScopedAllowedModelSet({
 		cfg: params.cfg,

package/dist/agents/bash-tools.exec-host-node.js

@@ -1,6 +1,6 @@
 import { logInfo } from "../logger.js";
-import { evaluateShellAllowlist } from "../infra/exec-approvals-allowlist.js";
 import { callGatewayTool } from "./tools/gateway.js";
+import { evaluateShellAllowlist } from "../infra/exec-approvals-allowlist.js";
 import { requiresExecApproval, resolveExecApprovalsFromFile } from "../infra/exec-approvals.js";
 import { detectCommandObfuscation } from "../infra/exec-obfuscation-detect.js";
 import { DEFAULT_APPROVAL_TIMEOUT_MS, createApprovalSlug, emitExecSystemEvent } from "./bash-tools.exec-runtime.js";

package/dist/agents/bash-tools.exec.js

@@ -2,8 +2,8 @@ import { parseAgentSessionKey } from "../sessions/session-key-utils.js";
 import { resolveAgentIdFromSessionKey } from "../routing/session-key.js";
 import { logInfo } from "../logger.js";
 import { getShellPathFromLoginShell, resolveShellEnvFallbackTimeoutMs } from "../infra/shell-env.js";
-import { resolveExecSafeBinRuntimePolicy } from "../infra/exec-safe-bin-runtime-policy.js";
 import { SafeOpenError, readFileWithinRoot } from "../infra/fs-safe.js";
+import { resolveExecSafeBinRuntimePolicy } from "../infra/exec-safe-bin-runtime-policy.js";
 import { maxAsk, minSecurity } from "../infra/exec-approvals.js";
 import { markBackgrounded } from "./bash-process-registry.js";
 import { applyPathPrepend, normalizePathPrepend } from "../infra/path-prepend.js";

package/dist/agents/copilot-dynamic-headers.js

@@ -0,0 +1,37 @@
+//#region src/agents/copilot-dynamic-headers.ts
+const COPILOT_EDITOR_VERSION = "vscode/1.96.2";
+const COPILOT_USER_AGENT = "GitHubCopilotChat/0.26.7";
+const COPILOT_GITHUB_API_VERSION = "2025-04-01";
+function inferCopilotInitiator(messages) {
+	const last = messages[messages.length - 1];
+	return last && last.role !== "user" ? "agent" : "user";
+}
+function hasCopilotVisionInput(messages) {
+	return messages.some((message) => {
+		if (message.role === "user" && Array.isArray(message.content)) {
+			return message.content.some((item) => item.type === "image");
+		}
+		if (message.role === "toolResult" && Array.isArray(message.content)) {
+			return message.content.some((item) => item.type === "image");
+		}
+		return false;
+	});
+}
+function buildCopilotIdeHeaders(params = {}) {
+	return {
+		"Editor-Version": COPILOT_EDITOR_VERSION,
+		"User-Agent": COPILOT_USER_AGENT,
+		...params.includeApiVersion ? { "X-Github-Api-Version": COPILOT_GITHUB_API_VERSION } : {}
+	};
+}
+function buildCopilotDynamicHeaders(params) {
+	return {
+		...buildCopilotIdeHeaders(),
+		"X-Initiator": inferCopilotInitiator(params.messages),
+		"Openai-Intent": "conversation-edits",
+		...params.hasImages ? { "Copilot-Vision-Request": "true" } : {}
+	};
+}
+
+//#endregion
+export { buildCopilotIdeHeaders };

package/dist/agents/current-model-catalog.js

@@ -153,7 +153,8 @@ const OPENAI_CODEX_MODELS = [
 		input: ["text", "image"],
 		contextWindow: 105e4,
 		maxTokens: 128e3,
-		api: "openai-codex-responses"
+		api: "openai-codex-responses",
+		compat: { responsesLite: true }
 	}),
 	model({
 		id: "gpt-5.6-terra",
@@ -162,7 +163,8 @@ const OPENAI_CODEX_MODELS = [
 		input: ["text", "image"],
 		contextWindow: 105e4,
 		maxTokens: 128e3,
-		api: "openai-codex-responses"
+		api: "openai-codex-responses",
+		compat: { responsesLite: true }
 	}),
 	model({
 		id: "gpt-5.6-luna",
@@ -171,7 +173,8 @@ const OPENAI_CODEX_MODELS = [
 		input: ["text", "image"],
 		contextWindow: 105e4,
 		maxTokens: 128e3,
-		api: "openai-codex-responses"
+		api: "openai-codex-responses",
+		compat: { responsesLite: true }
 	}),
 	model({
 		id: "gpt-5.5",

package/dist/agents/model-catalog-snapshot.js

@@ -0,0 +1,124 @@
+import { resolveAgentModelFallbackValues } from "../config/model-input.js";
+import { resolveAgentEffectiveModelPrimary, resolveAgentModelFallbacksOverride } from "./agent-scope.js";
+import { deriveModelMetadata } from "./model-metadata.js";
+import { resolveAuthenticatedModelCatalog } from "./authenticated-model-catalog.js";
+import { resolveTaskModelRole } from "../cron/task-model-roles.js";
+
+//#region src/agents/model-catalog-snapshot.ts
+const TASK_ROLES = [
+	"cheapCheck",
+	"strong",
+	"escalation",
+	"coding",
+	"summarizer"
+];
+function normalizeRef(value) {
+	const trimmed = value?.trim();
+	return trimmed || undefined;
+}
+function collectAssignments(params) {
+	const assignments = [];
+	const add = (role, ref) => {
+		const normalized = normalizeRef(ref);
+		if (normalized && !assignments.some((entry) => entry.role === role && entry.ref === normalized)) {
+			assignments.push({
+				role,
+				ref: normalized
+			});
+		}
+	};
+	add("primary", resolveAgentEffectiveModelPrimary(params.cfg, params.agentId));
+	const fallbacks = resolveAgentModelFallbacksOverride(params.cfg, params.agentId) ?? resolveAgentModelFallbackValues(params.cfg.agents?.defaults?.model);
+	for (const fallback of fallbacks) {
+		add("fallback", fallback);
+	}
+	for (const role of TASK_ROLES) {
+		add(role, resolveTaskModelRole({
+			cfg: params.cfg,
+			agentId: params.agentId,
+			role
+		})?.model);
+	}
+	return assignments;
+}
+function modelRef(model) {
+	return `${model.provider}/${model.id}`;
+}
+function buildProviderSummaries(models) {
+	const summaries = new Map();
+	for (const model of models) {
+		const providerId = model.metadata.publicProviderId;
+		const existing = summaries.get(providerId) ?? {
+			id: providerId,
+			label: model.metadata.publicProviderLabel,
+			routes: [],
+			credentialRoutes: [],
+			available: 0,
+			recommended: 0,
+			assigned: 0
+		};
+		if (!existing.routes.includes(model.provider)) {
+			existing.routes.push(model.provider);
+		}
+		for (const route of model.metadata.credentialRoutes) {
+			if (!existing.credentialRoutes.some((entry) => entry.id === route.id)) {
+				existing.credentialRoutes.push(route);
+			}
+		}
+		existing.available += 1;
+		existing.recommended += model.recommended ? 1 : 0;
+		existing.assigned += model.assignedRoles.length > 0 ? 1 : 0;
+		summaries.set(providerId, existing);
+	}
+	return [...summaries.values()].map((summary) => ({
+		...summary,
+		routes: summary.routes.toSorted(),
+		credentialRoutes: summary.credentialRoutes.toSorted((left, right) => left.label.localeCompare(right.label))
+	})).toSorted((left, right) => left.label.localeCompare(right.label));
+}
+async function resolveCanonicalModelCatalogSnapshot(params) {
+	const authenticated = await resolveAuthenticatedModelCatalog({
+		cfg: params.cfg,
+		store: params.store,
+		catalog: params.catalog,
+		defaultProvider: params.defaultProvider,
+		agentDir: params.agentDir
+	});
+	const configuredAssignments = collectAssignments({
+		cfg: params.cfg,
+		agentId: params.agentId
+	});
+	const assignmentsByRef = new Map();
+	for (const assignment of configuredAssignments) {
+		assignmentsByRef.set(assignment.ref, [...assignmentsByRef.get(assignment.ref) ?? [], assignment.role]);
+	}
+	const availableRefs = new Set(authenticated.usableCatalog.map(modelRef));
+	const runnableRefs = new Set(authenticated.allowedCatalog.map(modelRef));
+	const models = authenticated.usableCatalog.map((model) => {
+		const metadata = model.metadata ?? deriveModelMetadata({
+			model,
+			cfg: params.cfg
+		});
+		return {
+			...model,
+			metadata,
+			available: true,
+			runnable: runnableRefs.size === 0 || runnableRefs.has(modelRef(model)),
+			recommended: metadata.recommended === true,
+			assignedRoles: assignmentsByRef.get(modelRef(model)) ?? []
+		};
+	}).toSorted((left, right) => left.metadata.publicProviderLabel.localeCompare(right.metadata.publicProviderLabel) || Number(right.recommended) - Number(left.recommended) || (left.metadata.recommendationRank ?? Number.MAX_SAFE_INTEGER) - (right.metadata.recommendationRank ?? Number.MAX_SAFE_INTEGER) || left.name.localeCompare(right.name));
+	return {
+		generatedAt: new Date().toISOString(),
+		agentId: params.agentId,
+		models,
+		providers: buildProviderSummaries(models),
+		assignments: configuredAssignments.map((assignment) => ({
+			...assignment,
+			available: availableRefs.has(assignment.ref)
+		}))
+	};
+}
+
+//#endregion
+export { resolveCanonicalModelCatalogSnapshot };

package/dist/agents/model-catalog-source.js

@@ -1,4 +1,4 @@
-import { isOpenAISignInCatalogModel, isStandardProviderCatalogEntry, listProviderBrandManifests } from "../providers/registry.js";
+import { isOpenAISignInRuntimeModelSupported, isStandardProviderCatalogEntry, listProviderBrandManifests } from "../providers/registry.js";
 import { MODEL_APIS } from "../config/types.models.js";
 import { buildModelCatalogMergeKey, mergeModelCatalogRowsByAuthority, normalizeModelCatalogModelId, normalizeModelCatalogProviderId, normalizeProviderCatalogRows } from "./model-catalog-normalized.js";
 import { CURRENT_MODEL_PROVIDER_CATALOG, listCurrentModelCatalogRows } from "./current-model-catalog.js";
@@ -28,7 +28,7 @@ function isSupportedRuntimeCatalogModel(provider, id) {
 	if (provider !== "openai-codex") {
 		return true;
 	}
-	return isOpenAISignInCatalogModel(id);
+	return isOpenAISignInRuntimeModelSupported(id);
 }
 function configuredProviderCatalogRows(cfg) {
 	return Object.entries(cfg.models?.providers ?? {}).flatMap(([provider, providerConfig]) => normalizeProviderCatalogRows({

package/dist/agents/model-catalog.js

@@ -4,8 +4,8 @@ import { loadConfig } from "../config/io.js";
 import "../config/config.js";
 import { normalizeModelCatalogProviderId } from "./model-catalog-normalized.js";
 import { ensureFasedAgentModelsJson } from "./models-config.js";
-import { augmentModelCatalogWithProviderPlugins } from "../plugins/provider-runtime.runtime.js";
 import { deriveModelMetadata } from "./model-metadata.js";
+import { augmentModelCatalogWithProviderPlugins } from "../plugins/provider-runtime.runtime.js";
 import { buildFasedModelCatalogEntries } from "./model-catalog-source.js";
 import { __setProviderExtensionCatalogEntriesForTest, loadProviderExtensionCatalogIndex } from "./provider-extension-catalog-index.js";
 

package/dist/agents/model-metadata.js

@@ -73,6 +73,12 @@ function deriveModelMetadata(params) {
 	const provider = params.model.provider.trim();
 	const modelId = params.model.id.trim();
 	const providerConfig = params.providerConfig ?? resolveProviderConfig(params.cfg, provider);
+	const providerManifest = getProviderBrandManifestForRoute(provider);
+	const credentialMethod = providerManifest?.methods.find((entry) => [
+		entry.route,
+		entry.statusRoute,
+		entry.configProviderId
+	].map((value) => value?.trim().toLowerCase()).includes(provider.toLowerCase()));
 	const baseUrl = params.model.baseUrl ?? providerConfig?.baseUrl ?? "";
 	const api = params.model.api ?? providerConfig?.api;
 	const refreshed = lookupRefreshedModelCapability(provider, modelId);
@@ -103,8 +109,24 @@ function deriveModelMetadata(params) {
 	addFeature(features, "video", capabilities?.video === true);
 	addFeature(features, "speech", capabilities?.speech === true);
 	const privateNetwork = baseUrl ? isPrivateNetworkBaseUrl(baseUrl) : false;
+	const authMode = resolveAuthMode({
+		provider,
+		providerConfig
+	});
+	const credentialRoutes = params.credentialRoutes?.length ? params.credentialRoutes : [{
+		id: credentialMethod?.id ?? provider,
+		label: credentialMethod?.label ?? providerManifest?.label ?? provider,
+		authMode
+	}];
+	const credentialRoute = credentialRoutes[0];
+	const configuredCost = providerConfig?.models?.find((entry) => entry.id.trim().toLowerCase() === modelId.toLowerCase())?.cost;
+	const cost = params.model.cost ?? configuredCost;
+	const recommendationRank = providerModelRecommendationRank(provider, modelId);
 	return {
+		ref: `${provider}/${modelId}`,
 		provider,
+		publicProviderId: providerManifest?.id ?? provider,
+		publicProviderLabel: providerManifest?.label ?? provider,
 		model: modelId,
 		label: params.model.name?.trim() || modelId,
 		contextWindow: typeof refreshed?.contextWindow === "number" && refreshed.contextWindow > 0 ? refreshed.contextWindow : typeof params.model.contextWindow === "number" && params.model.contextWindow > 0 ? params.model.contextWindow : undefined,
@@ -124,14 +146,20 @@ function deriveModelMetadata(params) {
 		retrievedAt: refreshed?.refreshedAt ?? CURATED_CATALOG_REVIEWED_AT,
 		availabilitySource: availabilitySourceForCatalogSource(params.model.catalogSource),
 		authRoute: provider,
-		authMode: resolveAuthMode({
-			provider,
-			providerConfig
-		}),
+		authMode: credentialRoute.authMode,
+		credentialRoute,
+		credentialRoutes,
+		...cost ? { price: {
+			input: cost.input,
+			output: cost.output,
+			cacheRead: cost.cacheRead,
+			cacheWrite: cost.cacheWrite,
+			unit: "usd-per-million-tokens"
+		} } : {},
 		privateNetwork,
 		privateNetworkAllowed: privateNetwork ? providerConfig?.request?.allowPrivateNetwork === true : false,
-		...params.recommended ? { recommended: true } : {},
-		...providerModelRecommendationRank(provider, modelId) ? { recommendationRank: providerModelRecommendationRank(provider, modelId) } : {},
+		...params.recommended || recommendationRank !== undefined ? { recommended: true } : {},
+		...recommendationRank !== undefined ? { recommendationRank } : {},
 		...params.default ? { default: true } : {}
 	};
 }