@khalilgharbaoui/opencode-claude-code-plugin 0.59.0 → 0.60.1

package/dist/index.d.ts

@@ -1511,6 +1511,13 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
      * claim taken: a choice must never land on the wrong child (h #g227).
      */
     private resolveDispatchChoice;
+    /**
+     * The model the parent named for THIS session in its own `task` call, or
+     * undefined (h #g254). The same two lookups as `resolveDispatchChoice`, and
+     * the same reason for the order: a held record first, and the parent fetched
+     * only for a child whose agent and first message match a recorded request.
+     */
+    private resolveExplicitTaskModel;
     /**
      * Whether the ExitPlanMode approval bridge is live for this turn: the
      * operator opted in AND opencode's registry actually has the `question`

package/dist/index.js

@@ -55,6 +55,7 @@ var V2_TOOLS = {
     name: "subagent",
     input: (input) => defined({
       agent: input.subagent_type ?? input.agent,
+      model: input.model,
       description: input.description,
       prompt: input.prompt,
       sessionID: input.task_id ?? input.sessionID,
@@ -2613,9 +2614,12 @@ function withoutAccountMarker(modelId) {
 }
 function qualifyModelName(wanted, referenceModelId) {
   const base = withoutAccountMarker(wanted.trim());
-  if (!base || !Object.hasOwn(defaultModels, base)) return null;
+  if (!isRegisteredModelName(base)) return null;
   return `${base}${accountMarker(referenceModelId)}`;
 }
+function isRegisteredModelName(name) {
+  return name.length > 0 && Object.hasOwn(defaultModels, name);
+}
 function resolveAgentModel(agent, modelId, overrides) {
   if (!agent) return modelId;
   const record = (overrides?.records ?? registry)[agent];
@@ -3252,17 +3256,20 @@ function dispatchTasksFromCalls(calls, batchTasks) {
   const out = [];
   for (const call of calls) {
     if (call.toolName === "task") {
-      out.push(taskFromInput(call.toolCallId, null, call.input));
+      if (!namesOwnModel(call.input)) out.push(taskFromInput(call.toolCallId, null, call.input));
       continue;
     }
     if (call.toolName === "task_batch") {
       for (const [index, task] of batchTasks(call.input).entries()) {
-        out.push(taskFromInput(call.toolCallId, index, task));
+        if (!namesOwnModel(task)) out.push(taskFromInput(call.toolCallId, index, task));
       }
     }
   }
   return out;
 }
+function namesOwnModel(input) {
+  return typeof input.model === "string" && input.model.trim() !== "";
+}
 function taskFromInput(callId, batchIndex, input) {
   return {
     callId,
@@ -4718,6 +4725,13 @@ var TASK_INPUT_PROPERTIES = {
     type: "string",
     description: "The type of specialized agent to use for this task"
   },
+  // After the agent type, where opencode 2's own `subagent` tool puts it
+  // (after `prompt`): first in the list it was the field the model read first.
+  // Stripped on a host whose `task` has no such field (`applyTaskModelSupport`).
+  model: {
+    type: "string",
+    description: "NEVER set this unless the user explicitly asked for a particular model or variant for this subagent. The exact opencode model reference, providerID/modelID, or providerID/modelID#variant to pick a variant. Use only an id the user gave you or one this conversation already used; never guess one. Omit it and opencode picks the model as usual."
+  },
   task_id: {
     type: "string",
     description: "Set this only if you mean to resume a previous task: pass the prior task_id to continue the same subagent session instead of creating a fresh one."
@@ -4740,6 +4754,71 @@ var TASK_INPUT_PROPERTIES = {
 var TASK_INPUT_PROPERTIES_NO_BACKGROUND = Object.fromEntries(
   Object.entries(TASK_INPUT_PROPERTIES).filter(([name]) => name !== "background")
 );
+function liveTaskSupportsModel(taskParameters, dialect = "v1") {
+  if (dialect === "v2") return true;
+  const properties = taskParameters?.properties;
+  if (!properties || typeof properties !== "object") return false;
+  return "model" in properties;
+}
+function applyTaskModelSupport(tools, supported) {
+  if (supported) return tools;
+  const withoutModel = (schema) => {
+    const properties = schema?.properties;
+    if (!properties || typeof properties !== "object") return schema;
+    return {
+      ...schema,
+      properties: Object.fromEntries(
+        Object.entries(properties).filter(([name]) => name !== "model")
+      )
+    };
+  };
+  return tools.map((tool) => {
+    if (tool.name === "task") return { ...tool, inputSchema: withoutModel(tool.inputSchema) };
+    if (tool.name !== TASK_BATCH_TOOL_NAME) return tool;
+    const properties = tool.inputSchema.properties;
+    const tasks = properties?.tasks;
+    if (!tasks?.items || typeof tasks.items !== "object") return tool;
+    return {
+      ...tool,
+      inputSchema: {
+        ...tool.inputSchema,
+        properties: {
+          ...properties,
+          tasks: { ...tasks, items: withoutModel(tasks.items) }
+        }
+      }
+    };
+  });
+}
+function taskSchemaOffersModel(def) {
+  const properties = def.inputSchema.properties;
+  const schema = def.name === TASK_BATCH_TOOL_NAME ? properties?.tasks?.items : def.inputSchema;
+  const fields = schema?.properties;
+  return !!fields && typeof fields === "object" && "model" in fields;
+}
+function completeTaskModels(def, input, complete) {
+  if (!complete || !taskSchemaOffersModel(def)) return;
+  const tasks = def.name === TASK_BATCH_TOOL_NAME ? taskBatchTasks(input) : [input];
+  for (const task of tasks) {
+    if (task.model !== void 0) task.model = complete(task.model);
+  }
+}
+function taskModelInputError(def, input, guard) {
+  const tasks = def.name === TASK_BATCH_TOOL_NAME ? taskBatchTasks(input) : [input];
+  const offered = taskSchemaOffersModel(def);
+  for (const task of tasks) {
+    if (task.model === void 0) continue;
+    if (!offered) {
+      return "This opencode's task tool takes no per-call `model` (opencode 1.x has none), so no tasks were started. Omit `model`.";
+    }
+    if (typeof task.model !== "string") {
+      return "`model` must be a string, providerID/modelID or providerID/modelID#variant, so no tasks were started.";
+    }
+    const refusal = guard?.(task.model);
+    if (refusal) return refusal;
+  }
+  return null;
+}
 var DEFAULT_PROXY_TOOLS = [
   {
     name: "bash",
@@ -5032,7 +5111,8 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
         const params = request.params ?? {};
         const toolName = String(params.name ?? "");
         const input = params.arguments ?? {};
-        if (!tools.some((t) => t.name === toolName)) {
+        const tool = tools.find((t) => t.name === toolName);
+        if (!tool) {
           writeJson(res, {
             jsonrpc: "2.0",
             id: requestId,
@@ -5050,6 +5130,14 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
             return;
           }
         }
+        if (toolName === "task" || toolName === TASK_BATCH_TOOL_NAME) {
+          completeTaskModels(tool, input, options.completeTaskModel);
+          const problem = taskModelInputError(tool, input, options.taskModelGuard);
+          if (problem) {
+            writeToolCallResult(res, requestId, { kind: "error", message: problem });
+            return;
+          }
+        }
         const interceptor = interceptors?.get(toolName);
         if (interceptor) {
           let intercepted;
@@ -5808,6 +5896,127 @@ function clearLedger(sessionId) {
   ledgers.delete(sessionId);
 }
 
+// src/task-model.ts
+var TASK_MODEL_REFERENCE = /^([^/#]+)\/([^#]+)(?:#([^#]+))?$/;
+function parseTaskModelReference(value) {
+  if (typeof value !== "string") return null;
+  const match = TASK_MODEL_REFERENCE.exec(value.trim());
+  if (!match) return null;
+  const [, providerID, modelID, variant] = match;
+  return variant ? { providerID, modelID, variant } : { providerID, modelID };
+}
+function completeTaskModelReference(value, own) {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.includes("/")) return value;
+  const hash = trimmed.indexOf("#");
+  const id = hash === -1 ? trimmed : trimmed.slice(0, hash);
+  const variant = hash === -1 ? void 0 : trimmed.slice(hash + 1);
+  if (variant !== void 0 && (!variant || variant.includes("#"))) return value;
+  const at = id.indexOf("@");
+  const base = at === -1 ? id : id.slice(0, at);
+  if (at !== -1 && id.slice(at + 1) !== own.accountMarker) return value;
+  if (!own.isRegistered(base)) return value;
+  const modelID = own.accountMarker ? `${base}@${own.accountMarker}` : base;
+  return `${own.providerID}/${modelID}${variant ? `#${variant}` : ""}`;
+}
+function taskModelAccountRefusal(input) {
+  if (!input.groups || input.crossGroup) return null;
+  const reference = parseTaskModelReference(input.model);
+  if (!reference) return null;
+  const target = input.providers.get(reference.providerID);
+  if (target === void 0) return null;
+  if (accountsShareGroup(input.sourceAccount, target, input.groups)) return null;
+  log.notice("task model refused: its account is in another account group", {
+    account: target,
+    reason: "another-account-group"
+  });
+  return `The model "${input.model}" runs on the Claude account "${target}", which is outside this conversation's account group, so no tasks were started. A subagent is handed task text that can quote this conversation, and accountGroups keeps that text inside one group. Omit \`model\`, or name a model on an account in this conversation's group.`;
+}
+var CLAIM_TTL_MS2 = 15 * 6e4;
+var MAX_CLAIMS2 = 512;
+var MAX_SESSION_MODELS = 512;
+var claims2 = [];
+var sessionModels = /* @__PURE__ */ new Map();
+function pruneClaims2(now) {
+  for (let i = claims2.length - 1; i >= 0; i--) {
+    if (now - claims2[i].createdAt > CLAIM_TTL_MS2) claims2.splice(i, 1);
+  }
+  while (claims2.length > MAX_CLAIMS2) claims2.shift();
+}
+function holdSessionModel(sessionId, model) {
+  sessionModels.delete(sessionId);
+  sessionModels.set(sessionId, model);
+  while (sessionModels.size > MAX_SESSION_MODELS) {
+    const oldest = sessionModels.keys().next().value;
+    if (oldest === void 0) break;
+    sessionModels.delete(oldest);
+  }
+}
+function noteExplicitTaskModels(parentSessionId, tasks, now = Date.now()) {
+  let noted = 0;
+  for (const task of tasks) {
+    const reference = parseTaskModelReference(task.model);
+    if (!reference) continue;
+    const resumed = typeof task.task_id === "string" ? task.task_id.trim() : "";
+    if (resumed) {
+      holdSessionModel(resumed, reference);
+      noted++;
+      continue;
+    }
+    if (!parentSessionId || parentSessionId === "default") continue;
+    pruneClaims2(now);
+    claims2.push({
+      parentSessionId,
+      agent: typeof task.subagent_type === "string" ? task.subagent_type : "general",
+      prompt: typeof task.prompt === "string" ? task.prompt : "",
+      model: reference,
+      createdAt: now
+    });
+    noted++;
+  }
+  return noted;
+}
+function explicitTaskModelFor(sessionId) {
+  return sessionModels.get(sessionId);
+}
+function hasExplicitTaskModelCandidate(agent, prompt, now = Date.now()) {
+  if (!agent || prompt === void 0 || claims2.length === 0) return false;
+  pruneClaims2(now);
+  return claims2.some(
+    (claim) => claim.agent === agent && promptMatchesClaim(claim.prompt, prompt)
+  );
+}
+function claimExplicitTaskModel(input) {
+  const held = sessionModels.get(input.sessionId);
+  if (held) return held;
+  if (!input.agent || input.prompt === void 0 || !input.parentSessionId) return void 0;
+  pruneClaims2(input.now ?? Date.now());
+  const belongsHere = (claim2) => claim2.parentSessionId === input.parentSessionId && claim2.agent === input.agent;
+  const childPrompt = input.prompt;
+  let index = claims2.findIndex((claim2) => belongsHere(claim2) && claim2.prompt === childPrompt);
+  if (index === -1) {
+    index = claims2.findIndex(
+      (claim2) => belongsHere(claim2) && promptMatchesClaim(claim2.prompt, childPrompt)
+    );
+  }
+  if (index === -1) return void 0;
+  const [claim] = claims2.splice(index, 1);
+  holdSessionModel(input.sessionId, claim.model);
+  log.info("explicit task model claimed by its child session", {
+    sessionId: input.sessionId,
+    agent: input.agent,
+    model: claim.model.modelID
+  });
+  return claim.model;
+}
+function explicitTaskModelApplies(record, modelId) {
+  return record !== void 0 && record.modelID === modelId;
+}
+function forgetExplicitTaskModel(sessionId) {
+  sessionModels.delete(sessionId);
+}
+
 // src/compression-store.ts
 var MAX_COMPRESSION_ENTRIES = 32;
 var compressions = /* @__PURE__ */ new Map();
@@ -7820,6 +8029,7 @@ function deleteActiveProcessesForSession(sessionID) {
   for (const key of released) clearBackgroundTasks(key);
   forgetSessionChoice(sessionID);
   forgetDispatchChoicesForSession(sessionID);
+  forgetExplicitTaskModel(sessionID);
   return released;
 }
 var STOPPED_TURN_MESSAGE = "opencode stopped the turn while it was running its proxy tool calls";
@@ -8907,6 +9117,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "subagent dispatch answer was not recognised; dispatching with the defaults",
   "subagent dispatch answer was not recognised; keeping the default",
   "subagent dispatch form was dismissed; dispatching with the defaults",
+  "task model refused: its account is in another account group",
   "task_batch resolving with child results missing",
   "the interactive transport has not been measured on this Claude Code version; it reads the TUI's screen and transcript, which a new release can change. If a turn hangs or a dialog is not handled, run /claude-code-doctor bundle and report it",
   "the interactive turn did not take a forwarded user message",
@@ -15001,7 +15212,7 @@ async function resolvePlanModeQuestion(config, compactionMode, loadLiveToolInfo)
   }
   return active;
 }
