oh-my-claudecode-opencode 0.6.3 → 0.6.4

package/dist/index.js

@@ -21669,7 +21669,7 @@ function generateTaskId() {
   taskCounter++;
   return `bg_${Date.now().toString(36)}_${taskCounter.toString(36)}`;
 }
-function createBackgroundManager(ctx, config2) {
+function createBackgroundManager(ctx, config2, modelService) {
   const tasks = new Map;
   const defaultConcurrency = config2?.defaultConcurrency ?? 5;
   const modelCache = new Map;
@@ -21726,7 +21726,14 @@ function createBackgroundManager(ctx, config2) {
     };
     tasks.set(taskId, task);
     log(`Background task created`, { taskId, description, agent });
-    const resolvedModel = model || await getParentSessionModel(parentSessionID);
+    const parentModel = model || await getParentSessionModel(parentSessionID);
+    const resolvedModel = modelService ? modelService.resolveModelForAgent(agent, parentModel) : parentModel;
+    if (resolvedModel && resolvedModel !== parentModel) {
+      log(`[background-manager] Using tier-mapped model for ${agent}`, {
+        providerID: resolvedModel.providerID,
+        modelID: resolvedModel.modelID
+      });
+    }
     (async () => {
       try {
         const sessionResp = await ctx.client.session.create({
@@ -34256,7 +34263,7 @@ Use \`background_output\` to get results. Prompts MUST be in English.`,
 }
 
 // src/tools/call-omco-agent.ts
-function createCallOmcoAgent(ctx, manager) {
+function createCallOmcoAgent(ctx, manager, modelService) {
   const agentNames = listAgentNames();
   const agentList = agentNames.map((name) => {
     const agent = getAgent(name);
@@ -34293,8 +34300,15 @@ Prompts MUST be in English. Use \`background_output\` for async results.`,
 
 ${prompt}`;
       const parentModel = await manager.getParentSessionModel(context.sessionID);
+      const resolvedModel = modelService ? modelService.resolveModelForAgent(subagent_type, parentModel) : parentModel;
+      if (resolvedModel && resolvedModel !== parentModel) {
+        log(`[call-omco-agent] Using tier-mapped model for ${subagent_type}`, {
+          providerID: resolvedModel.providerID,
+          modelID: resolvedModel.modelID
+        });
+      }
       if (run_in_background) {
-        const task = await manager.createTask(context.sessionID, description, enhancedPrompt, subagent_type, parentModel);
+        const task = await manager.createTask(context.sessionID, description, enhancedPrompt, subagent_type, resolvedModel);
         return JSON.stringify({
           task_id: task.id,
           session_id: task.sessionID,
@@ -34316,9 +34330,9 @@ ${prompt}`;
         const promptBody = {
           parts: [{ type: "text", text: enhancedPrompt }]
         };
-        if (parentModel) {
-          promptBody.model = parentModel;
-          log(`Using parent model for sync agent call`, { subagent_type, ...parentModel });
+        if (resolvedModel) {
+          promptBody.model = resolvedModel;
+          log(`Using resolved model for sync agent call`, { subagent_type, ...resolvedModel });
         }
         const promptResp = await ctx.client.session.prompt({
           path: { id: sessionID },
@@ -34438,6 +34452,51 @@ class ModelResolver {
   }
 }
 
+// src/tools/model-resolution-service.ts
+function parseModelString(model) {
+  if (!model.includes("/")) {
+    return;
+  }
+  const [providerID, ...rest] = model.split("/");
+  const modelID = rest.join("/");
+  if (!providerID || !modelID) {
+    return;
+  }
+  return { providerID, modelID };
+}
+function createModelResolutionService(modelMappingConfig, agentOverrides) {
+  const resolver = new ModelResolver(modelMappingConfig);
+  const debugLogging = modelMappingConfig?.debugLogging ?? false;
+  const tierDefaults = resolver.getTierDefaults();
+  const hasConfiguredTiers = Object.values(tierDefaults).some((m) => m.includes("/"));
+  const resolveModelForAgent = (agentName, fallbackModel) => {
+    const agentDef = getAgent(agentName);
+    const agentTier = agentDef?.model;
+    const agentOverride = agentOverrides?.[agentName];
+    const resolution = resolver.resolve(agentName, agentTier, agentOverride);
+    const modelConfig = parseModelString(resolution.model);
+    if (modelConfig) {
+      if (debugLogging) {
+        log(`[model-resolution] Resolved ${agentName}: ${resolution.model} (source: ${resolution.source})`);
+      }
+      return modelConfig;
+    }
+    if (debugLogging) {
+      log(`[model-resolution] ${agentName}: No provider mapping for "${resolution.model}", using fallback`, {
+        fallback: fallbackModel ? `${fallbackModel.providerID}/${fallbackModel.modelID}` : "none"
+      });
+    }
+    return fallbackModel;
+  };
+  const isTierMappingConfigured = () => {
+    return hasConfiguredTiers;
+  };
+  return {
+    resolveModelForAgent,
+    isTierMappingConfigured
+  };
+}
+
 // src/skills/index.ts
 import { join as join4, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -38323,9 +38382,13 @@ function resumeSession(sessionId) {
 var OmoOmcsPlugin = async (ctx) => {
   const pluginConfig = loadConfig(ctx.directory);
   console.log("[omco] Config loaded:", pluginConfig);
-  const backgroundManager = createBackgroundManager(ctx, pluginConfig.background_task);
+  const modelService = createModelResolutionService(pluginConfig.model_mapping, pluginConfig.agents);
+  if (modelService.isTierMappingConfigured()) {
+    log("[omco] Model tier mapping configured - agents will use tier-specific models");
+  }
+  const backgroundManager = createBackgroundManager(ctx, pluginConfig.background_task, modelService);
   const backgroundTools = createBackgroundTools(backgroundManager, ctx.client);
-  const callOmcoAgent = createCallOmcoAgent(ctx, backgroundManager);
+  const callOmcoAgent = createCallOmcoAgent(ctx, backgroundManager, modelService);
   const systemPromptInjector = createSystemPromptInjector(ctx);
   const skillInjector = createSkillInjector(ctx);
   const ralphLoop = createRalphLoopHook(ctx, {

package/dist/tools/background-manager.d.ts

@@ -1,5 +1,6 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { BackgroundTaskConfig } from "../config";
+import type { ModelResolutionService } from "./model-resolution-service";
 export interface BackgroundTask {
     id: string;
     status: "running" | "completed" | "failed" | "cancelled";
@@ -24,4 +25,4 @@ export interface BackgroundManager {
     waitForTask: (taskId: string, timeoutMs?: number) => Promise<BackgroundTask>;
     getParentSessionModel: (parentSessionID: string) => Promise<ModelConfig | undefined>;
 }
-export declare function createBackgroundManager(ctx: PluginInput, config?: BackgroundTaskConfig): BackgroundManager;
+export declare function createBackgroundManager(ctx: PluginInput, config?: BackgroundTaskConfig, modelService?: ModelResolutionService): BackgroundManager;

package/dist/tools/call-omco-agent.d.ts

@@ -1,3 +1,4 @@
 import { type PluginInput, type ToolDefinition } from "@opencode-ai/plugin";
 import type { BackgroundManager } from "./background-manager";
-export declare function createCallOmcoAgent(ctx: PluginInput, manager: BackgroundManager): ToolDefinition;
+import type { ModelResolutionService } from "./model-resolution-service";
+export declare function createCallOmcoAgent(ctx: PluginInput, manager: BackgroundManager, modelService?: ModelResolutionService): ToolDefinition;

package/dist/tools/model-resolution-service.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Model Resolution Service
+ *
+ * Centralized model resolution for agent invocations.
+ * Connects ModelResolver (config-based tier mapping) to runtime tool calls.
+ *
+ * Priority chain:
+ * 1. Per-agent config model override
+ * 2. Per-agent config tier → tierDefaults
+ * 3. Agent definition tier → tierDefaults
+ * 4. Fallback to sonnet tier
+ * 5. If all else fails, use parent session model
+ */
+import { type AgentModelConfig, type ModelMappingConfig } from "../config/model-resolver";
+export interface ModelConfig {
+    providerID: string;
+    modelID: string;
+}
+export interface ModelResolutionService {
+    /**
+     * Resolve model for an agent based on tier configuration
+     * @param agentName - Name of the agent (canonical or alias)
+     * @param fallbackModel - Parent session model to use if resolution fails
+     * @returns Resolved ModelConfig or undefined if should use fallback
+     */
+    resolveModelForAgent(agentName: string, fallbackModel?: ModelConfig): ModelConfig | undefined;
+    /**
+     * Check if tier mapping is configured (tierDefaults has provider/model format)
+     */
+    isTierMappingConfigured(): boolean;
+}
+/**
+ * Create a ModelResolutionService instance
+ *
+ * @param modelMappingConfig - Config from omco.json model_mapping section
+ * @param agentOverrides - Per-agent config overrides from omco.json agents section
+ */
+export declare function createModelResolutionService(modelMappingConfig?: ModelMappingConfig, agentOverrides?: Record<string, AgentModelConfig>): ModelResolutionService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-claudecode-opencode",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "OpenCode port of oh-my-claudecode - Multi-agent orchestration plugin (omco)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",