oc-blackbytes 0.2.0 → 0.4.0

package/README.md

@@ -4,17 +4,20 @@ An OpenCode plugin for workflow automation. It provisions built-in MCP servers,
 
 ## What the plugin provides
 
-The plugin wires four OpenCode hook surfaces:
+The plugin wires five OpenCode hook surfaces:
 
 - `config` — merges built-in MCP servers and agents into the active OpenCode config
 - `chat.headers` — injects `x-initiator: agent` for supported GitHub Copilot providers
 - `tool` — registers bundled local tools for structured editing and codebase search
 - `tool.execute.after` — post-processes `read`/`write` output when hashline editing is enabled
+- `chat.params` — adapts model parameters at runtime based on actual model family and agent role
 
 ## Features
 
 - **Built-in MCP provisioning** — configures `websearch`, `context7`, and `grep_app`
 - **Agent installation** — provides `bytes` as the default primary agent plus `explore`, `oracle`, `librarian`, and `general`
+- **Per-agent model configuration** — each agent can target a specific model with tailored reasoning effort, temperature, and fallback chains via the `agents` config field
+- **Runtime model parameter adaptation** — the `chat.params` hook detects the actual model family at inference time and applies provider-correct parameters (Claude thinking, OpenAI reasoning effort) while stripping incompatible options
 - **Local tool registration** — exposes `hashline_edit`, `ast_grep_search`, `ast_grep_replace`, `grep`, and `glob`
 - **Hashline editing workflow** — transforms `read` output into `LINE#ID` anchors and turns successful `write` output into concise line-count summaries
 - **Config merging pipeline** — merges built-in MCPs and agents with user-defined config while preserving explicit user disables
@@ -59,7 +62,7 @@ opencode debug config
 
 ## Configuration
 
-Create `oc-blackbytes.jsonc` in the OpenCode config directory.
+Create `oc-blackbytes.jsonc` in the OpenCode config directory. For the full configuration guide with recommended models per agent and example setups, see [docs/configuration.md](docs/configuration.md).
 
 ```jsonc
 {
@@ -73,6 +76,13 @@ Create `oc-blackbytes.jsonc` in the OpenCode config directory.
 
   "websearch": {
     "provider": "exa"
+  },
+
+  "agents": {
+    "oracle": { "model": "openai/gpt-5.4", "reasoningEffort": "high" },
+    "explore": { "model": "google/gemini-3-flash", "temperature": 0.1 },
+    "librarian": { "model": "minimax/minimax-m2.7" },
+    "general": { "model": "anthropic/claude-sonnet-4-6" }
   }
 }
 ```
@@ -87,9 +97,11 @@ Create `oc-blackbytes.jsonc` in the OpenCode config directory.
 | `disabled_tools` | `string[]` | `[]` | Prevents bundled tools from being registered. |
 | `mcp_env_alllowlist` | `string[]` | `[]` | Recognized by the schema for MCP environment filtering workflows. |
 | `hashline_edit` | `boolean` | `true` | Enables the `hashline_edit` tool and `tool.execute.after` hashline post-processing for `read`/`write`. |
-| `model_fallback` | `boolean` | `false` | Recognized by the schema for model compatibility workflows. |
+| `model_fallback` | `boolean` | `false` | Enables model fallback resolution: discovers connected providers at init and resolves fallback chains when a preferred model's provider is unavailable. |
 | `auto_update` | `boolean` | `false` | Recognized by the schema for maintenance workflows. |
 | `websearch.provider` | `"exa" \| "tavily"` | `"exa"` | Selects the built-in `websearch` MCP backend. |
