minecodex 0.1.20 → 0.2.2

package/packages/runtime-host/src/feature-registry.mjs

@@ -11,9 +11,11 @@ const HOST_ACTIONS = new Set([
   "open-detail-tab",
   "open-editor-modal",
   "resolve-file-paths",
+  "import-generated-image",
 ]);
 
 const PAGE_SCRIPT_ENTRY_KINDS = new Set(["page-script"]);
+const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "[::1]"]);
 
 export const FEATURE_PROTOCOL_VERSION = 1;
 export const FEATURE_HEALTH_TIMEOUT_MS = 750;
@@ -30,6 +32,37 @@ function normalizeUrl(value, field) {
   return url.href;
 }
 
+function normalizeRuntimeUrls(manifest, env) {
+  let surfaceUrl = manifest.surfaceUrl ? normalizeUrl(manifest.surfaceUrl, "surfaceUrl") : null;
+  let healthUrl = manifest.healthUrl || surfaceUrl
+    ? normalizeUrl(manifest.healthUrl ?? surfaceUrl, "healthUrl")
+    : null;
+  const portEnvironment = manifest.runtimePortEnvironment;
+  if (!portEnvironment) return { surfaceUrl, healthUrl };
+  if (!/^[A-Z][A-Z0-9_]*$/.test(portEnvironment)) {
+    throw new Error("runtimePortEnvironment must be an environment variable name");
+  }
+  if (!surfaceUrl || !healthUrl) {
+    throw new Error("runtimePortEnvironment requires surfaceUrl and healthUrl");
+  }
+  const urls = [new URL(surfaceUrl), new URL(healthUrl)];
+  if (urls.some((url) => url.protocol !== "http:" || !LOOPBACK_HOSTS.has(url.hostname))) {
+    throw new Error("runtimePortEnvironment may only override loopback http URLs");
+  }
+  if (urls[0].origin !== urls[1].origin) {
+    throw new Error("runtimePortEnvironment requires surfaceUrl and healthUrl to share an origin");
+  }
+  const configuredPort = env?.[portEnvironment];
+  if (configuredPort === undefined || configuredPort === "") return { surfaceUrl, healthUrl };
+  const port = Number(configuredPort);
+  if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+    throw new Error(`${portEnvironment} must be an integer from 1 to 65535`);
+  }
+  for (const url of urls) url.port = String(port);
+  [surfaceUrl, healthUrl] = urls.map((url) => url.href);
+  return { surfaceUrl, healthUrl };
+}
+
 function normalizeLocaleKey(value) {
   const key = String(value).trim();
   if (key.toLowerCase().startsWith("zh")) return "zh-CN";
@@ -85,6 +118,18 @@ async function normalizeModelSelector(modelSelector, projectDir) {
     throw new Error("modelSelector.favoriteStorageKey is required");
   }
 
+  const reasoningEffortOverrides = {};
+  for (const [identity, efforts] of Object.entries(modelSelector.reasoningEffortOverrides ?? {})) {
+    const exactIdentity = String(identity).trim().toLowerCase();
+    const allowedEfforts = Array.isArray(efforts)
+      ? efforts.map((effort) => String(effort).trim().toLowerCase()).filter(Boolean)
+      : [];
+    if (!exactIdentity || !allowedEfforts.length || new Set(allowedEfforts).size !== allowedEfforts.length) {
+      throw new Error("modelSelector.reasoningEffortOverrides must map exact identities to unique efforts");
+    }
+    reasoningEffortOverrides[exactIdentity] = allowedEfforts;
+  }
+
   const providerAliases = {};
   for (const [provider, label] of Object.entries(modelSelector.providerAliases ?? {})) {
     if (!String(provider).trim() || !String(label).trim()) {
@@ -118,6 +163,7 @@ async function normalizeModelSelector(modelSelector, projectDir) {
   return {
     maxVisibleItems,
     favoriteStorageKey,
+    reasoningEffortOverrides,
     providerAliases,
     strings,
     icons: {
@@ -146,7 +192,7 @@ async function normalizePageScript(manifest, projectDir) {
   return { resource, source };
 }
 
-async function normalizeFeature(manifest, projectDir) {
+async function normalizeFeature(manifest, projectDir, env) {
   if (manifest.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
   if (!manifest.id || !manifest.label) {
     throw new Error("id and label are required");
@@ -194,7 +240,11 @@ async function normalizeFeature(manifest, projectDir) {
     throw new Error("hostActions contains an unsupported action");
   }
 
-  const surfaceUrl = manifest.surfaceUrl ? normalizeUrl(manifest.surfaceUrl, "surfaceUrl") : null;
+  const pageScript = manifest.pageScript
+    ? await normalizePageScript({ ...manifest, entry: { ...(manifest.entry ?? {}), script: manifest.pageScript.resource } }, projectDir)
+    : null;
+
+  const { surfaceUrl, healthUrl } = normalizeRuntimeUrls(manifest, env);
   const entryLabel = normalizeLocalizedText(manifest.entry?.ariaLabel ?? manifest.label, "entry.ariaLabel");
   const summaryLabel = manifest.pinnedSummary
     ? normalizeLocalizedText(manifest.pinnedSummary.label ?? manifest.label, "pinnedSummary.label")
@@ -218,9 +268,7 @@ async function normalizeFeature(manifest, projectDir) {
     label: label.value,
     labels: label.locales,
     surfaceUrl,
-    healthUrl: manifest.healthUrl || surfaceUrl
-      ? normalizeUrl(manifest.healthUrl ?? surfaceUrl, "healthUrl")
-      : null,
+    healthUrl,
     icon: await normalizeIcon(manifest.icon, projectDir),
     entry: {
       kind: entryKind,
@@ -242,9 +290,7 @@ async function normalizeFeature(manifest, projectDir) {
     modelSelector: isModelSelector
       ? await normalizeModelSelector(manifest.modelSelector, projectDir)
       : null,
-    pageScript: isPageScript
-      ? await normalizePageScript(manifest, projectDir)
-      : null,
+    pageScript: isPageScript ? await normalizePageScript(manifest, projectDir) : pageScript,
     placement: {
       after: manifest.placement?.after ?? "sites",
       order: Number(manifest.placement?.order ?? 100),
@@ -254,7 +300,7 @@ async function normalizeFeature(manifest, projectDir) {
   };
 }
 
-export async function discoverFeatures(featuresRoot) {
+export async function discoverFeatures(featuresRoot, { env = process.env } = {}) {
   const entries = await readdir(featuresRoot, { withFileTypes: true });
   const features = [];
 
@@ -270,7 +316,7 @@ export async function discoverFeatures(featuresRoot) {
     }
     try {
       const manifest = JSON.parse(source);
-      features.push(await normalizeFeature(manifest, projectDir));
+      features.push(await normalizeFeature(manifest, projectDir, env));
     } catch (error) {
       throw new Error(`Invalid ${entry.name}/${MANIFEST_NAME}: ${error.message}`);
     }

package/packages/runtime-host/src/main.mjs

@@ -11,6 +11,7 @@ import {
   selectEnabledFeatures,
   startFeatureProcesses,
 } from "./feature-registry.mjs";
+import { applyVisibleReasoningLevels, loadModelCapabilities } from "./model-capabilities.mjs";
 
 const runtimeRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 const featuresRoot = process.env.CODEX_FEATURES_ROOT ?? path.dirname(runtimeRoot);
@@ -22,8 +23,17 @@ const discoveredFeatures = await discoverFeatures(featuresRoot);
 if (!discoveredFeatures.length) throw new Error(`No codex-feature.json files found under ${featuresRoot}`);
 const features = selectEnabledFeatures(discoveredFeatures, process.env.MINECODEX_ENABLED_FEATURES);
 const modelCatalog = await loadConfiguredModelCatalog();
+const modelCapabilities = await loadModelCapabilities();
 for (const feature of features) {
-  if (feature.modelSelector) feature.modelSelector.models = modelCatalog;
+  if (feature.modelSelector) {
+    feature.modelSelector.models = modelCatalog.map((model) => (
+      applyVisibleReasoningLevels(
+        model,
+        modelCapabilities.get(String(model.slug ?? "").toLowerCase()),
+        model.supportedReasoningLevels,
+      )
+    ));
+  }
 }
 
 let readyWritePromise = Promise.resolve();

package/packages/runtime-host/src/model-capabilities.mjs

@@ -0,0 +1,86 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const CODEX_REASONING_ORDER = ["low", "medium", "high", "xhigh", "max", "ultra"];
+
+function uniqueLevels(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+
+function normalizedEfforts(entry) {
+  if (!Array.isArray(entry)) return null;
+  const levels = entry.map(String).filter((value) => (
+    CODEX_REASONING_ORDER.includes(value) || value === "none" || value === "minimal"
+  ));
+  return levels.length ? uniqueLevels(levels) : null;
+}
+
+export function resolveModelRecord(records, modelId) {
+  if (!records || typeof records !== "object") return undefined;
+  if (Object.prototype.hasOwnProperty.call(records, modelId)) return records[modelId];
+  const folded = modelId.toLowerCase();
+  for (const [key, value] of Object.entries(records)) {
+    if (key.toLowerCase() === folded) return value;
+  }
+  return undefined;
+}
+
+export function mergeCapability(providerConfig, modelId) {
+  if (!providerConfig) return null;
+  const configuredEfforts = normalizedEfforts(
+    resolveModelRecord(providerConfig.modelReasoningEfforts, modelId),
+  );
+  if (configuredEfforts) {
+    return {
+      source: "opencodex",
+      kind: "effort",
+      levels: uniqueLevels(configuredEfforts),
+      map: resolveModelRecord(providerConfig.modelReasoningEffortMap, modelId) ?? null,
+      rawEfforts: configuredEfforts,
+    };
+  }
+  if (Array.isArray(providerConfig.noReasoningModels) && providerConfig.noReasoningModels.includes(modelId)) {
+    return { source: "opencodex", kind: "no-effort", levels: null, map: null, rawEfforts: [] };
+  }
+  return null;
+}
+
+export async function loadModelCapabilities({
+  opencodexConfigPath = process.env.OPENCODEX_CONFIG_PATH ?? path.join(os.homedir(), ".opencodex", "config.json"),
+  read = readFile,
+} = {}) {
+  const configPayload = await read(opencodexConfigPath, "utf8").then((value) => JSON.parse(value)).catch(() => null);
+  const providers = configPayload?.providers ?? {};
+  const result = new Map();
+  for (const [providerId, providerConfig] of Object.entries(providers)) {
+    const modelIds = new Set([
+      ...Object.keys(providerConfig?.modelReasoningEfforts ?? {}),
+      ...Object.keys(providerConfig?.modelReasoningEffortMap ?? {}),
+      ...Object.keys(providerConfig?.thinkingToggleModels ?? {}),
+      ...Object.keys(providerConfig?.thinkingBudgetModels ?? {}),
+      ...(Array.isArray(providerConfig?.noReasoningModels) ? providerConfig.noReasoningModels : []),
+    ]);
+    for (const modelId of modelIds) {
+      const capability = mergeCapability(providerConfig, modelId);
+      if (capability) result.set(`${providerId}/${modelId}`.toLowerCase(), capability);
+    }
+  }
+  return result;
+}
+
+export function applyVisibleReasoningLevels(catalogModel, capability, fallbackLevels) {
+  if (!catalogModel) return catalogModel;
+  const rawLevels = Array.isArray(fallbackLevels) ? fallbackLevels : (catalogModel.supportedReasoningLevels ?? []);
+  if (!Array.isArray(rawLevels)) return catalogModel;
+  if (capability && Array.isArray(capability.levels)) {
+    const allowed = new Set(capability.levels);
+    const visible = rawLevels.filter((level) => {
+      const effort = String(level?.effort ?? level ?? "").toLowerCase();
+      return allowed.has(effort);
+    });
+    return { ...catalogModel, supportedReasoningLevels: visible, modelSelectorCapability: capability };
+  }
+  return { ...catalogModel, modelSelectorCapability: capability ?? null };
+}