@pixelbyte-software/pixcode 1.33.3 → 1.33.5

package/server/opencode-response-handler.js

@@ -1,92 +1,100 @@
-// OpenCode Response Handler — `opencode run --format json` parser.
-//
-// The JSON format streams one event per line (NDJSON). Event shapes follow
-// the OpenAPI contract exposed by `opencode serve`. We treat the stream
-// permissively: lines that don't parse as JSON are passed through as plain
-// text deltas (covers OpenCode's pre-stream banner output and any debug
-// noise the CLI emits to stdout).
-import { sessionsService } from './modules/providers/services/sessions.service.js';
-
-class OpencodeResponseHandler {
-  constructor(ws, options = {}) {
-    this.ws = ws;
-    this.buffer = '';
-    this.onContentFragment = options.onContentFragment || null;
-    this.onInit = options.onInit || null;
-    this.onToolUse = options.onToolUse || null;
-    this.onToolResult = options.onToolResult || null;
-  }
-
-  processData(data) {
-    this.buffer += data;
-
-    const lines = this.buffer.split('\n');
-    this.buffer = lines.pop() || '';
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      try {
-        const event = JSON.parse(trimmed);
-        this.handleEvent(event);
-      } catch {
-        // Non-JSON line — surface as plain text delta so the user sees CLI
-        // banners / status messages instead of swallowing them silently.
-        if (this.onContentFragment) this.onContentFragment(trimmed + '\n');
-      }
-    }
-  }
-
-  handleEvent(event) {
-    const sid = typeof this.ws.getSessionId === 'function' ? this.ws.getSessionId() : null;
-
-    if (event.type === 'init' || event.type === 'session.start') {
-      if (this.onInit) this.onInit(event);
-      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') {
-      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') {
-      if (this.onToolUse) this.onToolUse({
-        tool_id: event.tool_id || event.id,
-        tool_name: event.tool_name || event.name,
-        parameters: event.parameters || event.input || {},
-      });
-    } else if (event.type === 'tool_result' || event.type === 'tool-result' || event.type === 'tool.end') {
-      if (this.onToolResult) this.onToolResult({
-        tool_id: event.tool_id || event.id,
-        output: event.output ?? event.result ?? '',
-        status: event.status || (event.isError ? 'error' : 'ok'),
-      });
-    }
-
-    const normalized = sessionsService.normalizeMessage('opencode', event, sid);
-    for (const msg of normalized) {
-      this.ws.send(msg);
-    }
-  }
-
-  forceFlush() {
-    if (this.buffer.trim()) {
-      try {
-        const event = JSON.parse(this.buffer);
-        this.handleEvent(event);
-      } catch {
-        if (this.onContentFragment) this.onContentFragment(this.buffer);
-      }
-    }
-  }
-
-  destroy() {
-    this.buffer = '';
-  }
-}
-
-export default OpencodeResponseHandler;
+// OpenCode Response Handler — `opencode run --format json` parser.
+//
+// The JSON format streams one event per line (NDJSON). Event shapes follow
+// the OpenAPI contract exposed by `opencode serve`. We treat the stream
+// permissively: lines that don't parse as JSON are passed through as plain
+// text deltas (covers OpenCode's pre-stream banner output and any debug
+// noise the CLI emits to stdout).
+import { sessionsService } from './modules/providers/services/sessions.service.js';
+
+class OpencodeResponseHandler {
+  constructor(ws, options = {}) {
+    this.ws = ws;
+    this.buffer = '';
+    this.onContentFragment = options.onContentFragment || null;
+    this.onInit = options.onInit || null;
+    this.onToolUse = options.onToolUse || null;
+    this.onToolResult = options.onToolResult || null;
+  }
+
+  processData(data) {
+    this.buffer += data;
+
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const event = JSON.parse(trimmed);
+        this.handleEvent(event);
+      } catch {
+        // Non-JSON line — surface as plain text delta so the user sees CLI
+        // banners / status messages instead of swallowing them silently.
+        if (this.onContentFragment) this.onContentFragment(trimmed + '\n');
+      }
+    }
+  }
+
+  handleEvent(event) {
+    const sid = typeof this.ws.getSessionId === 'function' ? this.ws.getSessionId() : null;
+
+    if (event.type === 'init' || event.type === 'session.start') {
+      if (this.onInit) this.onInit(event);
+      return;
+    }
+
+    // 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: 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: 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'),
+      });
+    }
+
+    const normalized = sessionsService.normalizeMessage('opencode', event, sid);
+    for (const msg of normalized) {
+      this.ws.send(msg);
+    }
+  }
+
+  forceFlush() {
+    if (this.buffer.trim()) {
+      try {
+        const event = JSON.parse(this.buffer);
+        this.handleEvent(event);
+      } catch {
+        if (this.onContentFragment) this.onContentFragment(this.buffer);
+      }
+    }
+  }
+
+  destroy() {
+    this.buffer = '';
+  }
+}
+
+export default OpencodeResponseHandler;

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",
 };
 
 /**