+| `agents` | `Record<string, AgentModelConfig>` | `{}` | Per-agent model configuration overrides. See [Per-agent model configuration](#per-agent-model-configuration). |
+| `fallback_models` | `string \| (string \| FallbackModelObject)[]` | — | Global fallback model chain. When `model_fallback: true` and an agent's primary model is unavailable, the plugin walks this chain and uses the first model whose provider is connected. |
 | `_migrations` | `string[]` | `[]` | Internal migration bookkeeping. |
 
 ## Built-in agents
@@ -106,6 +118,54 @@ The plugin merges these agents into the OpenCode config and sets `default_agent`
 
 The merge behavior also preserves explicit user disables (`disable: true`), removes entries listed in `disabled_agents`, uses the OpenCode `permission` map format, and marks OpenCode's default `build` and `plan` agents as disabled unless the user configures them directly.
 
+### Per-agent model configuration
+
+The `agents` field accepts a record of agent names to model configuration objects:
+
+```jsonc
+{
+  "agents": {
+    "oracle": {
+      "model": "openai/gpt-5.4",
+      "reasoningEffort": "high"
+    },
+    "explore": {
+      "model": "google/gemini-3-flash",
+      "temperature": 0.1
+    },
+    "librarian": {
+      "model": "minimax/minimax-m2.7"
+    },
+    "general": {
+      "model": "anthropic/claude-sonnet-4-6"
+    }
+  }
+}
+```
+
+Each agent model config supports:
+
+| Field | Type | Description |
+|---|---|---|
+| `model` | `string` | Model identifier (e.g., `"openai/gpt-5.4"`). Drives prompt variant selection and, for subagents, sets the model hint. |
+| `reasoningEffort` | `string` | Override reasoning effort level for OpenAI reasoning models (`"low"`, `"medium"`, `"high"`). |
+| `temperature` | `number` | Override temperature for the agent. |
+| `fallback_models` | `string \| (string \| object)[]` | Per-agent fallback chain — tried before the global `fallback_models` when the primary model's provider is unavailable. Requires `model_fallback: true`. |
+
+When a `model` is specified for a subagent, the factory selects the appropriate prompt variant for that model family (Claude, GPT, or Gemini). The primary agent (`bytes`) uses the model hint for prompt selection only — the actual model is determined by the OpenCode UI selection. For recommended models per agent, see [docs/configuration.md](docs/configuration.md).
+
+## Runtime model parameter adaptation
+
+The `chat.params` hook fires on every LLM call and applies provider-correct parameters based on the actual runtime model:
+
+| Model Family | Behavior |
+|---|---|
+| **Claude** (Anthropic) | Applies extended thinking with per-agent budget tokens (bytes: 32K, oracle: 32K, general: 16K) when the model supports reasoning. Strips `reasoningEffort` and `textVerbosity`. |
+| **GPT** (OpenAI) | Applies `reasoningEffort` per agent (oracle: `"high"`, bytes/general: `"medium"`) when the model supports reasoning. Strips `thinking`. |
+| **Gemini / Other** | Strips all provider-specific options (`thinking`, `reasoningEffort`, `textVerbosity`). |
+
+User overrides from the `agents` config take priority over these defaults. Agents without thinking defaults (`explore`, `librarian`) skip reasoning configuration for speed and cost efficiency.
+
 ## Built-in MCP servers
 
 | Server | Auth | Behavior |
@@ -235,9 +295,9 @@ For CLI usage, `OPENCODE_CONFIG_DIR` overrides the default OpenCode config direc
 oc-blackbytes/
 ├── src/
 │   ├── index.ts                    # Plugin entry
-│   ├── bootstrap.ts                # Hook assembly
-│   ├── config/                     # JSONC config loading + Zod schemas
-│   ├── handlers/                   # Hook handlers for config, tools, chat headers, and post-processing
+│   ├── bootstrap.ts                # Hook assembly (config, chat.headers, chat.params, tool, tool.execute.after)
+│   ├── config/                     # JSONC config loading + Zod schemas (including per-agent model config)
+│   ├── handlers/                   # Hook handlers for config, tools, chat headers, chat params, and post-processing
 │   ├── extensions/
 │   │   ├── agents/                 # bytes/explore/oracle/librarian/general agent definitions
 │   │   ├── hooks/                  # Hook-related extension helpers
@@ -247,9 +307,10 @@ oc-blackbytes/
 │   ├── shared/                     # Logger, constants, config path resolution, JSONC utils
 │   ├── compat/                     # Compatibility integrations
 │   ├── integrations/               # Additional runtime integrations
-│   ├── services/                   # Reserved service modules
+│   ├── services/                   # Model fallback resolution (provider discovery, fallback chains)
 │   └── stores/                     # Reserved state stores
 ├── docs/
+│   ├── configuration.md
 │   └── debugging.md
 ├── test/
 │   └── config.test.ts

package/dist/index.js

@@ -1028,6 +1028,15 @@ function isGptModel(model) {
   return modelName.includes("gpt");
 }
 var GEMINI_PROVIDERS = ["google/", "google-vertex/"];
+var CLAUDE_PROVIDERS = ["anthropic/"];
+function isClaudeModel(model) {
+  if (CLAUDE_PROVIDERS.some((prefix) => model.startsWith(prefix)))
+    return true;
+  if (model.startsWith("github-copilot/") && extractModelName(model).toLowerCase().startsWith("claude"))
+    return true;
+  const modelName = extractModelName(model).toLowerCase();
+  return modelName.startsWith("claude-");
+}
 function isGeminiModel(model) {
   if (GEMINI_PROVIDERS.some((prefix) => model.startsWith(prefix)))
     return true;
@@ -1042,6 +1051,88 @@ function createAgentToolRestrictions(denyTools) {
     permission: Object.fromEntries(denyTools.map((tool) => [tool, "deny"]))
   };
 }
+// src/handlers/chat-params-handler.ts
+var CLAUDE_THINKING_DEFAULTS = {
+  bytes: { type: "enabled", budgetTokens: 32000 },
+  oracle: { type: "enabled", budgetTokens: 32000 },
+  general: { type: "enabled", budgetTokens: 16000 }
+};
+var OPENAI_REASONING_DEFAULTS = {
+  bytes: "medium",
+  oracle: "high",
+  general: "medium"
+};
+function detectModelFamily(providerID, modelRef) {
+  if (providerID === "anthropic")
+    return "claude";
+  if (providerID === "openai")
+    return "openai";
+  if (providerID === "google" || providerID === "google-vertex")
+    return "gemini";
+  if (isClaudeModel(modelRef))
+    return "claude";
+  if (isGptModel(modelRef))
+    return "openai";
+  if (isGeminiModel(modelRef))
+    return "gemini";
+  return "other";
+}
+function applyClaude(agentName, supportsReasoning, options) {
+  if (supportsReasoning) {
+    const defaults = CLAUDE_THINKING_DEFAULTS[agentName];
+    if (defaults) {
+      options.thinking = { ...defaults };
+    }
+  }
+  delete options.reasoningEffort;
+  delete options.textVerbosity;
+}
+function applyOpenAI(agentName, supportsReasoning, userReasoningEffort, options) {
+  if (supportsReasoning) {
+    const effort = userReasoningEffort ?? OPENAI_REASONING_DEFAULTS[agentName];
+    if (effort) {
+      options.reasoningEffort = effort;
+    }
+  }
+  delete options.thinking;
+}
+function stripProviderOptions(options) {
+  delete options.thinking;
+  delete options.reasoningEffort;
+  delete options.textVerbosity;
+}
+function handleChatParams(pluginConfig) {
+  return {
+    "chat.params": async (input, output) => {
+      const agentName = input.agent;
+      const model2 = input.model;
+      const providerID = model2.providerID;
+      const modelID = model2.id;
+      const modelRef = providerID ? `${providerID}/${modelID}` : modelID;
+      const family = detectModelFamily(providerID, modelRef);
+      const agentOverride = pluginConfig.agents?.[agentName];
+      const supportsReasoning = model2.capabilities?.reasoning ?? false;
+      log(`[chat.params] agent=${agentName} model=${modelRef} family=${family} reasoning=${supportsReasoning}`);
+      switch (family) {
+        case "claude": {
+          applyClaude(agentName, supportsReasoning, output.options);
+          break;
+        }
+        case "openai": {
+          applyOpenAI(agentName, supportsReasoning, agentOverride?.reasoningEffort, output.options);
+          break;
+        }
+        default: {
+          stripProviderOptions(output.options);
+          break;
+        }
+      }
+      if (agentOverride?.temperature !== undefined) {
+        output.temperature = agentOverride.temperature;
+      }
+    }
+  };
+}
 // src/extensions/agents/bytes/agent.ts
 var BYTES_DESCRIPTION = "Primary coding agent. Handles end-to-end software engineering: planning, implementation, debugging, refactoring, and code review. Delegates to specialized subagents (Oracle, Explore, Librarian, General) when elevated reasoning, broad search, multi-repo context, or heavy implementation is needed.";
 var SHARED_SECTIONS = {
@@ -2196,18 +2287,229 @@ function createOracleAgent(model2) {
 }
 createOracleAgent.mode = MODE5;
 
+// src/services/model-requirements.ts
+var BUILTIN_FALLBACK_CHAINS = {
+  oracle: [
+    { model: "gpt-5.4", providers: ["openai", "github-copilot"], reasoningEffort: "high" },
+    { model: "gemini-3.1-pro", providers: ["google"] },
+    { model: "claude-opus-4-6", providers: ["anthropic", "github-copilot"] }
+  ],
+  explore: [
+    { model: "gemini-3-flash", providers: ["google"], temperature: 0.1 },
+    { model: "claude-haiku-4-5", providers: ["anthropic", "github-copilot"], temperature: 0.1 },
+    { model: "gpt-5-nano", providers: ["openai", "github-copilot"], temperature: 0.1 },
+    { model: "minimax-m2.7", providers: ["minimax"], temperature: 0.1 }
+  ],
+  librarian: [
+    { model: "claude-haiku-4-5", providers: ["anthropic", "github-copilot"], temperature: 0.2 },
+    { model: "gemini-3-flash", providers: ["google"], temperature: 0.2 },
+    { model: "gpt-5-nano", providers: ["openai", "github-copilot"], temperature: 0.2 }
+  ],
+  general: [
+    { model: "claude-sonnet-4-6", providers: ["anthropic", "github-copilot"] },
+    { model: "kimi-k2.5", providers: ["kimi"] },
+    { model: "gpt-5.4-mini", providers: ["openai", "github-copilot"] },
+    { model: "gemini-3.1-pro", providers: ["google"] }
+  ]
+};
+// src/services/model-resolver.ts
+async function discoverAvailableModels(client) {
+  try {
+    const result = await client.provider.list();
+    const data = result.data;
+    if (!data) {
+      log("[model-resolver] Provider list returned no data, skipping fallback resolution");
+      return new Map;
+    }
+    const connected = new Set(data.connected);
+    const models = new Map;
+    for (const provider of data.all ?? []) {
+      if (!connected.has(provider.id))
+        continue;
+      const modelIds = new Set(Object.keys(provider.models ?? {}));
+      if (modelIds.size > 0) {
+        models.set(provider.id, modelIds);
+      }
+    }
+    const providerSummary = [...models.entries()].map(([id, m]) => `${id}(${m.size})`).join(", ");
+    log(`[model-resolver] Available: ${providerSummary || "(none)"}`);
+    return models;
+  } catch (e) {
+    log(`[model-resolver] Failed to discover providers: ${e}`);
+    return new Map;
+  }
+}
+function isModelAvailable(modelRef, availableModels) {
+  if (availableModels.size === 0)
+    return true;
+  const slashIdx = modelRef.indexOf("/");
+  if (slashIdx === -1)
+    return true;
+  const providerId = modelRef.substring(0, slashIdx);
+  return availableModels.has(providerId);
+}
+function prefixMatchModel(modelPrefix, providerModels) {
+  if (providerModels.has(modelPrefix))
+    return modelPrefix;
+  let bestMatch;
+  for (const available of providerModels) {
+    if (available.startsWith(modelPrefix)) {
+      const rest = available.substring(modelPrefix.length);
+      if (rest === "" || /^-\d/.test(rest)) {
+        if (!bestMatch || available.length < bestMatch.length) {
+          bestMatch = available;
+        }
+      }
+    }
+  }
+  return bestMatch;
+}
+function resolveChainEntry(entry, availableModels) {
+  for (const provider of entry.providers) {
+    const providerModels = availableModels.get(provider);
+    if (!providerModels)
+      continue;
+    const matched = prefixMatchModel(entry.model, providerModels);
+    if (matched) {
+      return {
+        model: `${provider}/${matched}`,
+        fromFallback: true,
+        reasoningEffort: entry.reasoningEffort,
+        temperature: entry.temperature
+      };
+    }
+  }
+  return;
+}
+function walkFallbackChain(fallbacks, availableModels) {
+  if (!fallbacks)
+    return;
+  const chain = typeof fallbacks === "string" ? [fallbacks] : fallbacks;
+  for (const entry of chain) {
+    const modelRef = typeof entry === "string" ? entry : entry.model;
+    if (isModelAvailable(modelRef, availableModels)) {
+      return typeof entry === "string" ? { model: entry, fromFallback: true } : {
+        model: entry.model,
+        fromFallback: true,
+        reasoningEffort: entry.reasoningEffort,
+        temperature: entry.temperature
+      };
+    }
+  }
+  return;
+}
+function walkBuiltinChain(agentName, availableModels) {
+  const chain = BUILTIN_FALLBACK_CHAINS[agentName];
+  if (!chain)
+    return;
+  for (const entry of chain) {
+    const resolved = resolveChainEntry(entry, availableModels);
+    if (resolved)
+      return resolved;
+  }
+  return;
+}
+function resolveAgentModel(agentName, agentConfig, globalFallbacks, availableModels) {
+  const primaryModel = agentConfig?.model;
+  if (!primaryModel) {
+    const perAgentResolved2 = walkFallbackChain(agentConfig?.fallback_models, availableModels);
+    if (perAgentResolved2) {
+      log(`  [model-resolver] ${agentName}: resolved \u2192 ${perAgentResolved2.model} (agent fallback)`);
+      return perAgentResolved2;
+    }
+    const builtinResolved2 = walkBuiltinChain(agentName, availableModels);
+    if (builtinResolved2) {
+      log(`  [model-resolver] ${agentName}: resolved \u2192 ${builtinResolved2.model} (builtin chain)`);
+      return builtinResolved2;
+    }
+    const globalResolved2 = walkFallbackChain(globalFallbacks, availableModels);
+    if (globalResolved2) {
+      log(`  [model-resolver] ${agentName}: resolved \u2192 ${globalResolved2.model} (global fallback)`);
+      return globalResolved2;
+    }
+    return { model: "", fromFallback: false };
+  }
+  if (isModelAvailable(primaryModel, availableModels)) {
+    log(`  [model-resolver] ${agentName}: using primary model ${primaryModel}`);
+    return { model: primaryModel, fromFallback: false };
+  }
+  log(`  [model-resolver] ${agentName}: primary model ${primaryModel} not available, trying fallbacks...`);
+  const perAgentResolved = walkFallbackChain(agentConfig?.fallback_models, availableModels);
+  if (perAgentResolved) {
+    log(`  [model-resolver] ${agentName}: resolved \u2192 ${perAgentResolved.model} (agent fallback)`);
+    return perAgentResolved;
+  }
+  const builtinResolved = walkBuiltinChain(agentName, availableModels);
+  if (builtinResolved) {
+    log(`  [model-resolver] ${agentName}: resolved \u2192 ${builtinResolved.model} (builtin chain)`);
+    return builtinResolved;
+  }
+  const globalResolved = walkFallbackChain(globalFallbacks, availableModels);
+  if (globalResolved) {
+    log(`  [model-resolver] ${agentName}: resolved \u2192 ${globalResolved.model} (global fallback)`);
+    return globalResolved;
+  }
+  log(`  [model-resolver] ${agentName}: no available fallback, using OpenCode default`);
+  return { model: "", fromFallback: false };
+}
+function resolveAllAgentModels(pluginConfig, availableModels) {
+  const agentOverrides = pluginConfig.agents;
+  const globalFallbacks = pluginConfig.fallback_models;
+  const agentNames = new Set([
+    ...Object.keys(BUILTIN_FALLBACK_CHAINS),
+    ...agentOverrides ? Object.keys(agentOverrides) : []
+  ]);
+  if (agentNames.size === 0)
+    return;
+  const resolved = {};
+  log("[model-resolver] Resolving agent models with fallback chains...");
+  for (const name of agentNames) {
+    const config = agentOverrides?.[name];
+    const resolution = resolveAgentModel(name, config, globalFallbacks, availableModels);
+    resolved[name] = {
+      ...config,
+      model: resolution.model || undefined,
+      ...resolution.fromFallback && resolution.reasoningEffort !== undefined && config?.reasoningEffort === undefined ? { reasoningEffort: resolution.reasoningEffort } : {},
+      ...resolution.fromFallback && resolution.temperature !== undefined && config?.temperature === undefined ? { temperature: resolution.temperature } : {}
+    };
+  }
+  return resolved;
+}
 // src/handlers/config-handler/agent-config-handler.ts
 var DEFAULT_AGENT_NAME = "bytes";
 var SUPERSEDED_AGENTS = ["build", "plan"];
-function createBuiltinAgents() {
-  const defaultModelHint = "";
-  return {
-    bytes: createBytesAgent(defaultModelHint),
-    explore: createExploreAgent(defaultModelHint),
-    oracle: createOracleAgent(defaultModelHint),
-    librarian: createLibrarianAgent(defaultModelHint),
-    general: createGeneralAgent(defaultModelHint)
-  };
+var BUILTIN_AGENT_FACTORIES = {
+  bytes: createBytesAgent,
+  explore: createExploreAgent,
+  oracle: createOracleAgent,
+  librarian: createLibrarianAgent,
+  general: createGeneralAgent
+};
+function createBuiltinAgents(agentOverrides) {
+  const agents = {};
+  for (const [name, factory] of Object.entries(BUILTIN_AGENT_FACTORIES)) {
+    const modelHint = agentOverrides?.[name]?.model ?? "";
+    agents[name] = factory(modelHint);
+  }
+  if (agentOverrides) {
+    applyAgentModelOverrides(agents, agentOverrides);
+  }
+  return agents;
+}
+function applyAgentModelOverrides(agents, overrides) {
+  for (const [name, override] of Object.entries(overrides)) {
+    if (!(name in agents))
+      continue;
+    const agent = agents[name];
+    if (override.reasoningEffort !== undefined) {
+      agent.reasoningEffort = override.reasoningEffort;
+      log(`  Agent '${name}': reasoningEffort \u2192 ${override.reasoningEffort}`);
+    }
+    if (override.temperature !== undefined) {
+      agent.temperature = override.temperature;
+      log(`  Agent '${name}': temperature \u2192 ${override.temperature}`);
+    }
+  }
 }
 function isDisabledAgentEntry(value) {
   return typeof value === "object" && value !== null && "disable" in value && value.disable === true;
@@ -2249,7 +2551,8 @@ function handleAgentConfig(ctx) {
   const { disabled_agents: pluginDisabledAgents = [] } = ctx.pluginConfig;
   const userAgents = ctx.config.agent;
   const userDisabledAgentNames = captureUserDisabledAgents(userAgents);
-  const builtinAgents = createBuiltinAgents();
+  const effectiveOverrides = ctx.availableModels.size > 0 ? resolveAllAgentModels(ctx.pluginConfig, ctx.availableModels) ?? ctx.pluginConfig.agents : ctx.pluginConfig.agents;
+  const builtinAgents = createBuiltinAgents(effectiveOverrides);
   const merged = {
     ...builtinAgents
   };
@@ -2397,10 +2700,10 @@ function handleMcpConfig(ctx) {
 }
 
 // src/handlers/config-handler/index.ts
-function handleConfig(pluginConfig) {
+function handleConfig(pluginConfig, availableModels) {
   return {
     config: async (config) => {
-      const configCtx = { config, pluginConfig };
+      const configCtx = { config, pluginConfig, availableModels };
       handleMcpConfig(configCtx);
       handleAgentConfig(configCtx);
     }
@@ -17520,11 +17823,13 @@ function handleTools(pluginConfig, ctx) {
 // src/bootstrap.ts
 async function createOpenCodePlugin({
   input,
-  pluginConfig
+  pluginConfig,
+  availableModels
 }) {
   return {
-    ...handleConfig(pluginConfig),
+    ...handleConfig(pluginConfig, availableModels),
     ...handleChatHeaders(pluginConfig),
+    ...handleChatParams(pluginConfig),
     tool: handleTools(pluginConfig, input),
     "tool.execute.after": handleToolExecuteAfter(pluginConfig)
   };
@@ -31078,6 +31383,21 @@ var WebsearchConfigSchema = zod_default.object({
 });
 
 // src/config/schema/oc-blackbytes-config.ts
+var FallbackModelObjectSchema = zod_default.object({
+  model: zod_default.string(),
+  reasoningEffort: zod_default.string().optional(),
+  temperature: zod_default.number().optional()
+});
+var FallbackModelsSchema = zod_default.union([
+  zod_default.string(),
+  zod_default.array(zod_default.union([zod_default.string(), FallbackModelObjectSchema]))
+]);
+var AgentModelConfigSchema = zod_default.object({
+  model: zod_default.string().optional(),
+  reasoningEffort: zod_default.string().optional(),
+  temperature: zod_default.number().optional(),
+  fallback_models: FallbackModelsSchema.optional()
+});
 var OcBlackbytesConfigSchema = zod_default.object({
   $schema: zod_default.string().optional(),
   disabled_mcps: zod_default.array(AnyMcpNameSchema).optional(),
@@ -31089,6 +31409,8 @@ var OcBlackbytesConfigSchema = zod_default.object({
   model_fallback: zod_default.boolean().optional(),
   auto_update: zod_default.boolean().optional(),
   websearch: WebsearchConfigSchema.optional(),
+  agents: zod_default.record(zod_default.string(), AgentModelConfigSchema).optional(),
+  fallback_models: FallbackModelsSchema.optional(),
   _migrations: zod_default.array(zod_default.string()).optional()
 });
 // src/config/loader.ts
@@ -31118,7 +31440,8 @@ function loadPluginConfig(_input) {
 // src/index.ts
 var BlackbytesPlugin = async (ctx) => {
   const pluginConfig = loadPluginConfig(ctx);
-  return createOpenCodePlugin({ input: ctx, pluginConfig });
+  const availableModels = pluginConfig.model_fallback ? await discoverAvailableModels(ctx.client) : new Map;
+  return createOpenCodePlugin({ input: ctx, pluginConfig, availableModels });
 };
 var src_default = BlackbytesPlugin;
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oc-blackbytes",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "An OpenCode plugin tailored to streamline my everyday workflow.",
   "type": "module",
   "main": "./dist/index.js",