@monotykamary/pi-opencode-provider 1.0.10 → 1.0.12

package/scripts/update-models.js

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+
+/**
+ * Script to update opencode models from models.dev API
+ * Writes to models.json (Pi-native format) and updates README.md.
+ *
+ * Pipeline: models.dev API → models.json (idempotent, re-runnable)
+ *           patch.json + custom-models.json for our layered overrides
+ */
+
+import https from 'https';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const API_URL = 'https://models.dev/api.json';
+const PROVIDER_ID = 'opencode';
+
+// Map models.dev provider.npm to pi API type and base URL
+const NPM_TO_API = {
+  '@ai-sdk/anthropic': { api: 'anthropic-messages', baseUrl: 'https://opencode.ai/zen' },
+  '@ai-sdk/openai':     { api: 'openai-responses',   baseUrl: 'https://opencode.ai/zen/v1' },
+  '@ai-sdk/google':     { api: 'google-generative-ai', baseUrl: 'https://opencode.ai/zen/v1' },
+};
+const DEFAULT_API = { api: 'openai-completions', baseUrl: 'https://opencode.ai/zen/v1' };
+
+// Fetch JSON from URL
+function fetchJSON(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(new Error(`Failed to parse JSON: ${e.message}`));
+        }
+      });
+    }).on('error', reject);
+  });
+}
+
+// Format cost for display
+function formatCost(cost) {
+  if (cost === 0) return '—';
+  if (cost === null || cost === undefined) return '—';
+  return '$' + cost.toFixed(2);
+}
+
+// Format number with K/M suffix
+function formatNumber(num) {
+  if (num === null || num === undefined) return '-';
+  if (num >= 1000000) return `${(num / 1000000).toFixed(1)}M`;
+  if (num >= 1000) return `${(num / 1000).toFixed(0)}K`;
+  return num.toString();
+}
+
+// Get input types from modalities (pi supports "text" and "image" only)
+function getInputTypes(modalities) {
+  const raw = modalities?.input || ['text'];
+  const filtered = raw.filter(m => m === 'text' || m === 'image');
+  if (!filtered.includes('text')) filtered.unshift('text');
+  return filtered;
+}
+
+// Get API label for display
+function getApiLabel(api) {
+  const labels = {
+    'anthropic-messages': 'Anthropic',
+    'openai-responses': 'Responses',
+    'openai-completions': 'Completions',
+    'google-generative-ai': 'Gemini',
+  };
+  return labels[api] || api;
+}
+
+// Convert API model to Pi-native format with per-model api/baseUrl
+function convertModel(model) {
+  const npm = model.provider?.npm;
+  const { api, baseUrl } = (npm && NPM_TO_API[npm]) || DEFAULT_API;
+  const inputTypes = getInputTypes(model.modalities);
+  const cost = model.cost || {};
+  const limit = model.limit || {};
+
+  return {
+    id: model.id,
+    name: model.name,
+    api,
+    baseUrl,
+    reasoning: model.reasoning || false,
+    input: inputTypes,
+    cost: {
+      input: cost.input || 0,
+      output: cost.output || 0,
+      cacheRead: cost.cache_read || 0,
+      cacheWrite: cost.cache_write || 0,
+    },
+    contextWindow: limit.context || 0,
+    maxTokens: limit.output || 0,
+  };
+}
+
+// Load a layered JSON model file.
+function loadJson(fileName) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(process.cwd(), fileName), 'utf8'));
+  } catch {
+    return fileName === 'patch.json' ? {} : [];
+  }
+}
+
+// Deep-merge patch overrides into a model for README documentation. The
+// generated models.json remains API-derived; only the displayed model map uses patches.
+function applyPatch(model, patch) {
+  if (!patch) return model;
+  const result = { ...model };
+  for (const [key, value] of Object.entries(patch)) {
+    if (key === 'cost' || key === 'compat' || key === 'thinkingLevelMap') {
+      result[key] = { ...(result[key] || {}), ...value };
+    } else {
+      result[key] = value;
+    }
+  }
+  if (!result.reasoning) {
+    delete result.thinkingLevelMap;
+    if (result.compat?.thinkingFormat) delete result.compat.thinkingFormat;
+  }
+  return result;
+}
+
+// Merge API models, patches, and custom models in the same order as index.ts.
+function buildModels(baseModels, customModels, patch) {
+  const byId = new Map(baseModels.map(model => [model.id, model]));
+  for (const [id, entry] of Object.entries(patch)) {
+    if (byId.has(id)) byId.set(id, applyPatch(byId.get(id), entry));
+  }
+  for (const model of customModels) {
+    byId.set(model.id, applyPatch(model, patch[model.id]));
+  }
+  return Array.from(byId.values());
+}
+
+// Generate README model table row
+function generateReadmeRow(model) {
+  const cost = model.cost || {};
+  const hasImage = model.input.includes('image');
+  const typeLabel = hasImage ? 'Text + Image' : 'Text';
+  return `| ${model.name} | ${getApiLabel(model.api)} | ${typeLabel} | ${formatNumber(model.contextWindow)} | ${formatNumber(model.maxTokens)} | ${formatCost(cost.input)} | ${formatCost(cost.output)} |`;
+}
+
+// Update README model table
+function updateReadme(models) {
+  const readmePath = path.join(process.cwd(), 'README.md');
+  let readme;
+
+  try {
+    readme = fs.readFileSync(readmePath, 'utf8');
+  } catch {
+    console.log('  No README.md found, skipping README update');
+    return;
+  }
+
+  // Sort models by name
+  const sortedModels = [...models].sort((a, b) => a.name.localeCompare(b.name));
+
+  // Generate table rows
+  const tableRows = sortedModels.map(generateReadmeRow).join('\n');
+  const newTable = `| Model | API | Type | Context | Max Tokens | Input Cost | Output Cost |
+|-------|-----|------|---------|------------|------------|-------------|
+${tableRows}`;
+
+  // Replace table in README
+  const tableRegex = /\| Model \| API \| Type \| Context \| Max Tokens \| Input Cost \| Output Cost \|[\s\S]*?(?=\n\*Costs are per million)/;
+  if (readme.match(tableRegex)) {
+    readme = readme.replace(tableRegex, newTable);
+  } else {
+    // Fallback: replace old 6-column table format
+    const oldTableRegex = /\| Model \| Type \| Context \| Max Tokens \| Input Cost \| Output Cost \|[\s\S]*?(?=\n\*Costs are per million)/;
+    if (readme.match(oldTableRegex)) {
+      readme = readme.replace(oldTableRegex, newTable);
+    }
+  }
+
+  // Update model count in features
+  readme = readme.replace(/\*\*\d+\+ AI Models\*\*/, `**${models.length}+ AI Models**`);
+
+  fs.writeFileSync(readmePath, readme);
+  console.log(`  Updated README.md with ${models.length} models`);
+}
+
+// Grace period for delisted models: update-models.js moves models the API no
+// longer lists into deprecated-models.json (stamped with deprecatedAt) instead
+// of dropping them; the runtime appends them back so sessions and saved model
+// settings keep working, and after 14 days they are evicted permanently.
+const DEPRECATED_MODEL_TTL_MS = 14 * 24 * 60 * 60 * 1000;
+
+/**
+ * Reconcile deprecated-models.json against the freshly fetched model list.
+ * - in old models.json but not the API: moved into the deprecated file
+ *   (deprecatedAt = now; preserved on repeat runs so the grace clock is not reset)
+ * - back in the API: resurrected (dropped from the deprecated file)
+ * - deprecatedAt older than 14 days: evicted permanently
+ * Must run BEFORE the new models.json is written; it reads the old file itself.
+ */
+function updateDeprecatedModels(modelsJsonPath, newModels) {
+  const deprecatedPath = path.join(path.dirname(modelsJsonPath), 'deprecated-models.json');
+
+  let oldModels = [];
+  try {
+    const parsed = JSON.parse(fs.readFileSync(modelsJsonPath, 'utf8'));
+    if (Array.isArray(parsed)) oldModels = parsed;
+  } catch { /* first run: no previous models.json */ }
+
+  let deprecated = {};
+  try {
+    const parsed = JSON.parse(fs.readFileSync(deprecatedPath, 'utf8'));
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) deprecated = parsed;
+  } catch { /* no graveyard yet */ }
+
+  const currentIds = new Set(newModels.map(m => m.id));
+  const now = new Date().toISOString();
+  const added = [];
+  const resurrected = [];
+  const evicted = [];
+
+  for (const old of oldModels) {
+    if (old && old.id && !currentIds.has(old.id) && !deprecated[old.id]) {
+      deprecated[old.id] = { ...old, deprecatedAt: now };
+      added.push(old.id);
+    }
+  }
+
+  for (const [id, entry] of Object.entries(deprecated)) {
+    if (currentIds.has(id)) {
+      delete deprecated[id];
+      resurrected.push(id);
+      continue;
+    }
+    const removedAt = Date.parse(entry && entry.deprecatedAt ? entry.deprecatedAt : '');
+    if (Number.isNaN(removedAt) || Date.now() - removedAt > DEPRECATED_MODEL_TTL_MS) {
+      delete deprecated[id];
+      evicted.push(id);
+    }
+  }
+
+  if (added.length > 0 || resurrected.length > 0 || evicted.length > 0) {
+    fs.writeFileSync(deprecatedPath, JSON.stringify(deprecated, null, 2) + '\n');
+    console.log('Updated deprecated-models.json ' + JSON.stringify({ added, resurrected, evicted }));
+  }
+}
+
+/**
+ * Grace-period deprecated models (deprecatedAt within TTL) with metadata stripped.
+ * Keeps the README table serving models that are delisted but still within their
+ * 14-day grace window.
+ */
+function withDeprecatedForReadme(models) {
+  const deprecatedPath = path.join(process.cwd(), 'deprecated-models.json');
+  let deprecated = {};
+  try {
+    const parsed = JSON.parse(fs.readFileSync(deprecatedPath, 'utf8'));
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) deprecated = parsed;
+  } catch { /* no graveyard yet */ }
+  const now = Date.now();
+  const seen = new Set(models.map(m => m.id));
+  const extras = [];
+  for (const entry of Object.values(deprecated)) {
+    if (!entry || !entry.id || seen.has(entry.id)) continue;
+    const removedAt = Date.parse(entry.deprecatedAt || '');
+    if (Number.isNaN(removedAt) || now - removedAt > DEPRECATED_MODEL_TTL_MS) continue;
+    const m = { ...entry };
+    delete m.deprecatedAt;
+    extras.push(m);
+  }
+  return extras.length > 0 ? [...models, ...extras] : models;
+}
+async function main() {
+  console.log('Fetching models from API...');
+
+  try {
+    const data = await fetchJSON(API_URL);
+    const provider = data[PROVIDER_ID];
+
+    if (!provider) {
+      throw new Error(`Provider "${PROVIDER_ID}" not found in API`);
+    }
+
+    if (!provider.models) {
+      throw new Error(`No models found for provider "${PROVIDER_ID}"`);
+    }
+
+    // Convert models object to array and filter out deprecated
+    const apiModels = Object.values(provider.models).filter(m => m.status !== 'deprecated');
+
+    console.log(`Found ${apiModels.length} active models`);
+
+    // Convert to Pi-native format and save to models.json
+    const models = apiModels.map(convertModel);
+    const modelsPath = path.join(process.cwd(), 'models.json');
+    // Move delisted models to deprecated-models.json BEFORE models.json is overwritten
+    updateDeprecatedModels(modelsPath, models);
+    fs.writeFileSync(modelsPath, JSON.stringify(models, null, 2) + '\n');
+    console.log(`  Saved ${models.length} models to models.json`);
+
+    // Apply layered overrides for documentation: models.json → patch.json → custom-models.json.
+    const patch = loadJson('patch.json');
+    const customModels = Array.isArray(loadJson('custom-models.json')) ? loadJson('custom-models.json') : [];
+    updateReadme(buildModels(models, customModels, patch));
+
+    console.log('\nDone!');
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();