@pixelbyte-software/pixcode 1.33.4 → 1.33.5

package/server/modules/providers/list/opencode/opencode-sessions.provider.ts

@@ -87,15 +87,44 @@ export class OpencodeSessionsProvider implements IProviderSessions {
     }
 
     if (raw.type === 'error') {
+      // OpenCode `--format json` emits errors as
+      //   { type:"error", error:{ name, data:{ message, statusCode?, isRetryable? } } }
+      // — `error` is always an object wrapper, never a plain string. Older
+      // builds put the message at `error.message`; current builds nest it
+      // under `error.data.message`. Map known error class names to friendly
+      // copy so the user gets actionable text instead of a class identifier.
       const rawErr = raw.error ?? raw.message;
-      const content = typeof rawErr === 'string'
-        ? rawErr
-        : rawErr && typeof rawErr === 'object'
-          ? (() => {
-              try { return JSON.stringify(rawErr); }
-              catch { return 'Unknown OpenCode streaming error'; }
-            })()
-          : 'Unknown OpenCode streaming error';
+      const errObj = rawErr && typeof rawErr === 'object' ? rawErr as Record<string, unknown> : null;
+      const data = errObj && typeof errObj.data === 'object' && errObj.data
+        ? errObj.data as Record<string, unknown>
+        : null;
+      const dataMessage = data && typeof data.message === 'string' ? data.message : null;
+      const errMessage = errObj && typeof errObj.message === 'string' ? errObj.message : null;
+      const errName = errObj && typeof errObj.name === 'string' ? errObj.name : null;
+      const statusCode = data && typeof data.statusCode === 'number' ? data.statusCode : null;
+
+      let content: string;
+      if (typeof rawErr === 'string') {
+        content = rawErr;
+      } else if (dataMessage) {
+        content = dataMessage;
+      } else if (errMessage) {
+        content = errMessage;
+      } else if (errName) {
+        const friendly: Record<string, string> = {
+          ProviderModelNotFoundError: 'Model not found. Open Settings → Agents → OpenCode and pick a model from the live catalog (or run `opencode models --refresh`).',
+          ProviderInitError: 'OpenCode provider config is invalid. Try `opencode auth login` or remove `~/.local/share/opencode/auth.json` and re-authenticate.',
+          MessageOutputLengthError: 'OpenCode response was truncated by the model output cap. Try shortening the prompt or pick a model with a larger output limit.',
+          AI_APICallError: 'OpenCode upstream API call failed. Clearing `~/.cache/opencode` and retrying usually fixes this.',
+          APIError: statusCode === 429
+            ? 'OpenCode hit a rate limit (429). Wait a few seconds and try again, or switch to a different model.'
+            : 'OpenCode upstream API error.',
+        };
+        content = friendly[errName] ?? errName;
+      } else {
+        try { content = JSON.stringify(rawErr); }
+        catch { content = 'Unknown OpenCode streaming error'; }
+      }
       return [createNormalizedMessage({
         id: baseId,
         sessionId,

package/server/opencode-cli.js

@@ -275,17 +275,31 @@ async function spawnOpencode(command, options = {}, ws) {
         });
 
         opencodeProcess.stderr.on('data', (data) => {
-            const errorMsg = data.toString();
+            const rawMsg = data.toString();
             // Suppress known cosmetic noise.
-            if (errorMsg.includes('[DEP0040]') ||
-                errorMsg.includes('DeprecationWarning') ||
-                errorMsg.includes('--trace-deprecation') ||
-                errorMsg.includes('punycode')) {
+            if (rawMsg.includes('[DEP0040]') ||
+                rawMsg.includes('DeprecationWarning') ||
+                rawMsg.includes('--trace-deprecation') ||
+                rawMsg.includes('punycode')) {
                 return;
             }
 
+            // Pre-stream validation errors land on stderr as plain text BEFORE
+            // the JSON event stream opens (e.g. "Model must be in the format
+            // provider/model"). Map the common ones to actionable copy.
+            let friendly = rawMsg.trim();
+            if (/Model must be in the format/i.test(friendly)) {
+                friendly = 'Model id must use the `provider/model` format (e.g. `opencode/big-pickle` or `anthropic/claude-sonnet-4-5`). Pick one from Settings → Agents → OpenCode → Model.';
+            } else if (/ProviderModelNotFoundError/.test(friendly)) {
+                friendly = 'OpenCode does not recognize the selected model. Run `opencode models --refresh` or pick a different model from the picker.';
+            } else if (/ProviderInitError/.test(friendly)) {
+                friendly = 'OpenCode provider config is invalid. Try `opencode auth login`, or clear `~/.local/share/opencode/auth.json` and re-authenticate.';
+            } else if (/AI_APICallError/.test(friendly)) {
+                friendly = 'OpenCode upstream call failed. Clearing `~/.cache/opencode` and retrying usually resolves this.';
+            }
+
             const socketSessionId = typeof ws.getSessionId === 'function' ? ws.getSessionId() : (capturedSessionId || sessionId);
-            ws.send(createNormalizedMessage({ kind: 'error', content: errorMsg, sessionId: socketSessionId, provider: 'opencode' }));
+            ws.send(createNormalizedMessage({ kind: 'error', content: friendly, sessionId: socketSessionId, provider: 'opencode' }));
         });
 
         opencodeProcess.on('close', async (code) => {

package/server/opencode-response-handler.js

@@ -45,25 +45,33 @@ class OpencodeResponseHandler {
       return;
     }
 
-    // OpenCode emits both `message` events and `part` events that compose
-    // a single assistant turn. We handle whichever shape lands.
-    if (event.type === 'message' && event.role === 'assistant') {
+    // OpenCode emits assistant text as either a top-level `text` event
+    // (current `--format json` shape: `{ type: "text", part: { text } }`)
+    // or as `message`/`part` legacy shapes from earlier builds. Cover all
+    // three so we don't drop tokens on a CLI version we haven't matched.
+    if (event.type === 'text' && event.part && typeof event.part.text === 'string') {
+      if (this.onContentFragment && event.part.text) this.onContentFragment(event.part.text);
+    } else if (event.type === 'message' && event.role === 'assistant') {
       const content = event.content || event.text || '';
       if (this.onContentFragment && content) this.onContentFragment(content);
     } else if (event.type === 'part' && event.part_type === 'text') {
       const content = event.text || event.content || '';
       if (this.onContentFragment && content) this.onContentFragment(content);
     } else if (event.type === 'tool_use' || event.type === 'tool-use' || event.type === 'tool.start') {
+      // Tool-use shape on `--format json`: `{ type:"tool_use", part:{ callID, tool, state:{ input } } }`
+      const part = event.part || event;
       if (this.onToolUse) this.onToolUse({
-        tool_id: event.tool_id || event.id,
-        tool_name: event.tool_name || event.name,
-        parameters: event.parameters || event.input || {},
+        tool_id: part.callID || part.id || event.tool_id,
+        tool_name: part.tool || part.name || event.tool_name,
+        parameters: part.state?.input || part.input || event.parameters || {},
       });
     } else if (event.type === 'tool_result' || event.type === 'tool-result' || event.type === 'tool.end') {
+      const part = event.part || event;
+      const state = part.state || {};
       if (this.onToolResult) this.onToolResult({
-        tool_id: event.tool_id || event.id,
-        output: event.output ?? event.result ?? '',
-        status: event.status || (event.isError ? 'error' : 'ok'),
+        tool_id: part.callID || part.id || event.tool_id,
+        output: state.output ?? part.output ?? event.output ?? event.result ?? '',
+        status: state.status || event.status || (event.isError ? 'error' : 'ok'),
       });
     }
 

package/server/services/provider-models.js

@@ -71,7 +71,9 @@ function normalizeList(list) {
         seen.add(value);
         const label = typeof item.label === 'string' && item.label.trim() ? item.label.trim() : value;
         const source = item.source === 'api' ? 'api' : 'static';
-        out.push({ value, label, source });
+        const entry = { value, label, source };
+        if (typeof item.free === 'boolean') entry.free = item.free;
+        out.push(entry);
     }
     return out;
 }
@@ -123,6 +125,101 @@ async function discoverOpenAiCompat(apiKey, baseUrl, fallbackBase) {
         }));
 }
 
+/**
+ * OpenCode is multi-provider — its "model" picker isn't a single API list,
+ * it's the union of every provider it can route to (Anthropic, OpenAI,
+ * Google, xAI, OpenRouter, OpenCode Zen, Ollama, etc.). The canonical
+ * catalog lives at https://models.dev/api.json (no auth, ~1.8 MB JSON, 115
+ * providers as of 2026-04). We pull that, filter to providers the user
+ * has authenticated with (read `~/.local/share/opencode/auth.json`) plus
+ * always include the OpenCode Zen tier (works without explicit auth on
+ * the free models), drop deprecated entries, and tag free models.
+ */
+async function discoverOpencode() {
+    const url = process.env.OPENCODE_MODELS_URL || 'https://models.dev/api.json';
+    const response = await fetch(url, {
+        // OpenCode itself caches this for hours; we cache for 6h via the
+        // outer wrapper so a single 7s fetch on cold start is acceptable.
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!response.ok) throw new Error(`models.dev/api.json returned ${response.status}`);
+    const data = await response.json();
+    if (!data || typeof data !== 'object') throw new Error('models.dev returned a non-object payload');
+
+    // Read OpenCode's auth.json to know which providers the user can
+    // actually call. Missing file → only show always-free Zen.
+    const authedProviders = new Set(['opencode']);
+    try {
+        const authPath = path.join(os.homedir(), '.local', 'share', 'opencode', 'auth.json');
+        const raw = await fs.readFile(authPath, 'utf8');
+        const auth = JSON.parse(raw);
+        if (auth && typeof auth === 'object') {
+            for (const k of Object.keys(auth)) authedProviders.add(k);
+        }
+    } catch { /* no auth.json → only Zen free models surface */ }
+
+    // Common env-var providers OpenCode picks up automatically. If the user
+    // exported one in their shell, surface those models too even without
+    // auth.json. Mirrors the env list in opencode-auth.provider.ts.
+    const envProviderHints = {
+        anthropic: ['ANTHROPIC_API_KEY'],
+        openai: ['OPENAI_API_KEY'],
+        google: ['GOOGLE_GENERATIVE_AI_API_KEY', 'GEMINI_API_KEY'],
+        'google-vertex': ['GOOGLE_APPLICATION_CREDENTIALS'],
+        xai: ['XAI_API_KEY'],
+        groq: ['GROQ_API_KEY'],
+        cerebras: ['CEREBRAS_API_KEY'],
+        openrouter: ['OPENROUTER_API_KEY'],
+    };
+    for (const [providerId, envVars] of Object.entries(envProviderHints)) {
+        if (envVars.some((v) => process.env[v]?.trim())) authedProviders.add(providerId);
+    }
+
+    const out = [];
+    for (const [providerId, providerCfg] of Object.entries(data)) {
+        if (!authedProviders.has(providerId)) continue;
+        if (!providerCfg || typeof providerCfg !== 'object') continue;
+        const models = providerCfg.models;
+        if (!models || typeof models !== 'object') continue;
+
+        const providerName = typeof providerCfg.name === 'string' && providerCfg.name.trim()
+            ? providerCfg.name
+            : providerId;
+
+        for (const [modelId, modelCfg] of Object.entries(models)) {
+            if (!modelCfg || typeof modelCfg !== 'object') continue;
+            // Skip deprecated entries from the default list — users can
+            // still hand-type them if they really need to.
+            if (modelCfg.status === 'deprecated') continue;
+            const cost = modelCfg.cost && typeof modelCfg.cost === 'object' ? modelCfg.cost : null;
+            const free = !cost || (Number(cost.input) === 0 && Number(cost.output) === 0);
+            const ctx = modelCfg.limit?.context;
+            const ctxLabel = typeof ctx === 'number' && ctx > 0
+                ? ` · ${ctx >= 1_000_000 ? `${(ctx / 1_000_000).toFixed(1)}M` : `${Math.round(ctx / 1000)}K`}`
+                : '';
+            const freeLabel = free ? ' · Free' : '';
+            const modelName = typeof modelCfg.name === 'string' && modelCfg.name.trim()
+                ? modelCfg.name
+                : modelId;
+
+            out.push({
+                value: `${providerId}/${modelId}`,
+                label: `${providerName} · ${modelName}${ctxLabel}${freeLabel}`,
+                source: 'api',
+                free,
+            });
+        }
+    }
+
+    // Sort: free first (handy when the user is unauthed), then by label.
+    out.sort((a, b) => {
+        if (a.free !== b.free) return a.free ? -1 : 1;
+        return a.label.localeCompare(b.label);
+    });
+
+    return out;
+}
+
 async function discoverGoogle(apiKey) {
     // Google Generative Language API — public models list, API key as query.
     const endpoint = `https://generativelanguage.googleapis.com/v1beta/models?key=${encodeURIComponent(apiKey)}`;
@@ -165,6 +262,22 @@ export async function getProviderModels(provider, opts = {}) {
         };
     }
 
+    // OpenCode is the odd one out: its catalog is models.dev, not a per-key
+    // API endpoint. Skip the credential plumbing and dispatch straight.
+    let liveModels = [];
+    let error;
+    if (provider === 'opencode') {
+        try {
+            liveModels = await discoverOpencode();
+        } catch (err) {
+            error = err?.message || String(err);
+        }
+        const merged = mergeCatalogs(normalizeList(liveModels), staticCatalog);
+        const entry = { models: merged, error };
+        await saveCacheEntry(provider, entry).catch(() => { /* non-fatal */ });
+        return { models: merged, fetchedAt: new Date().toISOString(), error, fromCache: false };
+    }
+
     // Pick up credentials from Pixcode's UI store first, then fall back to
     // the native env vars so a user who already exported ANTHROPIC_API_KEY
     // (or authenticated Claude Code via OAuth — the SDK writes the key into
@@ -185,8 +298,6 @@ export async function getProviderModels(provider, opts = {}) {
     const apiKey = creds?.apiKey || envKey;
     const baseUrl = creds?.baseUrl || envBase || undefined;
 
-    let liveModels = [];
-    let error;
     if (!apiKey) {
         // Be explicit so the UI can surface a useful hint rather than just
         // showing the static baseline with no reason given.

package/shared/modelConstants.js

@@ -95,25 +95,48 @@ export const QWEN_MODELS = {
 };
 
 /**
- * OpenCode Models
+ * OpenCode Models — STATIC FALLBACK ONLY.
  *
- * OpenCode is multi-provider, so the picker is really "which upstream
- * model does opencode talk to?". The defaults here point at OpenCode Zen
- * (their curated routing tier) plus a few direct picks the docs call
- * out as well-supported. Advanced users override via opencode.json's
- * `provider` / `model` block, which bypasses this list.
+ * OpenCode is multi-provider and the live model catalog rotates often
+ * (Zen free models come and go; new Anthropic/OpenAI/Google models ship
+ * every few weeks). The runtime fetches the live catalog from
+ * `https://models.dev/api.json` via server/services/provider-models.js
+ * and merges it on top of this list — these entries only show when the
+ * fetch fails (offline install, firewalled host).
+ *
+ * Curated current free Zen tier + canonical paid picks. Update when the
+ * fallback feels stale, but the live fetch is the source of truth.
  */
 export const OPENCODE_MODELS = {
   OPTIONS: [
-    { value: "opencode/zen-best", label: "OpenCode Zen (Best)" },
-    { value: "opencode/zen-fast", label: "OpenCode Zen (Fast)" },
+    // OpenCode Zen — free tier (no charge, may rate-limit). The "limited
+    // time" Zen freebies rotate, so this is the safest small set.
+    { 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 },
+
+    // Anthropic — current flagship + cheap.
+    { value: "anthropic/claude-opus-4-7", label: "Claude Opus 4.7 (Anthropic)" },
     { value: "anthropic/claude-sonnet-4-6", label: "Claude Sonnet 4.6 (Anthropic)" },
-    { value: "anthropic/claude-opus-4-6", label: "Claude Opus 4.6 (Anthropic)" },
+    { value: "anthropic/claude-haiku-4-5", label: "Claude Haiku 4.5 (Anthropic)" },
+
+    // OpenAI — current GPT-5 family.
     { value: "openai/gpt-5.4", label: "GPT-5.4 (OpenAI)" },
-    { value: "google/gemini-3-pro-preview", label: "Gemini 3 Pro (Google)" },
+    { value: "openai/gpt-5.1-codex", label: "GPT-5.1 Codex (OpenAI)" },
+
+    // Google — current Gemini 3 family.
+    { value: "google/gemini-3.1-pro-preview", label: "Gemini 3.1 Pro (Google)" },
+    { value: "google/gemini-3-flash-preview", label: "Gemini 3 Flash (Google)" },
+
+    // xAI — fast & cheap coding model.
+    { value: "xai/grok-code-fast-1", label: "Grok Code Fast 1 (xAI)" },
   ],
 
-  DEFAULT: "opencode/zen-best",
+  // Free Zen freebie that historically works for unauthed installs.
+  DEFAULT: "opencode/big-pickle",
 };
 
 /**