oc-blackbytes 0.2.0 → 0.3.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
@@ -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" }
   }
 }
 ```
@@ -90,6 +100,8 @@ Create `oc-blackbytes.jsonc` in the OpenCode config directory.
 | `model_fallback` | `boolean` | `false` | Recognized by the schema for model compatibility workflows. |
 | `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 (reserved for future use). |
 | `_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 (reserved for future use). |
+
+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.
+
+## 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

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 = {
@@ -2199,15 +2290,38 @@ createOracleAgent.mode = MODE5;
 // 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 +2363,7 @@ function handleAgentConfig(ctx) {
   const { disabled_agents: pluginDisabledAgents = [] } = ctx.pluginConfig;
   const userAgents = ctx.config.agent;
   const userDisabledAgentNames = captureUserDisabledAgents(userAgents);
-  const builtinAgents = createBuiltinAgents();
+  const builtinAgents = createBuiltinAgents(ctx.pluginConfig.agents);
   const merged = {
     ...builtinAgents
   };
@@ -17525,6 +17639,7 @@ async function createOpenCodePlugin({
   return {
     ...handleConfig(pluginConfig),
     ...handleChatHeaders(pluginConfig),
+    ...handleChatParams(pluginConfig),
     tool: handleTools(pluginConfig, input),
     "tool.execute.after": handleToolExecuteAfter(pluginConfig)
   };
@@ -31078,6 +31193,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 +31219,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

package/package.json

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