-async function ensureProxyServer(config, tools, sessionKeyForCalls, interceptCompress, callerSessionId) {
+async function ensureProxyServer(config, tools, sessionKeyForCalls, interceptCompress, callerSessionId, sourceAccount) {
   const timeoutOverrides = config.proxyToolTimeoutMs;
   const interceptors = /* @__PURE__ */ new Map();
   if (tools.some((t) => t.name === TASK_STATUS_TOOL_NAME)) {
@@ -15031,8 +15242,40 @@ async function ensureProxyServer(config, tools, sessionKeyForCalls, interceptCom
   }
   const cap = config.maxBackgroundSubagents;
   const admit = cap !== void 0 && tools.some((t) => t.name === "task" || t.name === TASK_BATCH_TOOL_NAME) ? (toolName, input) => admitBackgroundDispatch(toolName, input, cap) : void 0;
-  const srv = await createProxyMcpServer(tools, timeoutOverrides, interceptors, { admit });
+  const accountProviders = accountProviderMap(config.failoverAccounts);
+  const groups = config.accountGroups ?? null;
+  const caller = normalizeAccountName(sourceAccount ?? config.account ?? DEFAULT_ACCOUNT);
+  const taskModelGuard = groups && accountProviders.size > 0 ? (model) => taskModelAccountRefusal({
+    model,
+    sourceAccount: caller,
+    providers: accountProviders,
+    groups,
+    crossGroup: config.subagentDispatchCrossGroup === true
+  }) : void 0;
+  const ownModelMarker = accountModelSuffix(config.account ?? DEFAULT_ACCOUNT);
+  const completeTaskModel = (model) => {
+    const completed = completeTaskModelReference(model, {
+      providerID: config.provider,
+      accountMarker: ownModelMarker,
+      isRegistered: isRegisteredModelName
+    });
+    if (completed !== model) {
+      log.info("bare task model completed to this conversation's own provider", {
+        model: completed
+      });
+    }
+    return completed;
+  };
+  const srv = await createProxyMcpServer(tools, timeoutOverrides, interceptors, {
+    admit,
+    taskModelGuard,
+    completeTaskModel
+  });
   srv.calls.on("call", (call) => {
+    if (call.toolName === "task") noteExplicitTaskModels(callerSessionId, [call.input]);
+    else if (call.toolName === TASK_BATCH_TOOL_NAME) {
+      noteExplicitTaskModels(callerSessionId, taskBatchTasks(call.input));
+    }
     queuePendingProxyCall(sessionKeyForCalls, call, timeoutOverrides);
   });
   return srv;
@@ -17000,6 +17243,26 @@ var ClaudeCodeLanguageModel = class {
       parentSessionId: await fetchSessionParentId(affinity)
     });
   }
+  /**
+   * The model the parent named for THIS session in its own `task` call, or
+   * undefined (h #g254). The same two lookups as `resolveDispatchChoice`, and
+   * the same reason for the order: a held record first, and the parent fetched
+   * only for a child whose agent and first message match a recorded request.
+   */
+  async resolveExplicitTaskModel(options, affinity) {
+    if (affinity === "default") return void 0;
+    const held = explicitTaskModelFor(affinity);
+    if (held) return held;
+    const agent = this.getOpencodeAgent(options);
+    const prompt = firstUserText(options.prompt);
+    if (!hasExplicitTaskModelCandidate(agent, prompt)) return void 0;
+    return claimExplicitTaskModel({
+      sessionId: affinity,
+      agent,
+      prompt,
+      parentSessionId: await fetchSessionParentId(affinity)
+    });
+  }
   /**
    * Whether the ExitPlanMode approval bridge is live for this turn: the
    * operator opted in AND opencode's registry actually has the `question`
@@ -17173,13 +17436,14 @@ var ClaudeCodeLanguageModel = class {
    * Create a proxy MCP server for a single active Claude process/session.
    * The process lifecycle owns the server lifecycle via session-manager.
    */
-  async ensureProxyServer(tools, sessionKeyForCalls, interceptCompress, callerSessionId) {
+  async ensureProxyServer(tools, sessionKeyForCalls, interceptCompress, callerSessionId, sourceAccount) {
     return ensureProxyServer(
       this.config,
       tools,
       sessionKeyForCalls,
       interceptCompress,
-      callerSessionId
+      callerSessionId,
+      sourceAccount
     );
   }
   /**
@@ -17570,17 +17834,19 @@ var ClaudeCodeLanguageModel = class {
     const affinity = this.sessionAffinity(options);
     const cwd = await resolveSpawnCwdForSession(this.config.cwd, affinity);
     const compactionMode = this.isCompactionCall(options);
-    const dispatchChoice = compactionMode ? void 0 : await this.resolveDispatchChoice(options, affinity);
+    const explicitTaskModel = compactionMode ? void 0 : await this.resolveExplicitTaskModel(options, affinity);
+    const explicitModelApplies = explicitTaskModelApplies(explicitTaskModel, this.modelId);
+    const dispatchChoice = compactionMode || explicitModelApplies ? void 0 : await this.resolveDispatchChoice(options, affinity);
     const dispatchModelId = dispatchChoice?.model ? qualifyModelName(dispatchChoice.model, this.modelId) : null;
-    const effectiveModelId = compactionMode ? this.resolveCompactionModel() : attempt?.modelOverride ?? dispatchModelId ?? resolveAgentModel(
+    const effectiveModelId = compactionMode ? this.resolveCompactionModel() : attempt?.modelOverride ?? dispatchModelId ?? (explicitModelApplies ? this.modelId : resolveAgentModel(
       this.getOpencodeAgent(options),
       this.modelId
-    );
+    ));
     if (attempt) attempt.modelId = effectiveModelId;
-    const reasoningEffort = compactionMode ? void 0 : dispatchChoice?.effort ?? resolveAgentEffort(
+    const reasoningEffort = compactionMode ? void 0 : dispatchChoice?.effort ?? (explicitModelApplies && explicitTaskModel?.variant ? this.getReasoningEffort(options.providerOptions) : resolveAgentEffort(
       this.getOpencodeAgent(options),
       this.getReasoningEffort(options.providerOptions)
-    );
+    ));
     const promptCacheTtl = compactionMode ? void 0 : resolveAgentCacheTtl(this.getOpencodeAgent(options));
     const context = [
       this.config.provider,
@@ -18610,6 +18876,16 @@ var ClaudeCodeLanguageModel = class {
                 backgroundSubagentsSupported,
                 hostDialect
               );
+              const taskModelSupported = liveTaskSupportsModel(
+                liveToolInfo.taskParameters,
+                hostDialect
+              );
+              enrichedProxy = applyTaskModelSupport(enrichedProxy, taskModelSupported);
+              log.info("task model gate", {
+                supported: taskModelSupported,
+                registryResolved: liveToolInfo.resolved,
+                hostApi: hostDialect
+              });
               recordBackgroundSubagentGate({
                 supported: backgroundSubagentsSupported,
                 hostApi: hostDialect,
@@ -18664,7 +18940,8 @@ var ClaudeCodeLanguageModel = class {
                 combinedProxyTools,
                 sk,
                 pluginCompressEnabled,
-                affinity
+                affinity,
+                sourceAccount
               );
             }
             const questionProxyActive = enrichedProxy?.some((t) => t.name === "question") ?? false;