oh-my-opencode-slim 0.8.1 → 0.8.3

package/dist/index.js

@@ -3376,12 +3376,12 @@ var SUBAGENT_DELEGATION_RULES = {
   oracle: []
 };
 var DEFAULT_MODELS = {
-  orchestrator: "kimi-for-coding/k2p5",
-  oracle: "openai/gpt-5.2-codex",
-  librarian: "openai/gpt-5.1-codex-mini",
-  explorer: "openai/gpt-5.1-codex-mini",
+  orchestrator: undefined,
+  oracle: "openai/gpt-5.4",
+  librarian: "openai/gpt-5-codex",
+  explorer: "openai/gpt-5-codex",
   designer: "kimi-for-coding/k2p5",
-  fixer: "openai/gpt-5.1-codex-mini"
+  fixer: "openai/gpt-5-codex"
 };
 var POLL_INTERVAL_BACKGROUND_MS = 2000;
 var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
@@ -17014,7 +17014,16 @@ var FallbackChainsSchema = exports_external.object({
   fixer: AgentModelChainSchema.optional()
 }).catchall(AgentModelChainSchema);
 var AgentOverrideConfigSchema = exports_external.object({
-  model: exports_external.string().optional(),
+  model: exports_external.union([
+    exports_external.string(),
+    exports_external.array(exports_external.union([
+      exports_external.string(),
+      exports_external.object({
+        id: exports_external.string(),
+        variant: exports_external.string().optional()
+      })
+    ]))
+  ]).optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
   variant: exports_external.string().optional().catch(undefined),
   skills: exports_external.array(exports_external.string()).optional(),
@@ -17138,25 +17147,27 @@ function loadPluginConfig(directory) {
   }
   return config2;
 }
-function loadAgentPrompt(agentName) {
+function loadAgentPrompt(agentName, preset) {
+  const presetDirName = preset && /^[a-zA-Z0-9_-]+$/.test(preset) ? preset : undefined;
   const promptsDir = path.join(getUserConfigDir(), "opencode", PROMPTS_DIR_NAME);
+  const promptSearchDirs = presetDirName ? [path.join(promptsDir, presetDirName), promptsDir] : [promptsDir];
   const result = {};
-  const promptPath = path.join(promptsDir, `${agentName}.md`);
-  if (fs.existsSync(promptPath)) {
-    try {
-      result.prompt = fs.readFileSync(promptPath, "utf-8");
-    } catch (error48) {
-      console.warn(`[oh-my-opencode-slim] Error reading prompt file ${promptPath}:`, error48 instanceof Error ? error48.message : String(error48));
-    }
-  }
-  const appendPromptPath = path.join(promptsDir, `${agentName}_append.md`);
-  if (fs.existsSync(appendPromptPath)) {
-    try {
-      result.appendPrompt = fs.readFileSync(appendPromptPath, "utf-8");
-    } catch (error48) {
-      console.warn(`[oh-my-opencode-slim] Error reading append prompt file ${appendPromptPath}:`, error48 instanceof Error ? error48.message : String(error48));
+  const readFirstPrompt = (fileName, errorPrefix) => {
+    for (const dir of promptSearchDirs) {
+      const promptPath = path.join(dir, fileName);
+      if (!fs.existsSync(promptPath)) {
+        continue;
+      }
+      try {
+        return fs.readFileSync(promptPath, "utf-8");
+      } catch (error48) {
+        console.warn(`[oh-my-opencode-slim] ${errorPrefix} ${promptPath}:`, error48 instanceof Error ? error48.message : String(error48));
+      }
     }
-  }
+    return;
+  };
+  result.prompt = readFirstPrompt(`${agentName}.md`, "Error reading prompt file");
+  result.appendPrompt = readFirstPrompt(`${agentName}_append.md`, "Error reading append prompt file");
   return result;
 }
 // src/config/utils.ts
@@ -17580,21 +17591,32 @@ function createOrchestratorAgent(model, customPrompt, customAppendPrompt) {
 
 ${customAppendPrompt}`;
   }
-  return {
+  const definition = {
     name: "orchestrator",
     description: "AI coding orchestrator that delegates tasks to specialist agents for optimal quality, speed, and cost",
     config: {
-      model,
       temperature: 0.1,
       prompt
     }
   };
+  if (Array.isArray(model)) {
+    definition._modelArray = model.map((m) => typeof m === "string" ? { id: m } : m);
+  } else if (typeof model === "string" && model) {
+    definition.config.model = model;
+  }
+  return definition;
 }
 
 // src/agents/index.ts
 function applyOverrides(agent, override) {
-  if (override.model)
-    agent.config.model = override.model;
+  if (override.model) {
+    if (Array.isArray(override.model)) {
+      agent._modelArray = override.model.map((m) => typeof m === "string" ? { id: m } : m);
+      agent.config.model = undefined;
+    } else {
+      agent.config.model = override.model;
+    }
+  }
   if (override.variant)
     agent.config.variant = override.variant;
   if (override.temperature !== undefined)
@@ -17625,12 +17647,20 @@ var SUBAGENT_FACTORIES = {
 function createAgents(config2) {
   const getModelForAgent = (name) => {
     if (name === "fixer" && !getAgentOverride(config2, "fixer")?.model) {
-      return getAgentOverride(config2, "librarian")?.model ?? DEFAULT_MODELS.librarian;
+      const librarianOverride = getAgentOverride(config2, "librarian")?.model;
+      let librarianModel;
+      if (Array.isArray(librarianOverride)) {
+        const first = librarianOverride[0];
+        librarianModel = typeof first === "string" ? first : first?.id;
+      } else {
+        librarianModel = librarianOverride;
+      }
+      return librarianModel ?? DEFAULT_MODELS.librarian;
     }
     return DEFAULT_MODELS[name];
   };
   const protoSubAgents = Object.entries(SUBAGENT_FACTORIES).map(([name, factory]) => {
-    const customPrompts = loadAgentPrompt(name);
+    const customPrompts = loadAgentPrompt(name, config2?.preset);
     return factory(getModelForAgent(name), customPrompts.prompt, customPrompts.appendPrompt);
   });
   const allSubAgents = protoSubAgents.map((agent) => {
@@ -17641,13 +17671,13 @@ function createAgents(config2) {
     applyDefaultPermissions(agent, override?.skills);
     return agent;
   });
-  const orchestratorModel = getAgentOverride(config2, "orchestrator")?.model ?? DEFAULT_MODELS.orchestrator;
-  const orchestratorPrompts = loadAgentPrompt("orchestrator");
+  const orchestratorOverride = getAgentOverride(config2, "orchestrator");
+  const orchestratorModel = orchestratorOverride?.model ?? DEFAULT_MODELS.orchestrator;
+  const orchestratorPrompts = loadAgentPrompt("orchestrator", config2?.preset);
   const orchestrator = createOrchestratorAgent(orchestratorModel, orchestratorPrompts.prompt, orchestratorPrompts.appendPrompt);
-  const oOverride = getAgentOverride(config2, "orchestrator");
-  applyDefaultPermissions(orchestrator, oOverride?.skills);
-  if (oOverride) {
-    applyOverrides(orchestrator, oOverride);
+  applyDefaultPermissions(orchestrator, orchestratorOverride?.skills);
+  if (orchestratorOverride) {
+    applyOverrides(orchestrator, orchestratorOverride);
   }
   return [orchestrator, ...allSubAgents];
 }
@@ -17709,6 +17739,27 @@ function applyAgentVariant(variant, body) {
   }
   return { ...body, variant };
 }
+// src/utils/internal-initiator.ts
+var SLIM_INTERNAL_INITIATOR_MARKER = "<!-- SLIM_INTERNAL_INITIATOR -->";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function createInternalAgentTextPart(text) {
+  return {
+    type: "text",
+    text: `${text}
+${SLIM_INTERNAL_INITIATOR_MARKER}`
+  };
+}
+function hasInternalInitiatorMarker(part) {
+  if (!isRecord(part) || part.type !== "text") {
+    return false;
+  }
+  if (typeof part.text !== "string") {
+    return false;
+  }
+  return part.text.includes(SLIM_INTERNAL_INITIATOR_MARKER);
+}
 // src/utils/tmux.ts
 var {spawn } = globalThis.Bun;
 var tmuxPath = null;
@@ -18119,7 +18170,15 @@ class BackgroundTaskManager {
     const primary = this.config?.agents?.[agentName]?.model;
     const chain = [];
     const seen = new Set;
-    for (const model of [primary, ...configuredChain]) {
+    let primaryIds;
+    if (Array.isArray(primary)) {
+      primaryIds = primary.map((m) => typeof m === "string" ? m : m.id);
+    } else if (typeof primary === "string") {
+      primaryIds = [primary];
+    } else {
+      primaryIds = [];
+    }
+    for (const model of [...primaryIds, ...configuredChain]) {
       if (!model || seen.has(model))
         continue;
       seen.add(model);
@@ -18341,7 +18400,7 @@ class BackgroundTaskManager {
     await this.client.session.prompt({
       path: { id: task.parentSessionId },
       body: {
-        parts: [{ type: "text", text: message }]
+        parts: [createInternalAgentTextPart(message)]
       }
     });
   }
@@ -18580,8 +18639,6 @@ class TmuxSessionManager {
 // src/hooks/auto-update-checker/cache.ts
 import * as fs3 from "fs";
 import * as path4 from "path";
-// src/cli/dynamic-model-selection.ts
-var FREE_BIASED_PROVIDERS = new Set(["opencode"]);
 // src/hooks/auto-update-checker/constants.ts
 import * as os3 from "os";
 import * as path3 from "path";
@@ -18971,6 +19028,56 @@ function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
     body: { title, message, variant, duration: duration3 }
   }).catch(() => {});
 }
+// src/hooks/chat-headers.ts
+var INTERNAL_MARKER_CACHE_LIMIT = 1000;
+var internalMarkerCache = new Map;
+function getProviderID(input) {
+  return input.provider.info?.id || input.model.providerID;
+}
+function isCopilotProvider(providerID) {
+  return providerID === "github-copilot" || providerID === "github-copilot-enterprise";
+}
+async function hasInternalMarker(client, sessionID, messageID) {
+  const cacheKey = `${sessionID}:${messageID}`;
+  const cached2 = internalMarkerCache.get(cacheKey);
+  if (cached2 !== undefined) {
+    return cached2;
+  }
+  try {
+    const response = await client.session.message({
+      path: { id: sessionID, messageID }
+    });
+    const hasMarker = (response.data?.parts ?? []).some(hasInternalInitiatorMarker);
+    if (hasMarker) {
+      if (internalMarkerCache.size >= INTERNAL_MARKER_CACHE_LIMIT) {
+        internalMarkerCache.clear();
+      }
+      internalMarkerCache.set(cacheKey, true);
+    }
+    return hasMarker;
+  } catch {
+    return false;
+  }
+}
+function createChatHeadersHook(ctx) {
+  return {
+    "chat.headers": async (input, output) => {
+      if (!isCopilotProvider(getProviderID(input))) {
+        return;
+      }
+      if (input.model.api.npm === "@ai-sdk/github-copilot") {
+        return;
+      }
+      if (!input.message.id || input.message.role !== "user") {
+        return;
+      }
+      if (!await hasInternalMarker(ctx.client, input.sessionID, input.message.id)) {
+        return;
+      }
+      output.headers["x-initiator"] = "agent";
+    }
+  };
+}
 // src/hooks/delegate-task-retry/patterns.ts
 var DELEGATE_TASK_ERROR_PATTERNS = [
   {
@@ -19030,6 +19137,7 @@ function detectDelegateTaskError(output) {
   }
   return null;
 }
+
 // src/hooks/delegate-task-retry/guidance.ts
 function extractAvailableList(output) {
   const match = output.match(/Allowed agents:\s*(.+)$/m);
@@ -19161,6 +19269,9 @@ function createPhaseReminderHook() {
         return;
       }
       const originalText = lastUserMessage.parts[textPartIndex].text ?? "";
+      if (originalText.includes(SLIM_INTERNAL_INITIATOR_MARKER)) {
+        return;
+      }
       lastUserMessage.parts[textPartIndex].text = `${PHASE_REMINDER}
 
 ---
@@ -33415,7 +33526,14 @@ var lsp_rename = tool({
 // src/index.ts
 var OhMyOpenCodeLite = async (ctx) => {
   const config3 = loadPluginConfig(ctx.directory);
+  const agentDefs = createAgents(config3);
   const agents = getAgentConfigs(config3);
+  const modelArrayMap = {};
+  for (const agentDef of agentDefs) {
+    if (agentDef._modelArray && agentDef._modelArray.length > 0) {
+      modelArrayMap[agentDef.name] = agentDef._modelArray;
+    }
+  }
   const tmuxConfig = {
     enabled: config3.tmux?.enabled ?? false,
     layout: config3.tmux?.layout ?? "main-vertical",
@@ -33439,6 +33557,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   });
   const phaseReminderHook = createPhaseReminderHook();
   const postReadNudgeHook = createPostReadNudgeHook();
+  const chatHeadersHook = createChatHeadersHook(ctx);
   const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
   const jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
   return {
@@ -33460,9 +33579,55 @@ var OhMyOpenCodeLite = async (ctx) => {
       if (!opencodeConfig.agent) {
         opencodeConfig.agent = { ...agents };
       } else {
-        Object.assign(opencodeConfig.agent, agents);
+        for (const [name, pluginAgent] of Object.entries(agents)) {
+          const existing = opencodeConfig.agent[name];
+          if (existing) {
+            opencodeConfig.agent[name] = {
+              ...pluginAgent,
+              ...existing
+            };
+          } else {
+            opencodeConfig.agent[name] = {
+              ...pluginAgent
+            };
+          }
+        }
       }
       const configAgent = opencodeConfig.agent;
+      if (Object.keys(modelArrayMap).length > 0) {
+        const providerConfig = opencodeConfig.provider ?? {};
+        const configuredProviders = Object.keys(providerConfig);
+        for (const [agentName, modelArray] of Object.entries(modelArrayMap)) {
+          let resolved = false;
+          for (const modelEntry of modelArray) {
+            const slashIdx = modelEntry.id.indexOf("/");
+            if (slashIdx === -1)
+              continue;
+            const providerID = modelEntry.id.slice(0, slashIdx);
+            if (configuredProviders.includes(providerID)) {
+              const entry = configAgent[agentName];
+              if (entry) {
+                entry.model = modelEntry.id;
+                if (modelEntry.variant) {
+                  entry.variant = modelEntry.variant;
+                }
+              }
+              log("[plugin] resolved model fallback", {
+                agent: agentName,
+                model: modelEntry.id,
+                variant: modelEntry.variant
+              });
+              resolved = true;
+              break;
+            }
+          }
+          if (!resolved) {
+            log("[plugin] no provider match for model array", {
+              agent: agentName
+            });
+          }
+        }
+      }
       const configMcp = opencodeConfig.mcp;
       if (!configMcp) {
         opencodeConfig.mcp = { ...mcps };
@@ -33499,6 +33664,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       await backgroundManager.handleSessionDeleted(input.event);
       await tmuxSessionManager.onSessionDeleted(input.event);
     },
+    "chat.headers": chatHeadersHook["chat.headers"],
     "experimental.chat.messages.transform": phaseReminderHook["experimental.chat.messages.transform"],
     "tool.execute.after": async (input, output) => {
       await delegateTaskRetryHook["tool.execute.after"](input, output);

package/dist/utils/index.d.ts

@@ -1,5 +1,6 @@
 export * from './agent-variant';
 export * from './env';
+export * from './internal-initiator';
 export { log } from './logger';
 export * from './polling';
 export * from './tmux';

package/dist/utils/internal-initiator.d.ts

@@ -0,0 +1,6 @@
+export declare const SLIM_INTERNAL_INITIATOR_MARKER = "<!-- SLIM_INTERNAL_INITIATOR -->";
+export declare function createInternalAgentTextPart(text: string): {
+    type: 'text';
+    text: string;
+};
+export declare function hasInternalInitiatorMarker(part: unknown): boolean;