feature: add an "interject" response option to the "ask" permission's modal (implements #4822)

packages/opencode/src/cli/cmd/tui/routes/session/index.tsx

@@ -54,6 +54,7 @@ import { TodoItem } from "../../component/todo-item"
 import { DialogMessage } from "./dialog-message"
 import type { PromptInfo } from "../../component/prompt/history"
 import { DialogConfirm } from "@tui/ui/dialog-confirm"
+import { DialogPrompt } from "@tui/ui/dialog-prompt"
 import { DialogTimeline } from "./dialog-timeline"
 import { DialogForkFromTimeline } from "./dialog-fork-from-timeline"
 import { DialogSessionRename } from "../../component/dialog-session-rename"
@@ -73,6 +74,7 @@ import { PermissionPrompt } from "./permission"
 import { QuestionPrompt } from "./question"
 import { DialogExportOptions } from "../../ui/dialog-export-options"
 import { formatTranscript } from "../../util/transcript"
+import { iife } from "@/util/iife"
 
 addDefaultParsers(parsers.parsers)
 
@@ -254,6 +256,49 @@ export function Session() {
     dialog.clear()
   }
 
+  useKeyboard(async (evt) => {
+    if (dialog.stack.length > 0) return
+
+    const first = permissions()[0]
+    if (first) {
+      if (evt.ctrl || evt.meta) return
+
+      // Handle interject with "i" key - opens prompt for user suggestion
+      if (evt.name === "i") {
+        const interjection = await DialogPrompt.show(dialog, "Interject", {
+          placeholder: "Enter your suggestion...",
+          description: () => (
+            <text fg={theme.textMuted}>
+              Provide a suggestion or correction for the model to consider
+            </text>
+          ),
+        })
+        if (interjection !== null && interjection.trim()) {
+          sdk.client.permission.reply({
+            requestID: first.id,
+            reply: "interject",
+            interjection: interjection.trim(),
+          })
+        }
+        return
+      }
+
+      const response = iife(() => {
+        if (evt.name === "return") return "once"
+        if (evt.name === "a") return "always"
+        if (evt.name === "d") return "reject"
+        if (evt.name === "escape") return "reject"
+        return
+      })
+      if (response) {
+        sdk.client.permission.reply({
+          requestID: first.id,
+          reply: response,
+        })
+      }
+    }
+  })
+
   function toBottom() {
     setTimeout(() => {
       if (scroll) scroll.scrollTo(scroll.scrollHeight)

packages/opencode/src/cli/cmd/tui/ui/dialog-prompt.tsx

@@ -21,6 +21,7 @@ export function DialogPrompt(props: DialogPromptProps) {
   useKeyboard((evt) => {
     if (evt.name === "return") {
       props.onConfirm?.(textarea.plainText)
+      dialog.clear()
     }
   })
 
@@ -45,6 +46,7 @@ export function DialogPrompt(props: DialogPromptProps) {
         <textarea
           onSubmit={() => {
             props.onConfirm?.(textarea.plainText)
+            dialog.clear()
           }}
           height={3}
           keyBindings={[{ name: "return", action: "submit" }]}

packages/opencode/src/permission/index.ts

@@ -46,6 +46,7 @@ export namespace Permission {
         sessionID: z.string(),
         permissionID: z.string(),
         response: z.string(),
+        interjection: z.string().optional(),
       }),
     ),
   }
@@ -152,10 +153,10 @@ export namespace Permission {
     })
   }
 
-  export const Response = z.enum(["once", "always", "reject"])
+  export const Response = z.enum(["once", "always", "reject", "interject"])
   export type Response = z.infer<typeof Response>
 
