@khalilgharbaoui/opencode-claude-code-plugin 0.6.2 → 0.7.0

package/README.md

@@ -319,7 +319,7 @@ Set `permissionMode: "plan"` to forward `--permission-mode plan` to Claude. The
 opencode has no native structured ask-question executor to proxy through (unlike `Bash`/`Task`), so the plugin handles `AskUserQuestion` specially:
 
 1. **It renders the full question.** The tool's payload — every question, header, option label, and option description — is emitted as readable markdown into the assistant stream so the user actually sees the choices (same approach as `ExitPlanMode`).
-2. **It is never auto-allowed at the CLI gate.** Allowing it would let the headless Claude CLI resolve its own question (no TTY → fabricated/empty answer) and proceed on a guess. `controlRequestBehaviorForTool` hard-denies `AskUserQuestion` and returns a message telling the model to wait for the operator's answer — or, if the run is non-interactive, to proceed with the single most reasonable option and state its assumption rather than stall.
+2. **It is never auto-allowed at the CLI gate.** Allowing it would let the headless Claude CLI resolve its own question (no TTY → fabricated/empty answer) and proceed on a guess. `controlRequestBehaviorForTool` hard-denies `AskUserQuestion` and returns a message telling the model to **stop and wait for the operator's answer** — end the turn, call no further tools, and never self-answer. (Before v0.7.0 this message also offered an "if the run is non-interactive, proceed with a reasonable guess" fallback. The model could not reliably tell interactive opencode from a headless run and routinely took it, so questions appeared to be skipped — [issue #8](https://github.com/khalilgharbaoui/opencode-claude-code-plugin/issues/8). For genuinely unattended runs, use the `controlRequestToolBehaviors` override below instead.)
 
 This hard-deny sits **below** `controlRequestToolBehaviors` in precedence but **above** the global `controlRequestBehavior`. So:
 

package/dist/index.d.ts

@@ -542,9 +542,15 @@ interface ClaudeCodeProvider {
     languageModel(modelId: string): LanguageModelV3;
 }
 declare function createClaudeCode(settings?: ClaudeCodeProviderSettings): ClaudeCodeProvider;
+/**
+ * Build models in OpenCode's config schema format (flat properties like
+ * `temperature`, `reasoning`, `cost.cache_read`, `modalities`, etc.)
+ * so the config-path provider loader parses them correctly.
+ */
+declare function configModelsForProvider(providerModels: OpenCodeProvider["models"], providerID: string, modelSuffix?: string): Record<string, Record<string, unknown>>;
 declare const _default: {
     id: string;
     server: OpenCodePlugin;
 };
 
-export { type ClaudeCodeConfig, ClaudeCodeLanguageModel, type ClaudeCodeProvider, type ClaudeCodeProviderSettings, type ClaudeStreamMessage, type OpenCodeHooks, type OpenCodeModel, type OpenCodePlugin, bridgeOpencodeMcp, createClaudeCode, _default as default, defaultModels };
+export { type ClaudeCodeConfig, ClaudeCodeLanguageModel, type ClaudeCodeProvider, type ClaudeCodeProviderSettings, type ClaudeStreamMessage, type OpenCodeHooks, type OpenCodeModel, type OpenCodePlugin, bridgeOpencodeMcp, configModelsForProvider, createClaudeCode, _default as default, defaultModels };

package/dist/index.js

@@ -2018,6 +2018,11 @@ function isAskUserQuestionTool(name) {
   const n = name.toLowerCase();
   return n === "askuserquestion" || n === "ask_user_question";
 }
