@pixelbyte-software/pixcode 1.40.6 → 1.40.9

package/server/modules/orchestration/workflows/workflow-runner.ts

@@ -13,6 +13,19 @@ import {
   workspaceTargetMetadata,
 } from '@/modules/orchestration/workflows/workspace-target.js';
 import { workflowStore } from '@/modules/orchestration/workflows/workflow-store.js';
+// @ts-ignore — plain-JS service
+import { getProviderModels } from '@/services/provider-models.js';
+// @ts-ignore — plain-JS service
+import { notifyRunFailed, notifyRunStopped } from '@/services/notification-orchestrator.js';
+
+import {
+  CLAUDE_MODELS,
+  CODEX_MODELS,
+  CURSOR_MODELS,
+  GEMINI_MODELS,
+  OPENCODE_MODELS,
+  QWEN_MODELS,
+} from '../../../../shared/modelConstants.js';
 
 const TERMINAL = new Set(['completed', 'failed', 'canceled']);
 const SKIPPED = 'skipped';
@@ -106,6 +119,51 @@ type AgentAssignment = {
 
 type KnownAgentRole = typeof KNOWN_AGENT_ROLES[number];
 type AgentRole = string;
+type ProviderId = 'claude' | 'cursor' | 'codex' | 'gemini' | 'qwen' | 'opencode';
+type ProviderModel = {
+  value: string;
+  label?: string;
+  source?: 'static' | 'api';
+  free?: boolean;
+};
+type RunStoppedNotifier = (payload: {
+  userId: string | number;
+  provider: string;
+  sessionId?: string | null;
+  stopReason?: string;
+  sessionName?: string | null;
+}) => void;
+type RunFailedNotifier = (payload: {
+  userId: string | number;
+  provider: string;
+  sessionId?: string | null;
+  error: unknown;
+  sessionName?: string | null;
+}) => void;
+
+const sendRunStoppedNotification = notifyRunStopped as RunStoppedNotifier;
+const sendRunFailedNotification = notifyRunFailed as RunFailedNotifier;
+
+const adapterProviderMap: Record<string, ProviderId | undefined> = {
+  'claude-code': 'claude',
+  cursor: 'cursor',
+  codex: 'codex',
+  gemini: 'gemini',
+  qwen: 'qwen',
+  opencode: 'opencode',
+};
+
+const modelCatalogsByProvider: Record<ProviderId, {
+  staticList: ProviderModel[];
+  defaultModel?: string;
+}> = {
+  claude: { staticList: CLAUDE_MODELS.OPTIONS, defaultModel: CLAUDE_MODELS.DEFAULT },
+  cursor: { staticList: CURSOR_MODELS.OPTIONS, defaultModel: CURSOR_MODELS.DEFAULT },
+  codex: { staticList: CODEX_MODELS.OPTIONS, defaultModel: CODEX_MODELS.DEFAULT },
+  gemini: { staticList: GEMINI_MODELS.OPTIONS, defaultModel: GEMINI_MODELS.DEFAULT },
+  qwen: { staticList: QWEN_MODELS.OPTIONS, defaultModel: QWEN_MODELS.DEFAULT },
+  opencode: { staticList: OPENCODE_MODELS.OPTIONS, defaultModel: OPENCODE_MODELS.DEFAULT },
+};
 
 function readAgentRole(value: unknown): AgentRole | undefined {
   return typeof value === 'string' && value.trim() && value.trim() !== 'auto'
@@ -129,10 +187,94 @@ function readString(value: unknown): string | undefined {
   return typeof value === 'string' && value.trim() ? value : undefined;
 }
 
+function readNotificationUserId(metadata?: Record<string, unknown>): string | number | null {
+  const value = metadata?.userId;
+  return typeof value === 'string' || typeof value === 'number' ? value : null;
+}
+
+function workflowNotificationTitle(run: WorkflowRun): string {
+  return readString(run.metadata?.workflowName) ?? run.workflowId;
+}
+
+function notifyWorkflowRunFinished(run: WorkflowRun): void {
+  const userId = readNotificationUserId(run.metadata);
+  if (!userId) return;
+
+  if (run.status === 'completed') {
+    sendRunStoppedNotification({
+      userId,
+      provider: 'system',
+      sessionId: run.id,
+      sessionName: workflowNotificationTitle(run),
+      stopReason: 'Orchestration completed',
+    });
+    return;
+  }
+
+  if (run.status === 'canceled') {
+    sendRunStoppedNotification({
+      userId,
+      provider: 'system',
+      sessionId: run.id,
+      sessionName: workflowNotificationTitle(run),
+      stopReason: 'Orchestration canceled',
+    });
+    return;
+  }
+
+  if (run.status === 'failed') {
+    sendRunFailedNotification({
+      userId,
+      provider: 'system',
+      sessionId: run.id,
+      sessionName: workflowNotificationTitle(run),
+      error: readString(run.metadata?.error) ?? 'Orchestration failed',
+    });
+  }
+}
+
 function readBoolean(value: unknown): boolean | undefined {
   return typeof value === 'boolean' ? value : undefined;
 }
 
+function modelValueSet(models: ProviderModel[]): Set<string> {
+  return new Set(models.map((model) => model.value).filter(Boolean));
+}
+
+function preferredFallbackModel(models: ProviderModel[], defaultModel?: string): string | undefined {
+  const values = modelValueSet(models);
+  if (defaultModel && values.has(defaultModel)) return defaultModel;
+  return models.find((model) => model.source === 'api' && model.free)?.value
+    ?? models.find((model) => model.source === 'api')?.value
+    ?? models.find((model) => model.free)?.value
+    ?? models[0]?.value
+    ?? defaultModel;
+}
+
+async function resolveWorkflowModel(adapterId: string, requestedModel?: string): Promise<string | undefined> {
+  const provider = adapterProviderMap[adapterId];
+  if (!provider) return requestedModel;
+
+  const catalog = modelCatalogsByProvider[provider];
+  if (!requestedModel) return catalog.defaultModel;
+
+  try {
+    const result = await getProviderModels(provider, {
+      staticList: catalog.staticList,
+    });
+    const models = Array.isArray(result?.models) ? result.models as ProviderModel[] : [];
+    if (modelValueSet(models).has(requestedModel)) {
+      return requestedModel;
+    }
+    return preferredFallbackModel(models, catalog.defaultModel) ?? requestedModel;
+  } catch {
+    const staticValues = modelValueSet(catalog.staticList);
+    return staticValues.has(requestedModel)
+      ? requestedModel
+      : preferredFallbackModel(catalog.staticList, catalog.defaultModel) ?? requestedModel;
+  }
+}
+
 function readIsolation(value: unknown): 'host' | 'worktree' | 'docker' | undefined {
   return value === 'host' || value === 'worktree' || value === 'docker' ? value : undefined;
 }
@@ -1372,6 +1514,7 @@ class WorkflowRunner {
     } finally {
       run.finishedAt = run.finishedAt ?? Date.now();
       workflowStore.setRun(run);
+      notifyWorkflowRunFinished(run);
       this.cancelingRuns.delete(run.id);
     }
   }
@@ -1408,15 +1551,42 @@ class WorkflowRunner {
 
     const inputContext = node.inputs.map((input) => outputs.get(input)).filter(Boolean).join('\n\n');
     const workspaceTarget = resolveWorkflowWorkspace(run.metadata);
-    const prompt = [workspaceContextPrompt(workspaceTarget), run.input, inputContext, node.prompt]
-      .filter(Boolean)
-      .join('\n\n');
+    const prompt = [
+      'Original user request (primary task; answer this directly even if the workspace is empty):',
+      run.input?.trim() || '(No original user request was provided.)',
+      inputContext
+        ? `Upstream workflow context from prior agents:\n${inputContext}`
+        : '',
+      `Current workflow step instructions:\n${node.prompt}`,
+      workspaceContextPrompt(workspaceTarget),
+    ].filter(Boolean).join('\n\n');
     const settings = getMetadataRecord(run.metadata, 'settings');
     const projectPath = workspaceTarget.projectPath;
     const isolation = readIsolation(settings.isolation) ?? node.isolation ?? 'host';
     const keepAfterCompletion = readBoolean(settings.keepWorkspace) ?? true;
     const baseRef = readString(settings.baseRef) ?? 'HEAD';
     const effectivePermissionMode = resolveNodePermissionMode(node, workspaceTarget);
+    const effectiveModel = await resolveWorkflowModel(node.adapterId, node.model);
+    if (effectiveModel !== node.model) {
+      nodeRun.model = effectiveModel;
+      const modelFallbackEvents = Array.isArray(run.metadata?.modelFallbackEvents)
+        ? run.metadata.modelFallbackEvents
+        : [];
+      run.metadata = {
+        ...run.metadata,
+        modelFallbackEvents: [
+          ...modelFallbackEvents,
+          {
+            nodeId: node.id,
+            adapterId: node.adapterId,
+            requestedModel: node.model,
+            effectiveModel,
+            changedAt: Date.now(),
+          },
+        ],
+      };
+      workflowStore.setRun(run);
+    }
     let body: { id?: string; error?: { message?: string } };
     try {
       const submit = await fetch(`${localA2ABaseUrl()}/tasks`, {
@@ -1436,7 +1606,7 @@ class WorkflowRunner {
             agentInstanceId: node.agentInstanceId,
             agentLabel: node.agentLabel,
             assignment: node.assignment,
-            model: node.model,
+            model: effectiveModel,
             permissionMode: effectivePermissionMode,
             toolsSettings: node.toolsSettings,
             projectPath,

package/server/modules/orchestration/workflows/workflow.routes.ts

@@ -39,6 +39,11 @@ function readMetadata(body: unknown): Record<string, unknown> | undefined {
   return metadata && typeof metadata === 'object' ? metadata as Record<string, unknown> : undefined;
 }
 
+function readRequestUserId(req: express.Request): string | number | null {
+  const user = (req as express.Request & { user?: { id?: string | number; userId?: string | number } }).user;
+  return user?.id ?? user?.userId ?? null;
+}
+
 function sendRunSnapshot(res: express.Response, runId: string): boolean {
   const run = workflowStore.getRun(runId);
   if (!run) {
@@ -179,7 +184,11 @@ export function createWorkflowRouter(): Router {
       const run = workflowRunner.start(
         workflow,
         typeof req.body?.input === 'string' ? req.body.input : '',
-        readMetadata(req.body),
+        {
+          ...readMetadata(req.body),
+          userId: readRequestUserId(req),
+          workflowName: workflow.name,
+        },
       );
       res.status(202).json(run);
     } catch (error) {

package/server/services/live-view.js

@@ -208,6 +208,155 @@ function buildManagedPackageCommand(command, runtimeStatus) {
   };
 }
 
+function packageBinCandidates(binName) {
+  return process.platform === 'win32'
+    ? [binName, `${binName}.cmd`, `${binName}.ps1`, `${binName}.exe`]
+    : [binName];
+}
+
+function expectedPackageBin(command) {
+  if (command.framework === 'Vite' || command.id === 'npm-dev-vite') return 'vite';
+  if (command.framework === 'Next.js' || command.id === 'npm-dev-next') return 'next';
+  if (command.framework === 'Nuxt' || command.id === 'npm-dev-nuxt') return 'nuxt';
+  if (command.framework === 'Astro' || command.id === 'npm-dev-astro') return 'astro';
+  return null;
+}
+
+async function packageDependenciesReady(projectPath, command) {
+  if (!command?.scriptName && !command?.packageManager) return true;
+  if (!(await dirExists(path.join(projectPath, 'node_modules')))) return false;
+
+  const binName = expectedPackageBin(command);
+  if (!binName) return true;
+
+  const binDir = path.join(projectPath, 'node_modules', '.bin');
+  for (const candidate of packageBinCandidates(binName)) {
+    if (await fileExists(path.join(binDir, candidate))) return true;
+  }
+  return false;
+}
+
+function packageInstallInvocation(command) {
+  if (!command || command.packageManager !== 'npm') return null;
+  const installArgs = ['install', '--no-audit', '--no-fund', '--include=dev'];
+
+  if (
+    command.managedRuntime?.id === 'npm'
+    && command.args?.[0]
+    && String(command.args[0]).endsWith('npm-cli.js')
+  ) {
+    return {
+      command: command.command,
+      args: [command.args[0], ...installArgs],
+      displayCommand: 'npm install --no-audit --no-fund --include=dev',
+    };
+  }
+
+  if (command.command === 'npm' || path.basename(command.command || '').startsWith('npm')) {
+    return {
+      command: command.command,
+      args: installArgs,
+      displayCommand: 'npm install --no-audit --no-fund --include=dev',
+    };
+  }
+
+  return null;
+}
+
+function runPrepProcess(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      shell: shouldUseShell({ command }),
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+    const timeoutMs = Number.parseInt(process.env.PIXCODE_LIVE_VIEW_INSTALL_TIMEOUT_MS || '', 10) || 300000;
+    const finish = (callback, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      callback(value);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+        // Process may already be gone.
+      }
+      finish(reject, new Error(`Dependency install timed out after ${Math.round(timeoutMs / 1000)}s.`));
+    }, timeoutMs);
+
+    child.stdout.on('data', (chunk) => {
+      chunk.toString().split(/\r?\n/).forEach((line) => options.onLog?.(line));
+    });
+    child.stderr.on('data', (chunk) => {
+      chunk.toString().split(/\r?\n/).forEach((line) => options.onLog?.(line));
+    });
+    child.on('error', (error) => finish(reject, error));
+    child.on('exit', (code, signal) => {
+      if (code === 0) {
+        finish(resolve);
+        return;
+      }
+      finish(reject, new Error(`Dependency install exited with ${signal || `code ${code}`}.`));
+    });
+  });
+}
+
+export async function preparePackageDependencies(projectPath, command, env = process.env, onLog = () => {}) {
+  if (!command || command.packageManager !== 'npm') return false;
+  if (await packageDependenciesReady(projectPath, command)) return false;
+
+  const install = packageInstallInvocation(command);
+  if (!install) return false;
+
+  onLog(`Installing project dependencies: ${install.displayCommand}`);
+  await runPrepProcess(install.command, install.args, {
+    cwd: projectPath,
+    env: {
+      ...env,
+      NODE_ENV: 'development',
+      NPM_CONFIG_PRODUCTION: 'false',
+      npm_config_production: 'false',
+    },
+    onLog,
+  });
+  if (!(await packageDependenciesReady(projectPath, command))) {
+    const binName = expectedPackageBin(command);
+    throw new Error(binName
+      ? `${binName} was not installed. Check package.json dependencies or install output.`
+      : 'Project dependencies were not installed.');
+  }
+  onLog('Project dependencies are ready.');
+  return true;
+}
+
+function prependPathEntries(env, entries) {
+  const cleanEntries = entries.filter(Boolean);
+  if (!cleanEntries.length) return env;
+
+  const existingPath = env.Path || env.PATH || '';
+  const nextPath = [...cleanEntries, existingPath].filter(Boolean).join(path.delimiter);
+  return process.platform === 'win32'
+    ? { ...env, PATH: nextPath, Path: nextPath }
+    : { ...env, PATH: nextPath };
+}
+
+function applyManagedRuntimeEnv(env, runtimeStatus) {
+  if (runtimeStatus?.id !== 'frankenphp' || !runtimeStatus.executablePath) {
+    return env;
+  }
+
+  const runtimeDir = path.dirname(runtimeStatus.executablePath);
+  return prependPathEntries(env, [
+    runtimeDir,
+    path.join(runtimeDir, 'ext'),
+  ]);
+}
+
 function buildManagedPhpCommand(runtimeStatus) {
   const executable = runtimeStatus?.executablePath || 'frankenphp';
   return {
@@ -711,6 +860,7 @@ export async function startLiveView(projectName, projectPath, options = {}) {
     ...buildCliSpawnEnv(process.env),
     ...(command.env || {}),
     ...(process.versions.electron ? { ELECTRON_RUN_AS_NODE: '1' } : {}),
+    NODE_ENV: 'development',
     PORT: String(port),
     HOST: '127.0.0.1',
     VITE_HOST: '127.0.0.1',
@@ -718,16 +868,29 @@ export async function startLiveView(projectName, projectPath, options = {}) {
     BROWSER: 'none',
     NEXT_TELEMETRY_DISABLED: '1',
   };
+  const spawnEnv = applyManagedRuntimeEnv(env, runtimeStatus);
+
+  sessionsByProject.set(projectName, session);
+  sessionsByShareId.set(shareId, session);
+
+  try {
+    await preparePackageDependencies(projectPath, command, spawnEnv, (line) => appendLog(session, line));
+  } catch (error) {
+    session.status = 'error';
+    session.stoppedAt = new Date().toISOString();
+    session.error = error instanceof Error ? error.message : String(error);
+    appendLog(session, session.error);
+    return publicSession(session);
+  }
+
   const child = spawn(command.command, command.args, {
     cwd: projectPath,
-    env,
+    env: spawnEnv,
     shell: shouldUseShell(command),
     stdio: ['ignore', 'pipe', 'pipe'],
   });
 
   session.child = child;
-  sessionsByProject.set(projectName, session);
-  sessionsByShareId.set(shareId, session);
 
   child.stdout.on('data', (chunk) => {
     chunk.toString().split(/\r?\n/).forEach((line) => appendLog(session, line));

package/server/services/managed-runtimes.js

@@ -121,21 +121,39 @@ async function downloadFile(url, targetFile, env = process.env) {
 function runProcess(command, args, options = {}) {
   return new Promise((resolve, reject) => {
     let stderr = '';
+    let settled = false;
+    const { timeoutMs, ...spawnOptions } = options;
     const child = spawn(command, args, {
-      ...options,
+      ...spawnOptions,
       stdio: ['ignore', 'ignore', 'pipe'],
       windowsHide: true,
     });
+    const finish = (callback, value) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      callback(value);
+    };
+    const timer = timeoutMs
+      ? setTimeout(() => {
+        try {
+          child.kill();
+        } catch {
+          // Process may have exited between timeout scheduling and kill.
+        }
+        finish(reject, new Error(`${command} timed out after ${timeoutMs}ms`));
+      }, timeoutMs)
+      : null;
     child.stderr.on('data', (chunk) => {
       stderr += chunk.toString();
     });
-    child.on('error', reject);
+    child.on('error', (error) => finish(reject, error));
     child.on('close', (code) => {
       if (code === 0) {
-        resolve();
+        finish(resolve);
         return;
       }
-      reject(new Error(`${command} exited with code ${code}${stderr ? `: ${stderr.trim()}` : ''}`));
+      finish(reject, new Error(`${command} exited with code ${code}${stderr ? `: ${stderr.trim()}` : ''}`));
     });
   });
 }
@@ -200,6 +218,27 @@ async function findRuntimeExecutable(searchRoot, binaryName) {
   return null;
 }
 
+async function copyRuntimeWithSidecars(executablePath, currentDir) {
+  const executableDir = path.dirname(executablePath);
+  await fs.rm(currentDir, { recursive: true, force: true });
+  await fs.mkdir(currentDir, { recursive: true });
+  await fs.cp(executableDir, currentDir, { recursive: true, force: true });
+  return path.join(currentDir, path.basename(executablePath));
+}
+
+async function validateManagedRuntimeExecutable(id, executablePath, env = process.env) {
+  if (id !== 'frankenphp') return true;
+  try {
+    await runProcess(executablePath, ['version'], {
+      env,
+      timeoutMs: 5000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function installFrankenPhp(env = process.env) {
   const releaseApiUrl = env.PIXCODE_FRANKENPHP_RELEASE_API
     || 'https://api.github.com/repos/php/frankenphp/releases/latest';
@@ -245,12 +284,7 @@ async function installFrankenPhp(env = process.env) {
     await fs.chmod(executablePath, 0o755).catch(() => undefined);
   }
 
-  await fs.rm(currentDir, { recursive: true, force: true });
-  await fs.mkdir(currentDir, { recursive: true });
-
-  const finalName = process.platform === 'win32' ? 'frankenphp.exe' : 'frankenphp';
-  const finalExecutable = path.join(currentDir, finalName);
-  await fs.copyFile(executablePath, finalExecutable);
+  const finalExecutable = await copyRuntimeWithSidecars(executablePath, currentDir);
   if (process.platform !== 'win32') {
     await fs.chmod(finalExecutable, 0o755).catch(() => undefined);
   }
@@ -379,6 +413,18 @@ export async function getManagedRuntimeStatus(id, options = {}) {
 
   const manifest = await readManifest(id, env);
   if (manifest) {
+    const valid = await validateManagedRuntimeExecutable(id, manifest.executablePath, env);
+    if (!valid) {
+      return {
+        id,
+        label: 'Pixcode PHP runtime',
+        provider: 'FrankenPHP',
+        status: 'missing',
+        installable: true,
+        reason: 'The existing Pixcode PHP runtime is incomplete or cannot start. Pixcode will reinstall it automatically.',
+      };
+    }
+
     return {
       id,
       label: manifest.label || 'Pixcode PHP runtime',

package/server/services/notification-orchestrator.js

@@ -172,8 +172,9 @@ function buildPushBody(event) {
 
 function buildNotificationPayload(event) {
   const pushBody = buildPushBody(event);
+  const baseId = event.dedupeKey || `${event.provider || 'system'}:${event.kind || 'info'}:${event.code || 'generic'}:${event.sessionId || 'none'}`;
   return {
-    id: event.dedupeKey || `${event.provider || 'system'}:${event.kind || 'info'}:${event.code || 'generic'}:${event.sessionId || 'none'}:${event.createdAt}`,
+    id: `${baseId}:${event.createdAt}`,
     title: pushBody.title,
     body: pushBody.body,
     kind: event.kind || 'info',

package/server/services/provider-models.js

@@ -86,6 +86,20 @@ function mergeCatalogs(primary, secondary) {
     return Array.from(seen.values());
 }
 
+function mergeProviderCatalogs(provider, primary, staticCatalog) {
+    const normalizedPrimary = normalizeList(primary);
+
+    // OpenCode Zen free models rotate often. When models.dev succeeds, treat
+    // that live catalog as authoritative; otherwise stale static freebies can
+    // leak back into the UI and fail later with ProviderModelNotFoundError.
+    if (provider === 'opencode') {
+        const liveModels = normalizedPrimary.filter((item) => item.source === 'api');
+        if (liveModels.length > 0) return liveModels;
+    }
+
+    return mergeCatalogs(normalizedPrimary, staticCatalog);
+}
+
 // ---------------- Per-provider live discovery ----------------
 
 async function discoverAnthropic(apiKey, baseUrl) {
@@ -287,8 +301,9 @@ export async function getProviderModels(provider, opts = {}) {
         : false;
 
     if (!forceRefresh && cacheFresh && Array.isArray(cached?.models)) {
+        const merged = mergeProviderCatalogs(provider, cached.models, staticCatalog);
         return {
-            models: mergeCatalogs(normalizeList(cached.models), staticCatalog),
+            models: merged,
             fetchedAt: cached.fetchedAt,
             error: cached.error,
             fromCache: true,
@@ -305,7 +320,7 @@ export async function getProviderModels(provider, opts = {}) {
         } catch (err) {
             error = err?.message || String(err);
         }
-        const merged = mergeCatalogs(normalizeList(liveModels), staticCatalog);
+        const merged = mergeProviderCatalogs(provider, liveModels, staticCatalog);
         const entry = { models: merged, error };
         await saveCacheEntry(provider, entry).catch(() => { /* non-fatal */ });
         return { models: merged, fetchedAt: new Date().toISOString(), error, fromCache: false };
@@ -367,7 +382,7 @@ export async function getProviderModels(provider, opts = {}) {
         }
     }
 
-    const merged = mergeCatalogs(normalizeList(liveModels), staticCatalog);
+    const merged = mergeProviderCatalogs(provider, liveModels, staticCatalog);
     const entry = { models: merged, error };
     await saveCacheEntry(provider, entry).catch(() => { /* non-fatal */ });
     return { models: merged, fetchedAt: new Date().toISOString(), error, fromCache: false };

package/shared/modelConstants.js

@@ -110,11 +110,10 @@ export const QWEN_MODELS = {
 export const OPENCODE_MODELS = {
   OPTIONS: [
     // OpenCode Zen — free tier (no charge, may rate-limit). The "limited
-    // time" Zen freebies rotate, so this is the safest small set.
+    // time" Zen freebies rotate, so keep this fallback conservative and let
+    // the live models.dev catalog populate the full current list.
     { value: "opencode/big-pickle", label: "OpenCode Zen · Big Pickle (Free)", free: true },
     { value: "opencode/minimax-m2.5-free", label: "OpenCode Zen · MiniMax M2.5 (Free)", free: true },
-    { value: "opencode/hy3-preview-free", label: "OpenCode Zen · Hy3 Preview (Free)", free: true },
-    { value: "opencode/ling-2.6-flash-free", label: "OpenCode Zen · Ling 2.6 Flash (Free)", free: true },
     { value: "opencode/nemotron-3-super-free", label: "OpenCode Zen · Nemotron 3 Super (Free)", free: true },
     { value: "opencode/gpt-5-nano", label: "OpenCode Zen · GPT-5 Nano (Free)", free: true },