-  export function respond(input: { sessionID: Info["sessionID"]; permissionID: Info["id"]; response: Response }) {
+  export function respond(input: {sessionID: Info["sessionID"]; permissionID: Info["id"]; response: Response; interjection?: string}) {
     log.info("response", input)
     const { pending, approved } = state()
     const match = pending[input.sessionID]?.[input.permissionID]
@@ -165,9 +166,23 @@ export namespace Permission {
       sessionID: input.sessionID,
       permissionID: input.permissionID,
       response: input.response,
+      interjection: input.interjection,
     })
-    if (input.response === "reject") {
-      match.reject(new RejectedError(input.sessionID, input.permissionID, match.info.callID, match.info.metadata))
+    if (input.response === "reject" || input.response === "interject") {
+      const reason =
+        input.response === "interject" && input.interjection
+          ? `The user rejected this action and suggests: ${input.interjection}`
+          : undefined
+      match.reject(
+        new RejectedError(
+          input.sessionID,
+          input.permissionID,
+          match.info.callID,
+          match.info.metadata,
+          reason,
+          input.response === "interject",
+        ),
+      )
       return
     }
     match.resolve()
@@ -199,6 +214,7 @@ export namespace Permission {
       public readonly toolCallID?: string,
       public readonly metadata?: Record<string, any>,
       public readonly reason?: string,
+      public readonly isInterjection: boolean = false,
     ) {
       super(
         reason !== undefined

packages/opencode/src/permission/next.ts

@@ -74,7 +74,7 @@ export namespace PermissionNext {
 
   export type Request = z.infer<typeof Request>
 
-  export const Reply = z.enum(["once", "always", "reject"])
+  export const Reply = z.enum(["once", "always", "reject", "interject"])
   export type Reply = z.infer<typeof Reply>
 
   export const Approval = z.object({
@@ -90,6 +90,7 @@ export namespace PermissionNext {
         sessionID: z.string(),
         requestID: z.string(),
         reply: Reply,
+        interjection: z.string().optional(),
       }),
     ),
   }
@@ -149,6 +150,7 @@ export namespace PermissionNext {
     z.object({
       requestID: Identifier.schema("permission"),
       reply: Reply,
+      interjection: z.string().optional(),
       message: z.string().optional(),
     }),
     async (input) => {
@@ -160,7 +162,12 @@ export namespace PermissionNext {
         sessionID: existing.info.sessionID,
         requestID: existing.info.id,
         reply: input.reply,
+        interjection: input.interjection,
       })
+      if (input.reply === "interject") {
+        existing.reject(new RejectedError(true, input.interjection))
+        return
+      }
       if (input.reply === "reject") {
         existing.reject(input.message ? new CorrectedError(input.message) : new RejectedError())
         // Reject all other pending permissions for this session
@@ -242,8 +249,15 @@ export namespace PermissionNext {
 
   /** User rejected without message - halts execution */
   export class RejectedError extends Error {
-    constructor() {
-      super(`The user rejected permission to use this specific tool call.`)
+    public readonly isInterjection: boolean
+    public readonly interjection?: string
+    constructor(isInterjection = false, interjection?: string) {
+      const message = isInterjection && interjection
+        ? `The user interjected with a suggestion: ${interjection}`
+        : `The user rejected permission to use this specific tool call. You may try again with different parameters.`
+      super(message)
+      this.isInterjection = isInterjection
+      this.interjection = interjection
     }
   }
 

packages/opencode/src/server/server.ts

@@ -1625,12 +1625,21 @@ export namespace Server {
               permissionID: z.string(),
             }),
           ),
-          validator("json", z.object({ response: PermissionNext.Reply })),
+          validator(
+            "json",
+            z.object({
+              response: PermissionNext.Reply,
+              interjection: z.string().optional(),
+              message: z.string().optional(),
+            }),
+          ),
           async (c) => {
             const params = c.req.valid("param")
+            const json = c.req.valid("json")
             PermissionNext.reply({
               requestID: params.permissionID,
-              reply: c.req.valid("json").response,
+              reply: json.response,
+              interjection: json.interjection,
             })
             return c.json(true)
           },
@@ -1659,13 +1668,14 @@ export namespace Server {
               requestID: z.string(),
             }),
           ),
-          validator("json", z.object({ reply: PermissionNext.Reply, message: z.string().optional() })),
+          validator("json", z.object({ reply: PermissionNext.Reply, interjection: z.string().optional(), message: z.string().optional() })),
           async (c) => {
             const params = c.req.valid("param")
             const json = c.req.valid("json")
             await PermissionNext.reply({
               requestID: params.requestID,
               reply: json.reply,
+              interjection: json.interjection,
               message: json.message,
             })
             return c.json(true)

packages/opencode/src/session/processor.ts

@@ -209,10 +209,13 @@ export namespace SessionProcessor {
                       },
                     })
 
-                    if (
-                      value.error instanceof PermissionNext.RejectedError ||
-                      value.error instanceof Question.RejectedError
-                    ) {
+                    if (value.error instanceof PermissionNext.RejectedError) {
+                      // Only block processing for actual denials, not interjections
+                      // Interjections contain user suggestions and should allow model to continue
+                      if (!value.error.isInterjection) {
+                        blocked = shouldBreak
+                      }
+                    } else if (value.error instanceof Question.RejectedError) {
                       blocked = shouldBreak
                     }
                     delete toolcalls[value.toolCallId]

packages/sdk/js/src/gen/types.gen.ts

@@ -447,6 +447,7 @@ export type EventPermissionReplied = {
     sessionID: string
     permissionID: string
     response: string
+    interjection?: string
   }
 }
 
@@ -2877,7 +2878,8 @@ export type SessionUnrevertResponse = SessionUnrevertResponses[keyof SessionUnre
 
 export type PostSessionIdPermissionsPermissionIdData = {
   body?: {
-    response: "once" | "always" | "reject"
+    response: "once" | "always" | "reject" | "interject"
+    interjection?: string
   }
   path: {
     id: string

packages/sdk/js/src/v2/gen/sdk.gen.ts

@@ -1699,7 +1699,8 @@ export class Permission extends HeyApiClient {
       sessionID: string
       permissionID: string
       directory?: string
-      response?: "once" | "always" | "reject"
+      response?: "once" | "always" | "reject" | "interject"
+      interjection?: string
     },
     options?: Options<never, ThrowOnError>,
   ) {
@@ -1712,6 +1713,7 @@ export class Permission extends HeyApiClient {
             { in: "path", key: "permissionID" },
             { in: "query", key: "directory" },
             { in: "body", key: "response" },
+            { in: "body", key: "interjection" },
           ],
         },
       ],
@@ -1737,7 +1739,8 @@ export class Permission extends HeyApiClient {
     parameters: {
       requestID: string
       directory?: string
-      reply?: "once" | "always" | "reject"
+      reply?: "once" | "always" | "reject" | "interject"
+      interjection?: string
       message?: string
     },
     options?: Options<never, ThrowOnError>,
@@ -1750,6 +1753,7 @@ export class Permission extends HeyApiClient {
             { in: "path", key: "requestID" },
             { in: "query", key: "directory" },
             { in: "body", key: "reply" },
+            { in: "body", key: "interjection" },
             { in: "body", key: "message" },
           ],
         },

packages/sdk/js/src/v2/gen/types.gen.ts

@@ -484,7 +484,9 @@ export type EventPermissionReplied = {
   properties: {
     sessionID: string
     requestID: string
-    reply: "once" | "always" | "reject"
+    reply: "once" | "always" | "reject" | "interject"
+    interjection?: string
+    message?: string
   }
 }
 
@@ -3528,7 +3530,8 @@ export type SessionUnrevertResponse = SessionUnrevertResponses[keyof SessionUnre
 
 export type PermissionRespondData = {
   body?: {
-    response: "once" | "always" | "reject"
+    response: "once" | "always" | "reject" | "interject"
+    interjection?: string
   }
   path: {
     sessionID: string
@@ -3564,8 +3567,9 @@ export type PermissionRespondResponse = PermissionRespondResponses[keyof Permiss
 
 export type PermissionReplyData = {
   body?: {
-    reply: "once" | "always" | "reject"
-    message?: string
+     reply: "once" | "always" | "reject" | "interject"
+     interjection?: string
+     message?: string
   }
   path: {
     requestID: string

packages/sdk/openapi.json

@@ -3022,7 +3022,10 @@
                 "properties": {
                   "response": {
                     "type": "string",
-                    "enum": ["once", "always", "reject"]
+                    "enum": ["once", "always", "reject", "interject"]
+                  },
+                  "interjection": {
+                    "type": "string"
                   }
                 },
                 "required": ["response"]