@route_33/opencode 0.4.0 → 0.4.2

package/README.md

@@ -24,7 +24,7 @@ The installer patches both configs: the server plugin into `opencode.json` and t
 }
 ```
 
-This plugin never writes your config: opencode has no TUI-plugin auto-discovery, so without a `tui.json` entry the wizard simply never appears — the server plugin works regardless.
+This plugin never writes your `opencode.json` or `opencode.jsonc`: opencode has no TUI-plugin auto-discovery, so without a `tui.json` entry the wizard simply never appears — the server plugin works regardless. The server plugin may write its own `.opencode/route33-generated.json` sidecar to track catalog-generated entries.
 
 ## Auth
 
@@ -37,9 +37,9 @@ The catalog is discovered dynamically. The plugin calls `GET {baseURL}/models` w
 1. Return the fresh on-disk cache if it has not expired.
 2. Fetch live from the gateway and update the cache.
 3. If the live fetch fails, return the stale cache.
-4. If there is no cache and no live response, inject zero models.
+4. If there is no cache and no live response, preserve existing generated entries and inject no replacement models.
 
-The plugin does not embed or serve a static catalog.
+The plugin does not embed or serve a static catalog. Catalog cache envelopes are versioned; cache files from older plugin versions are ignored after an upgrade and repopulated from the gateway.
 
 If discovery yields no catalog, the plugin logs exactly one warning:
 
@@ -55,10 +55,29 @@ Models are decorated with metadata from the route33 gateway broadcast; `models.d
 
 - **Cost**: the gateway's broadcast pricing wins; `models.dev` fills in when the broadcast carries no pricing.
 - **Limits**: the gateway's broadcast `limits` win; `models.dev` fills in when the gateway broadcasts none. Limits are omitted entirely when neither source knows them; the plugin never fabricates them.