+var ASK_USER_QUESTION_DENY_MESSAGE = "Your question and its options have already been presented to the operator verbatim. Stop now: end your turn without calling any more tools and without answering the question yourself. Wait for the operator's reply, which arrives as the next user message. Do not guess, assume, or proceed on their behalf.";
+function denyMessageForTool(toolName, configuredDenyMessage) {
+  if (isAskUserQuestionTool(toolName)) return ASK_USER_QUESTION_DENY_MESSAGE;
+  return configuredDenyMessage ?? `Denied by opencode-claude-code policy for tool ${toolName}`;
+}
 function formatAskUserQuestion(input) {
   const anyInput = input;
   const questions = Array.isArray(anyInput?.questions) ? anyInput.questions : [];
@@ -2460,7 +2465,10 @@ var ClaudeCodeLanguageModel = class {
           toolName
         });
       } else {
-        const denyMessage = isAskUserQuestionTool(toolName) ? "Your question and its options have already been presented to the operator in full. Prefer to stop here and wait for their answer in the next message \u2014 do not silently guess. But if this is an automated or otherwise non-interactive run where no operator will reply, do not stall: proceed with the single most reasonable option and state, in one line, the assumption you made so it can be corrected later." : this.config.controlRequestDenyMessage ?? `Denied by opencode-claude-code policy for tool ${toolName}`;
+        const denyMessage = denyMessageForTool(
+          toolName,
+          this.config.controlRequestDenyMessage
+        );
         this.writeControlResponse(proc, requestId, {
           behavior: "deny",
           message: denyMessage,
@@ -4559,22 +4567,6 @@ function cleanProviderOptions(options = {}) {
   delete result.accounts;
   return result;
 }
-function mergeDefaultVariants(models = {}) {
-  const result = { ...models };
-  for (const [id, model] of Object.entries(defaultModels)) {
-    if (!model.variants) continue;
-    const existing = result[id] && typeof result[id] === "object" ? result[id] : {};
-    const variants = existing.variants && typeof existing.variants === "object" ? existing.variants : {};
-    result[id] = {
-      ...existing,
-      variants: {
-        ...model.variants,
-        ...variants
-      }
-    };
-  }
-  return result;
-}
 function defaultModelsForProvider(providerModels, providerID = PROVIDER_ID2, modelSuffix) {
   const models = Object.fromEntries(
     Object.entries(defaultModels).map(([id, model]) => {
@@ -4611,6 +4603,7 @@ function configModelsForProvider(providerModels, providerID, modelSuffix) {
   for (const [id, model] of Object.entries(defaultModels)) {
     const modelId = modelSuffix ? `${id}@${modelSuffix}` : id;
     const existing = providerModels[id] ?? providerModels[modelId];
+    const existingVariants = existing && typeof existing.variants === "object" ? existing.variants ?? {} : {};
     const full = {
       ...model,
       id: modelId,
@@ -4620,6 +4613,10 @@ function configModelsForProvider(providerModels, providerID, modelSuffix) {
         id: modelId,
         npm: existing?.api?.npm ?? model.api.npm,
         url: existing?.api?.url ?? model.api.url
+      },
+      variants: {
+        ...model.variants ?? {},
+        ...existingVariants
       }
     };
     models[modelId] = toConfigModel(full);
@@ -4648,8 +4645,10 @@ async function providerConfig(existing, providerID = PROVIDER_ID2, optionDefault
     options: {
       ...mergedOptions,
       ...runtime
-    },
-    models: mergeDefaultVariants(existing?.models)
+    }
+    // models is intentionally omitted: both callers overwrite it with
+    // configModelsForProvider(), which emits the flat config schema
+    // opencode's config-path loader parses (and merges user variants).
   };
 }
 async function expandAccountProviders(config) {
@@ -4717,7 +4716,11 @@ var server = async (input) => {
       const existing = config.provider[PROVIDER_ID2];
       config.provider[PROVIDER_ID2] = {
         ...existing,
-        ...await providerConfig(existing)
+        ...await providerConfig(existing),
+        models: configModelsForProvider(
+          existing?.models ?? {},
+          PROVIDER_ID2
+        )
       };
       log.notice("registered claude-code provider", {
         id: PROVIDER_ID2,
@@ -4768,6 +4771,7 @@ var index_default = {
 export {
   ClaudeCodeLanguageModel,
   bridgeOpencodeMcp,
+  configModelsForProvider,
   createClaudeCode,
   index_default as default,
   defaultModels