+- **Modalities**: gateway `modalities.input` / `modalities.output` are passed through to opencode. Invalid modality values and malformed modality objects are omitted per model.
+- **Attachment**: gateway `attachment` wins whenever present. `models.dev` supplies it only when the gateway omits the field.
 - **Capabilities**: the broadcast `reasoning` and `tool_support` flags win (`tool_support` is mapped to `tool_call`); `models.dev` always backfills any capability flag left undefined.
 - **Variants**: R33 broadcast variants are passed verbatim (for example, `kimi-k3`'s `max` `reasoningEffort` variant).
 
-The normative contract for limits and variants is [docs/gateway-limits-variants-broadcast.md](docs/gateway-limits-variants-broadcast.md).
+The normative broadcast contract is [docs/gateway-limits-variants-broadcast.md](docs/gateway-limits-variants-broadcast.md).
+
+## Managed model entries
+
+Gateway-discovered `provider.route_33.models` entries are managed and regenerated at startup. On the first 0.4.2 run, existing route_33 model entries are adopted as generated; entries no longer served by the gateway are pruned and a manifest is saved at `.opencode/route33-generated.json`. Later runs only remove keys listed in that manifest, then replace them with the current broadcast.
+
+Keep customizations in `.opencode/route33-overrides.json`, because the installed OpenCode `ProviderConfig` does not allow unknown provider-level keys such as `modelOverrides`. Overrides deep-merge onto matching generated entries and can add custom models:
+
+```json
+{
+  "models": {
+    "openai/gpt-5.5": { "variants": { "fast": { "temperature": 0 } } },
+    "custom/internal": { "name": "Internal model" }
+  }
+}
+```
+
+If the gateway fetch fails with no usable cache, regeneration is skipped: existing entries are never pruned. Sidecar I/O failures also preserve the previous add-only behavior for that run.
 
 `ROUTE33_ENRICH_CAPS` has been removed; capability backfill from `models.dev` is now always on.
 

package/dist/index.d.ts

@@ -6,7 +6,7 @@ import { Plugin } from '@opencode-ai/plugin';
  *
  * Registers the `config` hook — key-scoped model discovery, cost/limit
  * enrichment, add-only injection into the single `route_33` provider block
- * (per-model native-SDK routing via `provider.npm`) and strict flavour-ref
+ * (per-model native-SDK routing via `provider.npm`) and strict model-reference
  * validation — plus the `route_33` auth method and options loader.
  * Discovery runs once at startup; restart opencode after a key or config
  * change.

package/dist/index.js

@@ -328,7 +328,10 @@ function toModelPatch(meta, routingSlug, forceReasoning, nativeNpm) {
   if (routingSlug !== void 0) entry.id = routingSlug;
   if (nativeNpm !== void 0) entry.provider = { npm: nativeNpm };
   const caps = meta.capabilities;
-  if (caps.attachment !== void 0) entry.attachment = caps.attachment;
+  if (meta.attachment !== void 0) entry.attachment = meta.attachment;
+  else if (caps.attachment !== void 0) entry.attachment = caps.attachment;
+  if (meta.modalities !== void 0)
+    entry.modalities = { input: [...meta.modalities.input], output: [...meta.modalities.output] };
   if (caps.reasoning !== void 0) entry.reasoning = caps.reasoning;
   if (forceReasoning) entry.reasoning = true;
   if (caps.temperature !== void 0) entry.temperature = caps.temperature;
@@ -390,6 +393,9 @@ function cacheFilePath(keyHash, env) {
   return path5.join(resolveCacheDir(env), `catalog-${keyHash}.json`);
 }
 
+// src/catalog/catalog-cache/cache-version.ts
+var CATALOG_CACHE_VERSION = 2;
+
 // src/catalog/catalog-cache/read-disk.ts
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -399,7 +405,7 @@ function readDisk(keyHash, env) {
     const parsed = JSON.parse(
       fs3.readFileSync(cacheFilePath(keyHash, env), "utf8")
     );
-    if (!isRecord3(parsed) || typeof parsed.fetchedAt !== "number" || !isRecord3(parsed.models))
+    if (!isRecord3(parsed) || parsed.version !== CATALOG_CACHE_VERSION || typeof parsed.fetchedAt !== "number" || !isRecord3(parsed.models))
       return void 0;
     return {
       fetchedAt: parsed.fetchedAt,
@@ -449,7 +455,10 @@ function writeCatalog(opts) {
   memory.set(keyHash, record);
   try {
     fs4.mkdirSync(resolveCacheDir(env), { recursive: true });
-    fs4.writeFileSync(cacheFilePath(keyHash, env), JSON.stringify(record));
+    fs4.writeFileSync(
+      cacheFilePath(keyHash, env),
+      JSON.stringify({ version: CATALOG_CACHE_VERSION, ...record })
+    );
   } catch (error) {
     logger.warn(
       `could not persist catalog cache: ${error instanceof Error ? error.message : String(error)}`
@@ -593,6 +602,13 @@ function parseVariants(raw) {
   if (!Object.values(raw).every(isRecord5)) return void 0;
   return raw;
 }
+function isModality(value) {
+  return value === "text" || value === "audio" || value === "image" || value === "video" || value === "pdf";
+}
+function parseModalities(raw) {
+  if (!isRecord5(raw) || !Array.isArray(raw.input) || !Array.isArray(raw.output)) return void 0;
+  return { input: raw.input.filter(isModality), output: raw.output.filter(isModality) };
+}
 function toCatalogModels(entries, env) {
   const models = {};
   for (const entry of entries) {
@@ -610,6 +626,9 @@ function toCatalogModels(entries, env) {
     if (capabilities !== void 0) model.capabilities = capabilities;
     const variants = parseVariants(entry.variants);
     if (variants !== void 0) model.variants = variants;
+    const modalities = parseModalities(entry.modalities);
+    if (modalities !== void 0) model.modalities = modalities;
+    if (typeof entry.attachment === "boolean") model.attachment = entry.attachment;
     models[slug] = model;
   }
   return models;
@@ -707,7 +726,7 @@ async function runLadder(opts) {
     );
     return { models: stale, source: "stale-cache" };
   }
-  return noneResult("live fetch failed and no cache available", false);
+  return { ...noneResult("live fetch failed and no cache available", false), liveFetchFailed: true };
 }
 async function getCatalog(opts) {
   try {
@@ -748,14 +767,24 @@ function resolveCapabilities(catalogModel, modelsDevLookup) {
 function enrichModel(slug, sources) {
   const modelsDevLookup = sources.modelsDev.lookup(slug);
   const catalogModel = sources.catalogModel;
+  const catalogPresent = sources.catalogPresent ?? catalogModel !== void 0;
   const capabilities = resolveCapabilities(catalogModel, modelsDevLookup);
   const name = catalogModel !== void 0 && catalogModel.id === slug && catalogModel.displayName !== void 0 ? catalogModel.displayName : slug;
   const meta = { name, capabilities };
+  if (catalogModel?.modalities !== void 0) meta.modalities = catalogModel.modalities;
+  const attachment = catalogModel?.attachment ?? modelsDevLookup?.attachment;
+  if (attachment !== void 0) meta.attachment = attachment;
   const limit = resolveLimit(catalogModel, modelsDevLookup);
   if (limit === void 0) {
-    logger.warn(
-      `limit metadata unavailable for ${slug} \u2014 no context/output ceiling will be enforced until added`
-    );
+    if (catalogPresent) {
+      logger.warn(
+        `limit metadata unavailable for ${slug} \u2014 no context/output ceiling will be enforced until added`
+      );
+    } else {
+      logger.info(
+        `not in the current gateway catalog \u2014 serving cached metadata for ${slug}`
+      );
+    }
   } else {
     meta.limit = limit;
   }
@@ -988,7 +1017,11 @@ async function loadModelsDev(options = {}) {
 
 // src/config/enrich-catalog.ts
 function enrichOne(slug, catalogModel, modelsDev, env) {
-  const sources = { modelsDev, env };
+  const sources = {
+    catalogPresent: catalogModel !== void 0,
+    modelsDev,
+    env
+  };
   if (catalogModel !== void 0) sources.catalogModel = catalogModel;
   return enrichModel(slug, sources);
 }
@@ -1000,6 +1033,38 @@ function enrichCatalog(catalog, modelsDev, env) {
   return enriched;
 }
 
+// src/config/merge-provider.ts
+var FORCED_OPTION_FIELDS = /* @__PURE__ */ new Set([
+  "apiKey",
+  "baseURL",
+  "headers"
+]);
+function mergeProvider(target, patch) {
+  if (target.npm === void 0) target.npm = patch.npm;
+  if (target.name === void 0) target.name = patch.name;
+  if (target.options === void 0) {
+    target.options = { ...patch.options };
+  } else {
+    const options = target.options;
+    for (const [field, value] of Object.entries(patch.options)) {
+      if (value === void 0) continue;
+      if (FORCED_OPTION_FIELDS.has(field) || options[field] === void 0)
+        options[field] = value;
+    }
+  }
+}
+
+// src/config/merge-config.ts
+function mergeConfig(cfg, blocks) {
+  if (cfg.provider === void 0) cfg.provider = {};
+  const provider = cfg.provider;
+  for (const [providerID, patch] of Object.entries(blocks)) {
+    const target = provider[providerID] ?? {};
+    provider[providerID] = target;
+    mergeProvider(target, patch);
+  }
+}
+
 // src/config/merge-models.ts
 function cloneEntry(entry) {
   return { ...entry };
@@ -1014,7 +1079,8 @@ function cloneModels(patch) {
 function fillModelEntry(existing, patchEntry) {
   for (const [field, value] of Object.entries(patchEntry)) {
     if (value === void 0) continue;
-    if (existing[field] === void 0) existing[field] = value;
+    if (field === "limit" || existing[field] === void 0)
+      existing[field] = value;
   }
 }
 function mergeModels(target, patch) {
@@ -1033,37 +1099,119 @@ function mergeModels(target, patch) {
   }
 }
 
-// src/config/merge-provider.ts
-var FORCED_OPTION_FIELDS = /* @__PURE__ */ new Set([
-  "apiKey",
-  "baseURL",
-  "headers"
-]);
-function mergeProvider(target, patch) {
-  if (target.npm === void 0) target.npm = patch.npm;
-  if (target.name === void 0) target.name = patch.name;
-  if (target.options === void 0) {
-    target.options = { ...patch.options };
-  } else {
-    const options = target.options;
-    for (const [field, value] of Object.entries(patch.options)) {
-      if (value === void 0) continue;
-      if (FORCED_OPTION_FIELDS.has(field) || options[field] === void 0)
-        options[field] = value;
-    }
+// src/config/generation-manifest.ts
+import * as fs6 from "fs";
+import * as path7 from "path";
+var SIDECAR_DIR = ".opencode";
+var MANIFEST_FILE = "route33-generated.json";
+var OVERRIDES_FILE = "route33-overrides.json";
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function generatedPath(root) {
+  return path7.join(root, SIDECAR_DIR, MANIFEST_FILE);
+}
+function overridesPath(root) {
+  return path7.join(root, SIDECAR_DIR, OVERRIDES_FILE);
+}
+function parseManifest(value) {
+  if (!isRecord7(value) || value.version !== 1 || !Array.isArray(value.generatedKeys) || typeof value.lastBroadcastHash !== "string") return void 0;
+  if (!value.generatedKeys.every((key) => typeof key === "string")) return void 0;
+  return { version: 1, generatedKeys: value.generatedKeys, lastBroadcastHash: value.lastBroadcastHash };
+}
+function parseOverrides(value) {
+  if (!isRecord7(value) || !isRecord7(value.models) || !Object.values(value.models).every(isRecord7)) return void 0;
+  const models = {};
+  for (const [key, entry] of Object.entries(value.models)) if (isRecord7(entry)) models[key] = entry;
+  return models;
+}
+function readJson(file) {
+  try {
+    if (!fs6.existsSync(file)) return void 0;
+    const parsed = JSON.parse(fs6.readFileSync(file, "utf8"));
+    return parsed;
+  } catch (error) {
+    logger.info(`route_33: unable to read generated-model sidecar: ${error instanceof Error ? error.message : String(error)}`);
+    return void 0;
+  }
+}
+function readGenerationManifest(root) {
+  const file = generatedPath(root);
+  const manifest = parseManifest(readJson(file));
+  if (manifest === void 0 && fs6.existsSync(file)) logger.info("route_33: generated-model manifest is malformed; treating this run as first-run regeneration");
+  return manifest;
+}
+function readModelOverrides(root) {
+  const file = overridesPath(root);
+  const overrides = parseOverrides(readJson(file));
+  if (overrides === void 0 && fs6.existsSync(file)) logger.info("route_33: model overrides sidecar is malformed; ignoring it for this run");
+  return overrides ?? {};
+}
+function writeGenerationManifest(root, manifest) {
+  try {
+    fs6.mkdirSync(path7.join(root, SIDECAR_DIR), { recursive: true });
+    fs6.writeFileSync(generatedPath(root), `${JSON.stringify(manifest, null, 2)}
+`);
+    return true;
+  } catch (error) {
+    logger.info(`route_33: unable to write generated-model manifest; using add-only behavior this run: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
   }
-  mergeModels(target, patch);
 }
 
-// src/config/merge-config.ts
-function mergeConfig(cfg, blocks) {
-  if (cfg.provider === void 0) cfg.provider = {};
-  const provider = cfg.provider;
-  for (const [providerID, patch] of Object.entries(blocks)) {
-    const target = provider[providerID] ?? {};
-    provider[providerID] = target;
-    mergeProvider(target, patch);
+// src/config/regenerate-models.ts
+import { createHash as createHash2 } from "crypto";
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clone(value) {
+  if (Array.isArray(value)) return value.map(clone);
+  if (!isRecord8(value)) return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clone(item)]));
+}
+function cloneEntry2(entry) {
+  const copy = {};
+  for (const [key, value] of Object.entries(entry)) copy[key] = clone(value);
+  return copy;
+}
+function mergeEntry(base, override) {
+  const result = cloneEntry2(base);
+  for (const [key, value] of Object.entries(override)) {
+    const existing = result[key];
+    result[key] = isRecord8(existing) && isRecord8(value) ? mergeEntry(existing, value) : clone(value);
   }
+  return result;
+}
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (!isRecord8(value)) return JSON.stringify(value);
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+}
+function broadcastHash(models) {
+  return createHash2("sha256").update(stableJson(models)).digest("hex");
+}
+function regenerateModels(input) {
+  if (input.source === "none" && input.failedLiveFetch === true) {
+    const models2 = {};
+    for (const [key, entry] of Object.entries(input.currentModels ?? {}))
+      if (entry !== void 0) models2[key] = cloneEntry2(entry);
+    return { models: models2, prunedKeys: [], skipped: true };
+  }
+  const current = input.currentModels ?? {};
+  const generatedKeys = input.previousManifest?.generatedKeys ?? Object.keys(current);
+  const models = {};
+  for (const [key, entry] of Object.entries(current)) {
+    if (!generatedKeys.includes(key) && entry !== void 0) models[key] = cloneEntry2(entry);
+  }
+  for (const [key, entry] of Object.entries(input.freshModels)) models[key] = cloneEntry2(entry);
+  for (const [key, override] of Object.entries(input.overrides ?? {}))
+    models[key] = mergeEntry(models[key] ?? {}, override);
+  const freshKeys = Object.keys(input.freshModels).sort();
+  return {
+    models,
+    manifest: { version: 1, generatedKeys: freshKeys, lastBroadcastHash: broadcastHash(input.freshModels) },
+    prunedKeys: generatedKeys.filter((key) => input.freshModels[key] === void 0).sort()
+  };
 }
 
 // src/config/collected-ref.ts
@@ -1100,66 +1248,6 @@ function collectCfgRefs(cfg) {
   return refs;
 }
 
-// src/config/collect-flavour-refs.ts
-import * as fs6 from "fs";
-import * as os3 from "os";
-import * as path7 from "path";
-import { parse as parseJsonc } from "jsonc-parser";
-function isRecord7(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function findFlavourPath(env, cwd) {
-  const candidates = [];
-  const configDir = env.OPENCODE_CONFIG_DIR?.trim();
-  if (configDir) candidates.push(path7.join(configDir, "oh-my-openagent.jsonc"));
-  candidates.push(path7.join(cwd, ".opencode", "oh-my-openagent.jsonc"));
-  const configHome = env.XDG_CONFIG_HOME?.trim() || path7.join(os3.homedir(), ".config");
-  candidates.push(path7.join(configHome, "opencode", "oh-my-openagent.jsonc"));
-  for (const candidate of candidates) {
-    try {
-      if (fs6.existsSync(candidate)) return candidate;
-    } catch {
-    }
-  }
-  return void 0;
-}
-function collectSectionRefs(refs, section, label) {
-  if (!isRecord7(section)) return;
-  for (const [name, entry] of Object.entries(section)) {
-    if (!isRecord7(entry)) continue;
-    pushRef(refs, entry.model, `flavour ${label} "${name}"`);
-    if (label === "agent" && isRecord7(entry.ultrawork)) {
-      pushRef(
-        refs,
-        entry.ultrawork.model,
-        `flavour ${label} "${name}" (ultrawork)`
-      );
-    }
-  }
-}
-function collectFlavourRefs(env, cwd) {
-  const flavourPath = findFlavourPath(env, cwd);
-  if (flavourPath === void 0) return [];
-  const refs = [];
-  try {
-    const parsed = parseJsonc(fs6.readFileSync(flavourPath, "utf8"));
-    if (!isRecord7(parsed)) {
-      logger.warn(
-        `flavour file ${flavourPath} did not parse to an object \u2014 skipping flavour ref validation`
-      );
-      return [];
-    }
-    collectSectionRefs(refs, parsed.agents, "agent");
-    collectSectionRefs(refs, parsed.categories, "category");
-  } catch (error) {
-    logger.warn(
-      `flavour file ${flavourPath} could not be read \u2014 skipping flavour ref validation: ${String(error)}`
-    );
-    return [];
-  }
-  return refs;
-}
-
 // src/config/describe-missing.ts
 function availableKeys(cfg, providerId) {
   return Object.keys(cfg.provider?.[providerId]?.models ?? {});
@@ -1289,8 +1377,7 @@ var REMEDIATION = [
 ].join("\n");
 function validateRefs(cfg, options = {}) {
   const env = options.env ?? process.env;
-  const cwd = options.cwd ?? process.cwd();
-  const refs = [...collectCfgRefs(cfg), ...collectFlavourRefs(env, cwd)];
+  const refs = collectCfgRefs(cfg);
   const missing = findMissingRefs(cfg, refs);
   if (missing.length === 0) return;
   const unresolved = [];
@@ -1378,6 +1465,29 @@ function createConfigHook(options = {}) {
         resolveKeyNow: () => resolveKey(void 0, env, cwd)
       });
       mergeConfig(cfg, blocks);
+      const mergeableConfig = cfg;
+      const provider = mergeableConfig.provider?.route_33;
+      if (provider !== void 0) {
+        const regeneration = regenerateModels({
+          currentModels: provider.models,
+          freshModels: blocks.route_33.models,
+          previousManifest: readGenerationManifest(cwd),
+          overrides: readModelOverrides(cwd),
+          source: catalog.source,
+          failedLiveFetch: catalog.liveFetchFailed
+        });
+        if (regeneration.skipped) {
+          logger.info("route_33: catalog fetch failed without a cache; preserving existing managed model entries");
+        } else {
+          if (regeneration.manifest !== void 0 && !writeGenerationManifest(cwd, regeneration.manifest)) {
+            mergeModels(provider, blocks.route_33);
+          } else {
+            provider.models = regeneration.models;
+          }
+          for (const key2 of regeneration.prunedKeys)
+            logger.info(`route_33: removed stale model entry '${key2}' (no longer in the gateway catalog); move custom entries to route_33 modelOverrides \u2014 see README`);
+        }
+      }
     } catch (error) {
       logger.error(
         `model discovery/injection failed unexpectedly \u2014 opencode startup continues without injected models: ${describeError(error)}`
@@ -1386,7 +1496,6 @@ function createConfigHook(options = {}) {
     try {
       validateRefs(cfg, {
         env,
-        cwd,
         keyResolved: key !== void 0,
         catalogAvailable
       });

package/docs/gateway-limits-variants-broadcast.md

@@ -1,9 +1,9 @@
-# Gateway limits and variants broadcast proposal
+# Gateway model metadata broadcast
 
 **To:** R33 gateway team  
 **From:** opencode-route33 plugin maintainers  
 **Date:** 2026-08-10  
-**Subject:** Embedding per-model limits and variants in `GET /v1/models`
+**Subject:** Shipped per-model metadata in `GET /v1/models`
 
 ## Problem
 
@@ -19,10 +19,12 @@ This creates three gaps:
 
 ## Recommendation
 
-Extend each entry of the existing `GET /v1/models` response with two new optional fields:
+**Status: shipped.** Each entry of the existing `GET /v1/models` response supports these optional metadata fields:
 
 - `limits`: `{ "context": number, "output": number }`, present only when both values are positive integers.
 - `variants`: `Record<string, Record<string, unknown>>`, passed through verbatim from the platform's curated catalog.
+- `modalities`: `{ "input": ["text"|"audio"|"image"|"video"|"pdf"], "output": ["text"|"audio"|"image"|"video"|"pdf"] }`.
+- `attachment`: boolean, derived by the gateway as true when `modalities.input` contains `image` or `pdf`.
 
 Existing unchanged fields (`id`, `object`, `created`, `owned_by`, plus optional `display_name`, `pricing`, `capabilities`, and `endpoints`) remain unchanged. Extra JSON fields still do not break OpenAI-compatible clients, so the catalog stays one round trip and atomically consistent.
 
@@ -61,7 +63,9 @@ Existing unchanged fields (`id`, `object`, `created`, `owned_by`, plus optional
         "max": {
           "reasoningEffort": "max"
         }
-      }
+      },
+      "modalities": { "input": ["text", "image"], "output": ["text"] },
+      "attachment": true
     }
   ]
 }
@@ -89,6 +93,10 @@ Existing unchanged fields (`id`, `object`, `created`, `owned_by`, plus optional
 | `limits.context` | positive integer | Maximum context-window tokens |
 | `limits.output` | positive integer | Maximum completion tokens |
 | `variants` | object or omitted | Per-model parameter variants, a record of records |
+| `modalities` | object or omitted | Exact supported input and output media types |
+| `modalities.input` | array | Zero or more of `text`, `audio`, `image`, `video`, `pdf` |
+| `modalities.output` | array | Zero or more of `text`, `audio`, `image`, `video`, `pdf` |
+| `attachment` | boolean or omitted | Gateway-derived file/image support (`input` includes `image` or `pdf`) |
 
 ### Consumer parse rules
 
@@ -98,6 +106,9 @@ The opencode-route33 plugin consumes this shape with the following rules:
 - `capabilities.reasoning` with the boolean value `true` maps to opencode's `reasoning` flag. Any non-boolean value is skipped.
 - `capabilities.tool_support` with the boolean value `true` maps to opencode's `tool_call` flag. Any non-boolean value is skipped.
 - `variants` is accepted only when it is a `Record<string, Record<string, unknown>>` and is passed through verbatim. Malformed variants are skipped.
+- `modalities` is accepted only as an object with array `input` and `output` fields. Consumers drop unrecognized modality values; malformed modality shapes are omitted for that one model.
+- `attachment` is accepted only when boolean; a non-boolean value is omitted for that one model.
+- `capabilities.modality` is legacy qualitative metadata. `modalities` is the authoritative exact media contract.
 - Unknown or malformed fields are ignored. Parsing is never fatal.
 
 ### Why embed limits and variants on `/v1/models`
@@ -129,3 +140,7 @@ It should return the same per-model fields and types documented above (`id`, `ob
 ## Secondary option (later)
 
 Publish route33 limit and variant metadata on models.dev via a community TOML PR. This is useful for non-gateway consumers, but it does not solve the key-scoped freshness problem or the single-round-trip goal. Recommended as a follow-up, not a substitute.
+
+## Future direction
+
+Broadcasting `reasoning_options` is deferred. The current shipped contract intentionally limits itself to limits, variants, modalities, attachment, pricing, and capabilities.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@route_33/opencode",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
   "description": "opencode provider plugin for the route33.ai AI gateway — key-scoped model discovery, cost/limit enrichment, auth, and the key-setup wizard.",
@@ -40,9 +40,6 @@
   "peerDependencies": {
     "@opencode-ai/plugin": ">=1.17.0 <2.0.0"
   },
-  "dependencies": {
-    "jsonc-parser": "^3.3.1"
-  },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.17.12",
     "@types/node": "^22.10.7",