opencode-next-prompt 0.0.8 → 0.1.0

package/README.md

@@ -2,54 +2,61 @@
 
 Predicts your next message after the assistant replies and shows it at the prompt — accept it with a keypress (like Claude Code's "next message suggestion").
 
+Requires OpenCode **≥ 2.0** (V2 plugin API).
+
 ## Install
 
-Add to `~/.config/opencode/tui.json`:
+Add to `~/.config/opencode/cli.json`:
 
 ```json
 {
-  "plugin": ["opencode-next-prompt"]
+  "plugins": ["opencode-next-prompt"]
 }
 ```
 
 Restart opencode. The package and its dependencies are installed automatically.
 
-> TUI plugins are declared in `tui.json`; the `plugin` array in `opencode.jsonc` is for server plugins (e.g. opencode-polkit).
+> TUI plugins are declared in `cli.json`'s `plugins` array (the successor of `tui.json`'s `plugin` array); the `plugin` array in `opencode.json` is for server plugins.
 
 ## Usage
 
 - After each reply, a suggested next message appears at the input in gray
-- Press the accept key (**↓** by default) while the input is empty to fill it; with text in the input, the key keeps its normal cursor behavior
+- Press the accept key (**→** by default) while the input is empty to fill it; with text in the input, the key keeps its normal cursor behavior
 - Typing hides the suggestion; clearing the input re-shows it
 
 ## Config
 
 ```json
 {
-  "plugin": [["opencode-next-prompt", {
-    "acceptKey": "down",
-    "timeoutMs": 20000,
-    "model": "my-provider/fast-model",
-    "disableTools": true,
-    "includeToolContext": false
-  }]]
+  "plugins": [
+    {
+      "package": "opencode-next-prompt",
+      "options": {
+        "acceptKey": "right",
+        "timeoutMs": 20000,
+        "model": "my-provider/fast-model",
+        "includeToolContext": false
+      }
+    }
+  ]
 }
 ```
 
 | Key | Default | Description |
 |---|---|---|
-| `acceptKey` | `down` | Key to accept the suggestion (only effective while the input is empty) |
+| `acceptKey` | `right` | Key to accept the suggestion (only effective while the input is empty) |
 | `timeoutMs` | `20000` | Per-prediction timeout; the timed-out call is aborted and retried once |
-| `model` | unset | Fast model for predictions as `provider/model`; a bare model id uses the session's provider. Defaults to the current session's model. Unknown providers/models are rejected with an error toast and a log entry |
+| `model` | unset | Fast model for predictions as `provider/model`; a bare model id uses the session's provider. Defaults to the current session's model. Unknown providers/models are rejected with an error toast |
 | `variant` | auto | Model variant (reasoning effort) used for predictions. By default the lowest variant the model supports is picked automatically (e.g. `low`); models without variants are left untouched. Set it explicitly (e.g. `"high"`) to override, or `"default"` to disable |
-| `disableTools` | `true` | Denies all tools in the background predictor session (predictions never run code or search) |
 | `includeToolContext` | `false` | Include summarized tool calls and outputs in the prediction context (more context, more tokens) |
 
+The accept command is registered as `opencode-next-prompt.accept`, so it can be rebound in `cli.json`'s `keybinds`.
+
 ## How it works
 
-After each reply, the plugin predicts your next input in a fresh background session built from the recent conversation (the last few turns plus the original goal). The suggestion is written into the input placeholder, so what you see is exactly what gets accepted. The main conversation is never modified.
+After each reply, the plugin predicts your next input with a single tool-free text-generation call built from the recent conversation (the last few turns plus the original goal). No background session is created, no tools are ever available to the prediction, and the main conversation is never modified. The suggestion is written into the input placeholder, so what you see is exactly what gets accepted.
 
-Each suggestion costs one extra model call, and the background session is created and removed per prediction, so the model never sees its own previous predictions (which would bias the next one). Failed or timed-out predictions are retried once. A suggestion disappears when you type or when the session changes.
+Each suggestion costs one extra model call. Failed or timed-out predictions are retried once. A suggestion disappears when you type, when you revert or compact the conversation, or when the session changes.
 
 ## License
 

package/dist/debug.d.ts

@@ -0,0 +1,10 @@
+/** Where debug output lands while running inside the real TUI. */
+export declare const DEBUG_LOG_FILE: string;
+/**
+ * Debug logging is off by default. Enable with `NEXT_PROMPT_DEBUG=1` (or the
+ * globalThis flag used by tests).
+ *
+ * Output goes to a file: inside the TUI, console.error is captured by the
+ * host and never reaches stderr, so a file is the only reliable channel.
+ */
+export declare function debug(message: string, extra?: unknown): void;

package/dist/debug.js

@@ -0,0 +1,36 @@
+import { appendFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/** Where debug output lands while running inside the real TUI. */
+export const DEBUG_LOG_FILE = join(tmpdir(), "opencode-next-prompt.log");
+function stringify(extra) {
+    if (extra === undefined)
+        return "";
+    if (typeof extra === "string")
+        return extra;
+    try {
+        return JSON.stringify(extra);
+    }
+    catch {
+        return String(extra);
+    }
+}
+/**
+ * Debug logging is off by default. Enable with `NEXT_PROMPT_DEBUG=1` (or the
+ * globalThis flag used by tests).
+ *
+ * Output goes to a file: inside the TUI, console.error is captured by the
+ * host and never reaches stderr, so a file is the only reliable channel.
+ */
+export function debug(message, extra) {
+    const flag = globalThis.NEXT_PROMPT_DEBUG || process.env.NEXT_PROMPT_DEBUG;
+    if (!flag)
+        return;
+    const detail = stringify(extra);
+    try {
+        appendFileSync(DEBUG_LOG_FILE, `${new Date().toISOString()} ${message}${detail ? ` ${detail}` : ""}\n`);
+    }
+    catch {
+        // Never let diagnostics break the plugin.
+    }
+}

package/dist/editor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Structural (duck-typed) access to the TUI's focused prompt editor.
+ *
+ * `instanceof` cannot be used across the plugin/host boundary: the opencode
+ * binary bundles its own copy of @opentui/core, while the plugin resolves its
+ * own copy from node_modules, so class identity never matches. Instead we
+ * recognise editors by the members every edit-buffer renderable exposes.
+ *
+ * To tell the prompt's multi-line TextareaRenderable apart from the
+ * single-line InputRenderable (dialogs, forms — which must never receive the
+ * suggestion), we check for the `maxLength` accessor that only
+ * InputRenderable defines.
+ */
+export type TextareaLike = {
+    readonly plainText: string;
+    placeholder: string | null;
+    readonly isDestroyed: boolean;
+    insertText(text: string): void;
+    gotoBufferEnd(options?: {
+        select?: boolean;
+    }): void;
+    getLayoutNode(): {
+        markDirty(): void;
+    };
+};
+/** Returns `editor` when it is a live, writable multi-line textarea; otherwise null. */
+export declare function asPromptTextarea(editor: unknown): TextareaLike | null;

package/dist/editor.js

@@ -0,0 +1,32 @@
+/**
+ * Structural (duck-typed) access to the TUI's focused prompt editor.
+ *
+ * `instanceof` cannot be used across the plugin/host boundary: the opencode
+ * binary bundles its own copy of @opentui/core, while the plugin resolves its
+ * own copy from node_modules, so class identity never matches. Instead we
+ * recognise editors by the members every edit-buffer renderable exposes.
+ *
+ * To tell the prompt's multi-line TextareaRenderable apart from the
+ * single-line InputRenderable (dialogs, forms — which must never receive the
+ * suggestion), we check for the `maxLength` accessor that only
+ * InputRenderable defines.
+ */
+/** Returns `editor` when it is a live, writable multi-line textarea; otherwise null. */
+export function asPromptTextarea(editor) {
+    if (!editor || typeof editor !== "object")
+        return null;
+    const candidate = editor;
+    if (candidate.isDestroyed)
+        return null;
+    if (typeof candidate.plainText !== "string")
+        return null;
+    if (typeof candidate.insertText !== "function")
+        return null;
+    if (typeof candidate.gotoBufferEnd !== "function")
+        return null;
+    if (typeof candidate.getLayoutNode !== "function")
+        return null;
+    if ("maxLength" in candidate)
+        return null; // single-line InputRenderable
+    return candidate;
+}

package/dist/index.d.ts

@@ -1,6 +1,3 @@
-import type { TuiPlugin } from "@opencode-ai/plugin/tui";
-declare const _default: {
-    id: string;
-    tui: TuiPlugin;
-};
-export default _default;
+import { Plugin } from "@opencode/plugin/tui";
+declare const opencodeNextPrompt: Plugin.Definition;
+export default opencodeNextPrompt;

package/dist/index.js

@@ -1,227 +1,317 @@
-import { InputRenderable } from "@opentui/core";
+import { Plugin } from "@opencode/plugin/tui";
 import { createSuggestionStore } from "./state.js";
 import { createPredictor } from "./predict.js";
-import { renderSuggestionPlaceholder } from "./ui.js";
+import { createPlaceholderController } from "./ui.js";
+import { asPromptTextarea } from "./editor.js";
+import { debug } from "./debug.js";
 const DEFAULT_OPTIONS = {
-    acceptKey: "down",
+    acceptKey: "right",
     timeoutMs: 20_000,
-    disableTools: true,
     includeToolContext: false,
 };
 const RETRY_DELAY_MS = 800;
-const opencodeNextPrompt = async (api, rawOptions) => {
-    const options = { ...DEFAULT_OPTIONS, ...(rawOptions ?? {}) };
-    const store = createSuggestionStore();
-    const currentSessionID = () => {
-        const route = api.route.current;
-        if (route.name !== "session")
+const THINK_TAG = /<\/?think>[\s\S]*?<\/think>\s*/g;
+const opencodeNextPrompt = Plugin.define({
+    id: "opencode-next-prompt",
+    setup(context) {
+        const options = { ...DEFAULT_OPTIONS, ...context.options };
+        const store = createSuggestionStore();
+        // The controller gates on the session the prompt is editing; the router
+        // always reports the focused session (per-tab footers cannot diverge
+        // from it), and predictions commit against the same source.
+        const placeholder = createPlaceholderController(context, store, () => currentSessionID(), options.acceptKey);
+        let disposed = false;
+        const currentSessionID = () => {
+            const route = context.ui.router.current();
+            if (route.type !== "session")
+                return undefined;
+            return route.sessionID;
+        };
+        const promptInputIsEmpty = () => {
+            const editor = asPromptTextarea(context.renderer.currentFocusedEditor);
+            return editor !== null && editor.plainText === "";
+        };
+        const conversationTurns = (sessionID) => {
+            const result = [];
+            for (const message of context.data.session.message.list(sessionID)) {
+                if (message.type === "user") {
+                    const text = message.text.replace(THINK_TAG, "").trim();
+                    if (text)
+                        result.push({ id: message.id, role: "user", text });
+                    continue;
+                }
+                if (message.type !== "assistant")
+                    continue;
+                const text = message.content
+                    .map((part) => {
+                    if (part.type === "text")
+                        return part.text.replace(THINK_TAG, "");
+                    return options.includeToolContext ? summarizeToolPart(part) : "";
+                })
+                    .join("\n")
+                    .trim();
+                if (text)
+                    result.push({ id: message.id, role: "assistant", text });
+            }
+            return result;
+        };
+        const lastUserMessageID = (sessionID) => {
+            for (const message of context.data.session.message.list(sessionID).toReversed()) {
+                if (message.type === "user")
+                    return message.id;
+            }
             return undefined;
-        const sessionID = route.params?.sessionID;
-        return typeof sessionID === "string" ? sessionID : undefined;
-    };
-    const promptInputIsEmpty = () => {
-        const editor = api.renderer.currentFocusedEditor;
-        if (!editor || editor instanceof InputRenderable)
-            return false;
-        return editor.editBuffer.getText() === "";
-    };
-    const conversationTurns = (sessionID) => {
-        const result = [];
-        for (const message of api.state.session.messages(sessionID)) {
-            if (message.role !== "user" && message.role !== "assistant")
-                continue;
-            const text = api.state
-                .part(message.id)
-                .map((part) => {
-                if (part.type === "text" && !part.synthetic && !part.ignored) {
-                    return part.text.replace(/<think>[\s\S]*?<\/think>\s*/g, "");
+        };
+        let inFlightUserMessageID;
+        let completedUserMessageID;
+        let retriedUserMessageID;
+        let reportedModelIssue;
+        const predictor = createPredictor(context.client, {
+            timeoutMs: options.timeoutMs,
+            model: options.model,
+        });
+        const maybePredict = async () => {
+            if (disposed)
+                return;
+            const sessionID = currentSessionID();
+            if (!sessionID) {
+                debug("skip", "no session route");
+                return;
+            }
+            const status = context.data.session.status(sessionID);
+            if (status !== "idle") {
+                debug("skip", { status });
+                return;
+            }
+            const userMessageID = lastUserMessageID(sessionID);
+            if (!userMessageID) {
+                debug("skip", "no user message");
+                return;
+            }
+            if (userMessageID === completedUserMessageID || userMessageID === inFlightUserMessageID) {
+                debug("skip", "message already handled");
+                return;
+            }
+            const session = context.data.session.get(sessionID);
+            const modelRef = resolveModelRef(options.model, session?.model, context);
+            const modelIssue = checkModelConfig(options.model, modelRef, context);
+            if (modelIssue) {
+                if (reportedModelIssue !== modelIssue) {
+                    reportedModelIssue = modelIssue;
+                    debug("prediction skipped", modelIssue);
+                    context.ui.toast.show({ variant: "error", title: "next-prompt", message: modelIssue, duration: 8000 });
                 }
-                return options.includeToolContext ? summarizeToolPart(part) : "";
-            })
-                .join("\n")
-                .trim();
-            if (!text)
-                continue;
-            result.push({ id: message.id, role: message.role, text });
-        }
-        return result;
-    };
-    const lastUserMessageID = (sessionID) => {
-        for (const message of api.state.session.messages(sessionID).toReversed()) {
-            if (message.role === "user")
-                return message.id;
-        }
-        return undefined;
-    };
-    let inFlightUserMessageID;
-    let completedUserMessageID;
-    let retriedUserMessageID;
-    let reportedModelIssue;
-    const predictor = createPredictor(api.client, api.state.path.directory, {
-        timeoutMs: options.timeoutMs,
-        model: options.model,
-        disableTools: options.disableTools,
-    });
-    const maybePredict = async () => {
-        if (api.lifecycle.signal.aborted)
-            return;
-        const sessionID = currentSessionID();
-        if (!sessionID)
-            return;
-        if (api.state.session.status(sessionID)?.type !== "idle")
-            return;
-        const userMessageID = lastUserMessageID(sessionID);
-        if (!userMessageID)
-            return;
-        if (userMessageID === completedUserMessageID || userMessageID === inFlightUserMessageID)
-            return;
-        const session = api.state.session.get(sessionID);
-        const modelRef = resolveModelRef(options.model, session?.model, api.state.provider);
-        const modelIssue = checkModelConfig(options.model, modelRef, api.state.provider);
-        if (modelIssue) {
-            if (reportedModelIssue !== modelIssue) {
-                reportedModelIssue = modelIssue;
-                log(api, "prediction skipped", modelIssue);
-                api.ui.toast({ variant: "error", title: "next-prompt", message: modelIssue, duration: 8000 });
+                return;
             }
-            return;
-        }
-        const turns = conversationTurns(sessionID);
-        if (turns.length === 0)
-            return;
-        const generation = store.beginPredict(sessionID);
-        if (generation === null)
-            return;
-        inFlightUserMessageID = userMessageID;
-        const variant = resolveVariant(options.variant, modelRef);
-        try {
-            const result = await predictor.predict(session?.model, turns, variant);
-            if (inFlightUserMessageID !== userMessageID)
+            const turns = conversationTurns(sessionID);
+            if (turns.length === 0) {
+                debug("skip", "no conversation turns");
                 return;
-            if (result.ok) {
-                completedUserMessageID = userMessageID;
-                store.commit(generation, sessionID, result.text);
             }
-            else {
+            const generation = store.beginPredict(sessionID);
+            if (generation === null) {
+                debug("skip", "store busy");
+                return;
+            }
+            inFlightUserMessageID = userMessageID;
+            const variant = resolveVariant(options.variant, modelRef);
+            try {
+                debug("predicting", { model: session?.model, variant });
+                const result = await predictor.predict(session?.model, turns, variant);
+                if (inFlightUserMessageID !== userMessageID)
+                    return;
+                debug("predict result", { ok: result.ok, length: result.ok ? (result.text?.length ?? 0) : -1 });
+                if (result.ok) {
+                    completedUserMessageID = userMessageID;
+                    store.commit(generation, sessionID, result.text);
+                }
+                else {
+                    store.discard();
+                    scheduleRetry(userMessageID);
+                }
+            }
+            catch (error) {
+                debug("prediction failed", errorMessage(error));
+                if (inFlightUserMessageID !== userMessageID)
+                    return;
                 store.discard();
                 scheduleRetry(userMessageID);
             }
-        }
-        catch (error) {
-            log(api, "prediction failed", errorMessage(error));
-            if (inFlightUserMessageID !== userMessageID)
+            finally {
+                if (inFlightUserMessageID === userMessageID)
+                    inFlightUserMessageID = undefined;
+            }
+        };
+        const scheduleRetry = (userMessageID) => {
+            if (retriedUserMessageID === userMessageID)
                 return;
+            retriedUserMessageID = userMessageID;
+            setTimeout(() => void maybePredict(), RETRY_DELAY_MS);
+        };
+        const invalidate = () => {
             store.discard();
-            scheduleRetry(userMessageID);
-        }
-        finally {
-            if (inFlightUserMessageID === userMessageID)
-                inFlightUserMessageID = undefined;
-        }
-    };
-    const scheduleRetry = (userMessageID) => {
-        if (retriedUserMessageID === userMessageID)
-            return;
-        retriedUserMessageID = userMessageID;
-        setTimeout(() => void maybePredict(), RETRY_DELAY_MS);
-    };
-    const invalidate = () => {
-        store.discard();
-        inFlightUserMessageID = undefined;
-        completedUserMessageID = undefined;
-        retriedUserMessageID = undefined;
-        void predictor.dispose();
-    };
-    const accept = async () => {
-        const current = store.read();
-        if (current.kind !== "ready")
-            return;
-        try {
-            await api.client.tui.appendPrompt({ text: current.text });
-        }
-        catch (error) {
-            log(api, "append prompt failed", errorMessage(error));
-        }
-    };
-    api.event.on("session.status", (event) => {
-        const { sessionID, status } = event.properties;
-        if (sessionID !== currentSessionID())
-            return;
-        if (status.type === "busy") {
+            inFlightUserMessageID = undefined;
+            completedUserMessageID = undefined;
+            retriedUserMessageID = undefined;
+            void predictor.dispose();
+        };
+        const accept = () => {
+            const current = store.read();
+            if (current.kind !== "ready")
+                return;
+            const editor = asPromptTextarea(context.renderer.currentFocusedEditor);
+            if (!editor)
+                return;
+            // Same insertion path the host uses for the `tui.prompt.append` event.
+            editor.insertText(current.text);
+            setTimeout(() => {
+                if (editor.isDestroyed)
+                    return;
+                editor.getLayoutNode().markDirty();
+                editor.gotoBufferEnd();
+                context.renderer.requestRender();
+            }, 0);
+        };
+        const unsubscribers = [];
+        unsubscribers.push(context.data.on("session.status", (event) => {
+            if (event.data.sessionID !== currentSessionID())
+                return;
+            const type = event.data.status.type;
+            debug("session.status event", { type });
+            if (type === "busy") {
+                store.discard();
+            }
+            else if (type === "idle") {
+                if (store.read().kind === "idle")
+                    void maybePredict();
+            }
+        }));
+        // V2 delivery guarantee: feature-plugins subscribe to execution events,
+        // while session.status appears not to reach clients at all. Mirrors the
+        // V1 busy/idle pair: started ≈ busy (user submitted), ended ≈ idle.
+        unsubscribers.push(context.data.on("session.execution.started", (event) => {
+            if (event.data.sessionID !== currentSessionID())
+                return;
+            debug("execution started");
             store.discard();
+        }));
+        for (const type of ["session.execution.succeeded", "session.execution.interrupted"]) {
+            unsubscribers.push(context.data.on(type, (event) => {
+                if (event.data.sessionID !== currentSessionID())
+                    return;
+                debug(type);
+                if (store.read().kind === "idle")
+                    void maybePredict();
+            }));
         }
-        else if (status.type === "idle") {
-            if (store.read().kind === "idle")
-                void maybePredict();
-        }
-    });
-    api.event.on("tui.session.select", () => invalidate());
-    api.event.on("session.compacted", () => invalidate());
-    api.event.on("session.deleted", (event) => {
-        if (event.properties.sessionID === currentSessionID())
-            invalidate();
-    });
-    api.event.on("message.removed", (event) => {
-        if (event.properties.sessionID === currentSessionID())
-            invalidate();
-    });
-    api.event.on("message.part.removed", (event) => {
-        if (event.properties.sessionID === currentSessionID())
-            invalidate();
-    });
-    api.lifecycle.onDispose(() => {
-        void predictor.dispose();
-    });
-    api.keymap.registerLayer({
-        priority: 1000,
-        enabled: () => store.read().kind === "ready",
-        commands: [{ name: "next-prompt.accept", run: () => (promptInputIsEmpty() ? void accept() : undefined) }],
-        bindings: [
-            { key: options.acceptKey, cmd: "next-prompt.accept", preventDefault: false, fallthrough: true },
-        ],
-    });
-    api.slots.register({
-        id: "opencode-next-prompt",
-        slots: {
-            session_prompt_right: (ctx, props) => renderSuggestionPlaceholder(api, props, store.read, options.acceptKey),
-        },
-    });
-};
-function log(api, message, extra) {
-    void api.client.app.log({
-        service: "opencode-next-prompt",
-        level: "info",
-        message,
-        extra: { data: extra },
-    });
-}
-function resolveModelRef(spec, sessionModel, providers) {
+        // Diagnostic: what actually streams. Logs status/execution events plus a
+        // capped sample of distinct event types.
+        const seenEventTypes = new Set();
+        unsubscribers.push(context.data.listen(({ details }) => {
+            const type = details.type;
+            if (/^session\.(status|execution|idle|error)/.test(type)) {
+                debug("event", type);
+                return;
+            }
+            if (seenEventTypes.size < 40 && !seenEventTypes.has(type)) {
+                seenEventTypes.add(type);
+                debug("event(first-seen)", type);
+            }
+        }));
+        unsubscribers.push(context.data.on("tui.session.select", () => invalidate()));
+        // V1's message.removed / message.part.removed: history changed under us.
+        unsubscribers.push(context.data.on("session.revert.committed", (event) => {
+            if (event.data.sessionID === currentSessionID())
+                invalidate();
+        }));
+        unsubscribers.push(context.data.on("session.deleted", (event) => {
+            if (event.data.sessionID === currentSessionID())
+                invalidate();
+        }));
+        // The accept command itself; registered from the app slot render below
+        // (keymap layers need a live solid owner — see the slot comment).
+        const acceptLayer = () => ({
+            priority: 1000,
+            commands: [
+                {
+                    id: "opencode-next-prompt.accept",
+                    title: "Accept next-prompt suggestion",
+                    group: "next-prompt",
+                    enabled: () => store.read().kind === "ready",
+                    bind: options.acceptKey,
+                    run: () => {
+                        debug("accept key", { kind: store.read().kind, empty: promptInputIsEmpty() });
+                        if (promptInputIsEmpty())
+                            accept();
+                        // Keep the default key behavior (cursor movement), like V1's fallthrough.
+                        return false;
+                    },
+                },
+            ],
+        });
+        placeholder.start();
+        // `context.keymap.layer` resolves through useContext, so it needs an
+        // active solid owner under the host's Keymap.Provider. Plugin setup runs
+        // outside the component tree (an async reconciliation, owner already
+        // dropped), where it would throw "Keymap.Provider is missing" — a slot
+        // render runs as a component inside the tree instead. The `app` slot is
+        // the mount the built-in /btw plugin uses for its layers: always mounted,
+        // exactly one instance, alive for the whole TUI session — so per-tab
+        // prompt footers can never duplicate the command registration, and
+        // plugin deactivation (disposeSlot → unmount) releases it via the
+        // component's own cleanup.
+        const disposeSlot = context.ui.slot({
+            append: "app",
+            render: () => {
+                context.keymap.layer(acceptLayer);
+                debug("keymap layer registered");
+                return null;
+            },
+        });
+        return () => {
+            disposed = true;
+            for (const off of unsubscribers)
+                off();
+            placeholder.dispose();
+            disposeSlot();
+            store.discard();
+            void predictor.dispose();
+        };
+    },
+});
+function resolveModelRef(spec, sessionModel, context) {
     const slash = spec?.indexOf("/") ?? -1;
     if (spec && slash > 0 && slash < spec.length - 1) {
         const providerID = spec.slice(0, slash);
         const modelID = spec.slice(slash + 1);
-        return { providerID, modelID, model: findModel(providerID, modelID, providers) };
+        return { providerID, id: modelID, model: findModel(context, providerID, modelID) };
     }
     const providerID = sessionModel?.providerID;
     const modelID = spec ?? sessionModel?.id;
     if (!providerID || !modelID)
         return undefined;
-    return { providerID, modelID, model: findModel(providerID, modelID, providers) };
+    return { providerID, id: modelID, model: findModel(context, providerID, modelID) };
 }
-function findModel(providerID, modelID, providers) {
-    return providers.find((item) => item.id === providerID)?.models[modelID];
+function findModel(context, providerID, modelID) {
+    return context.data.location.model.list()?.find((item) => item.providerID === providerID && item.modelID === modelID);
 }
-function checkModelConfig(spec, ref, providers) {
+function checkModelConfig(spec, ref, context) {
     if (!spec || !ref)
         return undefined;
-    const provider = providers.find((item) => item.id === ref.providerID);
-    if (!provider) {
+    const providers = context.data.location.provider.list();
+    if (providers && !providers.some((item) => item.id === ref.providerID)) {
         const available = providers.map((item) => item.id).join(", ");
         return `model config error: provider "${ref.providerID}" not found${available ? ` (available providers: ${available})` : ""}`;
     }
-    if (!ref.model) {
-        const available = Object.keys(provider.models).slice(0, 10).join(", ");
-        return `model config error: model "${ref.modelID}" not found on provider "${ref.providerID}"${available ? ` (available models: ${available}${Object.keys(provider.models).length > 10 ? ", ..." : ""})` : ""}`;
+    const models = context.data.location.model.list();
+    if (models && !models.some((item) => item.providerID === ref.providerID && item.modelID === ref.id)) {
+        const available = models
+            .filter((item) => item.providerID === ref.providerID)
+            .map((item) => item.modelID)
+            .slice(0, 10)
+            .join(", ");
+        const count = models.filter((item) => item.providerID === ref.providerID).length;
+        return `model config error: model "${ref.id}" not found on provider "${ref.providerID}"${available ? ` (available models: ${available}${count > 10 ? ", ..." : ""})` : ""}`;
     }
     return undefined;
 }
@@ -232,11 +322,9 @@ function resolveVariant(configVariant, ref) {
     if (configVariant)
         return configVariant;
     const variants = ref?.model?.variants;
-    if (!variants)
-        return undefined;
-    const names = Object.keys(variants);
-    if (names.length === 0)
+    if (!variants || variants.length === 0)
         return undefined;
+    const names = variants.map((item) => item.id);
     const low = names.find((name) => name.toLowerCase() === "low");
     if (low)
         return low;
@@ -265,12 +353,13 @@ function errorMessage(error) {
 }
 const TOOL_SUMMARY_CHARS = 150;
 function summarizeToolPart(part) {
-    if (part.type !== "tool" || !part.state || part.state.status === "running")
+    const tool = part;
+    if (tool.type !== "tool" || !tool.state || tool.state.status === "running" || tool.state.status === "streaming")
         return "";
-    const input = JSON.stringify(part.state.input ?? {});
-    const output = part.state.metadata?.output ?? "";
+    const input = JSON.stringify(tool.state.input ?? {});
+    const output = tool.state.metadata?.output ?? "";
     const inputText = input.length > 80 ? input.slice(0, 79) + "…" : input;
     const outputText = output.length > TOOL_SUMMARY_CHARS ? output.slice(0, TOOL_SUMMARY_CHARS - 1) + "…" : output;
-    return `[tool:${part.tool ?? "?"}] ${inputText} → ${outputText || part.state.status || ""}`;
+    return `[tool:${tool.name ?? "?"}] ${inputText} → ${outputText || tool.state.status || ""}`;
 }
-export default { id: "opencode-next-prompt", tui: opencodeNextPrompt };
+export default opencodeNextPrompt;

package/dist/predict.d.ts

@@ -1,4 +1,4 @@
-import type { OpencodeClient } from "@opencode-ai/sdk/v2";
+import type { ModelRef, OpenCodeClient } from "@opencode/client";
 export type ConversationTurn = {
     id: string;
     role: "user" | "assistant";
@@ -7,7 +7,6 @@ export type ConversationTurn = {
 export type PredictOptions = {
     timeoutMs: number;
     model?: string;
-    disableTools?: boolean;
 };
 export type PredictResult = {
     ok: true;
@@ -16,10 +15,18 @@ export type PredictResult = {
     ok: false;
 };
 export type Predictor = {
-    predict(model: {
-        providerID: string;
-        id: string;
-    } | undefined, turns: ConversationTurn[], variant?: string): Promise<PredictResult>;
+    predict(model: ModelRef | undefined, turns: ConversationTurn[], variant?: string): Promise<PredictResult>;
     dispose(): Promise<void>;
 };
-export declare function createPredictor(client: OpencodeClient, directory: string | undefined, options: PredictOptions): Predictor;
+/**
+ * Prediction runs through the tool-free `generate.text` endpoint: no session
+ * is created, so there is nothing to abort or clean up beyond the request
+ * itself, which is cancelled by an AbortSignal on timeout.
+ *
+ * Model fallback: some gates — notably OpenCode's free tier — reject
+ * explicitly selected models on this endpoint (503) while letting the server
+ * default through, so a failed call with a specified model is retried once
+ * without a model instead of failing the whole prediction. Both attempts
+ * share one timeout budget.
+ */
+export declare function createPredictor(client: OpenCodeClient, options: PredictOptions): Predictor;

package/dist/predict.js

@@ -1,4 +1,4 @@
-const TITLE = "next-prompt-suggestion";
+import { debug } from "./debug.js";
 const PROMPT = `You are the user in a conversation with an AI coding assistant. The
 assistant just finished replying to your latest message.
 
@@ -15,54 +15,81 @@ Conversation (oldest first):
 const MAX_PREDICTION_CHARS = 170;
 const MAX_TURNS = 8;
 const MAX_TURN_CHARS = 800;
-const DENY_ALL_TOOLS = [
-    { permission: "*", pattern: "*", action: "deny" },
-];
-export function createPredictor(client, directory, options) {
-    let sessionID;
-    const deleteSession = async () => {
-        if (sessionID) {
-            const current = sessionID;
-            sessionID = undefined;
-            await client.session.abort({ sessionID: current, directory }).catch(() => { });
-            await client.session.delete({ sessionID: current, directory }).catch(() => { });
-        }
-    };
+/**
+ * Prediction runs through the tool-free `generate.text` endpoint: no session
+ * is created, so there is nothing to abort or clean up beyond the request
+ * itself, which is cancelled by an AbortSignal on timeout.
+ *
+ * Model fallback: some gates — notably OpenCode's free tier — reject
+ * explicitly selected models on this endpoint (503) while letting the server
+ * default through, so a failed call with a specified model is retried once
+ * without a model instead of failing the whole prediction. Both attempts
+ * share one timeout budget.
+ */
+export function createPredictor(client, options) {
     return {
         async predict(model, turns, variant) {
             if (turns.length === 0)
                 return { ok: true, text: null };
-            const input = PROMPT + renderConversation(turns);
+            const prompt = PROMPT + renderConversation(turns);
             const ref = resolveModel(options.model, model);
-            const created = await client.session.create({
-                directory,
-                title: TITLE,
-                model: ref ? { id: ref.id, providerID: ref.providerID, ...(variant ? { variant } : {}) } : undefined,
-                permission: options.disableTools === false ? undefined : DENY_ALL_TOOLS,
-            });
-            if (created.error)
-                throw created.error;
-            sessionID = created.data.id;
-            const currentSessionID = sessionID;
-            let text;
+            const deadline = Date.now() + options.timeoutMs;
+            const attempt = async (spec) => {
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    return { ok: false };
+                const controller = new AbortController();
+                const timer = setTimeout(() => controller.abort(), remaining);
+                try {
+                    const result = await client.generate.text({ prompt, model: spec }, { signal: controller.signal });
+                    return { ok: true, text: parsePrediction(result.text) };
+                }
+                finally {
+                    clearTimeout(timer);
+                }
+            };
+            const spec = ref ? { providerID: ref.providerID, id: ref.id, ...(variant ? { variant } : {}) } : undefined;
+            try {
+                return await attempt(spec);
+            }
+            catch (error) {
+                if (!spec) {
+                    debug("generate failed", errorMessage(error));
+                    return { ok: false };
+                }
+                debug("generate with explicit model failed, retrying with server default", errorMessage(error));
+            }
             try {
-                const result = await withTimeout(client.session.prompt({ sessionID, directory, parts: [{ type: "text", text: input }] }), options.timeoutMs, () => void client.session.abort({ sessionID: currentSessionID, directory }).catch(() => { }));
-                if (result.error)
-                    throw result.error;
-                text = parsePrediction(result.data.parts);
+                return await attempt(undefined);
             }
             catch (error) {
-                await deleteSession();
-                throw error;
+                debug("generate failed", errorMessage(error));
+                return { ok: false };
             }
-            await deleteSession();
-            return { ok: true, text };
         },
         async dispose() {
-            await deleteSession();
+            // Nothing to clean up: predictions do not own a session.
         },
     };
 }
+function errorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    if (error && typeof error === "object") {
+        const candidate = error.message;
+        if (typeof candidate === "string")
+            return candidate;
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return String(error);
+        }
+    }
+    return String(error);
+}
 function resolveModel(spec, sessionModel) {
     if (!spec)
         return sessionModel;
@@ -86,12 +113,9 @@ function renderConversation(turns) {
 function truncate(text, max) {
     return text.length > max ? text.slice(0, max - 1) + "…" : text;
 }
-function parsePrediction(parts) {
-    const line = parts
-        .filter((part) => part.type === "text")
-        .map((part) => part.text)
-        .join("")
-        .replace(/<think>[\s\S]*?<\/think>\s*/g, "")
+function parsePrediction(raw) {
+    const line = raw
+        .replace(/<\/?think>[\s\S]*?<\/think>\s*/g, "")
         .split("\n")
         .map((item) => item.trim())
         .find((item) => item.length > 0);
@@ -105,13 +129,3 @@ function parsePrediction(parts) {
         return null;
     return text.length > MAX_PREDICTION_CHARS ? text.slice(0, MAX_PREDICTION_CHARS - 3) + "..." : text;
 }
-function withTimeout(promise, ms, onTimeout) {
-    let timer;
-    const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => {
-            onTimeout();
-            reject(new Error(`prediction timed out after ${ms}ms`));
-        }, ms);
-    });
-    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
-}

package/dist/state.d.ts

@@ -10,8 +10,19 @@ export type SuggestionState = {
     text: string;
     generation: number;
 };
+export type SuggestionListener = (state: SuggestionState) => void;
+/**
+ * A tiny explicit pub/sub store.
+ *
+ * Deliberately not a solid signal: a plugin loaded at runtime resolves solid's
+ * server build under bun's node conditions (createEffect would be a no-op)
+ * and the plugin's copy of solid is never the TUI's copy, so reactivity must
+ * not depend on it.
+ */
 export declare function createSuggestionStore(): {
-    read: import("solid-js").Accessor<SuggestionState>;
+    read(): SuggestionState;
+    /** Subscribes to state transitions; returns the unsubscribe function. */
+    subscribe(listener: SuggestionListener): () => void;
     beginPredict(sessionID: string): number | null;
     commit(generation: number, sessionID: string, text: string | null): void;
     discard(): void;

package/dist/state.js

@@ -1,25 +1,46 @@
-import { createSignal } from "solid-js";
+/**
+ * A tiny explicit pub/sub store.
+ *
+ * Deliberately not a solid signal: a plugin loaded at runtime resolves solid's
+ * server build under bun's node conditions (createEffect would be a no-op)
+ * and the plugin's copy of solid is never the TUI's copy, so reactivity must
+ * not depend on it.
+ */
 export function createSuggestionStore() {
     let generation = 0;
-    const [state, setState] = createSignal({ kind: "idle" });
+    let state = { kind: "idle" };
+    const listeners = new Set();
+    const set = (next) => {
+        state = next;
+        for (const listener of [...listeners])
+            listener(state);
+    };
     return {
-        read: state,
+        read() {
+            return state;
+        },
+        /** Subscribes to state transitions; returns the unsubscribe function. */
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
         beginPredict(sessionID) {
-            if (state().kind !== "idle")
+            if (state.kind !== "idle")
                 return null;
             generation += 1;
-            setState({ kind: "predicting", sessionID, generation });
+            set({ kind: "predicting", sessionID, generation });
             return generation;
         },
         commit(generation, sessionID, text) {
-            const current = state();
-            if (current.kind !== "predicting" || current.generation !== generation)
+            if (state.kind !== "predicting" || state.generation !== generation)
                 return;
-            setState(text ? { kind: "ready", sessionID, text, generation } : { kind: "idle" });
+            set(text ? { kind: "ready", sessionID, text, generation } : { kind: "idle" });
         },
         discard() {
             generation += 1;
-            setState({ kind: "idle" });
+            set({ kind: "idle" });
         },
     };
 }

package/dist/ui.d.ts

@@ -1,8 +1,23 @@
-import type { JSX } from "@opentui/solid";
-import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
-import type { Accessor } from "solid-js";
-import type { SuggestionState } from "./state.ts";
-export type PromptSlotProps = {
-    session_id: string;
+import type { Context } from "@opencode/plugin/tui/context";
+import type { SuggestionStore } from "./state.ts";
+/**
+ * Renders the suggestion into the prompt textarea's placeholder. There is no
+ * slot inside the input in V2, so the controller writes the placeholder
+ * directly: it re-applies on store changes, on the renderer's `focused_editor`
+ * event, and — because the TUI rewrites the placeholder from its own reactive
+ * memo (session switch, resize, shell change) — on every frame while a
+ * suggestion is live. `sessionID()` answers which session the prompt edits.
+ *
+ * Deliberately free of solid-js: a plugin loaded at runtime resolves solid's
+ * server build (createEffect would be a no-op) and the plugin's copy of solid
+ * is not the TUI's copy anyway, so side effects here must not depend on it.
+ *
+ * The placeholder is only cleared when it is ours (it starts with the accept
+ * key marker), so OpenCode's own placeholder list is left untouched.
+ */
+export declare function createPlaceholderController(context: Context, store: SuggestionStore, sessionID: () => string | undefined, acceptKey: string): {
+    apply: () => void;
+    start(): void;
+    dispose(): void;
 };
-export declare function renderSuggestionPlaceholder(api: TuiPluginApi, props: PromptSlotProps, state: Accessor<SuggestionState>, acceptKey: string): JSX.Element;
+export type PlaceholderController = ReturnType<typeof createPlaceholderController>;

package/dist/ui.js

@@ -1,5 +1,5 @@
-import { createEffect, onCleanup } from "solid-js";
-import { InputRenderable, TextareaRenderable } from "@opentui/core";
+import { asPromptTextarea } from "./editor.js";
+import { debug } from "./debug.js";
 const ARROW_KEYS = {
     right: "→",
     left: "←",
@@ -9,21 +9,70 @@ const ARROW_KEYS = {
 function displayKey(key) {
     return ARROW_KEYS[key] ?? key;
 }
-export function renderSuggestionPlaceholder(api, props, state, acceptKey) {
+/**
+ * Renders the suggestion into the prompt textarea's placeholder. There is no
+ * slot inside the input in V2, so the controller writes the placeholder
+ * directly: it re-applies on store changes, on the renderer's `focused_editor`
+ * event, and — because the TUI rewrites the placeholder from its own reactive
+ * memo (session switch, resize, shell change) — on every frame while a
+ * suggestion is live. `sessionID()` answers which session the prompt edits.
+ *
+ * Deliberately free of solid-js: a plugin loaded at runtime resolves solid's
+ * server build (createEffect would be a no-op) and the plugin's copy of solid
+ * is not the TUI's copy anyway, so side effects here must not depend on it.
+ *
+ * The placeholder is only cleared when it is ours (it starts with the accept
+ * key marker), so OpenCode's own placeholder list is left untouched.
+ */
+export function createPlaceholderController(context, store, sessionID, acceptKey) {
+    const marker = ` [${displayKey(acceptKey)}] `;
     const apply = () => {
-        const editor = api.renderer.currentFocusedEditor;
-        if (!editor || editor instanceof InputRenderable || !(editor instanceof TextareaRenderable))
+        const editor = asPromptTextarea(context.renderer.currentFocusedEditor);
+        const current = store.read();
+        debug("apply", {
+            kind: current.kind,
+            want: current.kind === "ready" ? current.sessionID : undefined,
+            have: sessionID(),
+            editor: editor !== null,
+        });
+        if (!editor)
             return;
-        const current = state();
-        editor.placeholder =
-            current.kind === "ready" && current.sessionID === props.session_id
-                ? ` [${displayKey(acceptKey)}] ${current.text}`
-                : null;
+        if (current.kind === "ready" && current.sessionID === sessionID()) {
+            const desired = marker + current.text;
+            // Write only on real changes: the setter is idempotent, which is what
+            // lets the frame reconciler below settle after restoring our marker.
+            if (editor.placeholder !== desired)
+                editor.placeholder = desired;
+            return;
+        }
+        if (typeof editor.placeholder === "string" && editor.placeholder.startsWith(marker)) {
+            editor.placeholder = null;
+        }
+    };
+    // TUI overwrites trigger a render, so reconciling on the next frame
+    // restores our marker within one paint; when idle there is nothing to
+    // defend, and frames skip the work entirely.
+    const onFrame = () => {
+        if (store.read().kind === "ready")
+            apply();
+    };
+    let unsubscribe = null;
+    return {
+        apply,
+        start() {
+            unsubscribe = store.subscribe(apply);
+            context.renderer.on("focused_editor", apply);
+            context.renderer.on("frame", onFrame);
+        },
+        dispose() {
+            unsubscribe?.();
+            unsubscribe = null;
+            context.renderer.off("focused_editor", apply);
+            context.renderer.off("frame", onFrame);
+            const editor = asPromptTextarea(context.renderer.currentFocusedEditor);
+            if (editor && typeof editor.placeholder === "string" && editor.placeholder.startsWith(marker)) {
+                editor.placeholder = null;
+            }
+        },
     };
-    createEffect(apply);
-    api.renderer.on("focused_editor", apply);
-    onCleanup(() => {
-        api.renderer.off("focused_editor", apply);
-    });
-    return null;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-next-prompt",
-  "version": "0.0.8",
-  "description": "Predicts your next message after the assistant replies in OpenCode \u2014 accept it with the down arrow",
+  "version": "0.1.0",
+  "description": "Predicts your next message after the assistant replies in OpenCode — accept it with the right arrow",
   "type": "module",
   "exports": {
     "./tui": {
@@ -11,27 +11,33 @@
   },
   "files": [
     "dist",
+    "tui.js",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "build": "deno task build",
-    "check": "deno task check"
+    "build": "bun tools/build.ts",
+    "check": "tsc --noEmit",
+    "test": "bun test"
   },
   "engines": {
-    "opencode": ">=1.18.0"
+    "opencode": ">=2.0.0"
   },
   "dependencies": {
-    "@opentui/core": "0.4.5",
-    "@opentui/solid": "0.4.5",
-    "solid-js": "1.9.12"
+    "@opencode/plugin": "^2.0.12"
   },
   "peerDependencies": {
-    "@opencode-ai/plugin": ">=1.0.0"
+    "@opencode/client": ">=2.0.12",
+    "@opentui/core": ">=0.5.11",
+    "@opentui/solid": ">=0.5.11",
+    "solid-js": ">=1.9.15"
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.0.0",
-    "bun-types": "^1.2.0",
+    "@opencode/client": "^2.0.12",
+    "@opentui/core": "0.5.11",
+    "@opentui/solid": "0.5.11",
+    "@types/node": "^22.0.0",
+    "solid-js": "^1.9.15",
     "typescript": "^5.5.0"
   },
   "keywords": [

package/tui.js

@@ -0,0 +1,4 @@
+// Local-directory entrypoint for OpenCode (cli.json "plugins" with an absolute
+// path resolves <dir>/tui directly, bypassing package.json "exports").
+// Published installs use the "./tui" export in package.json instead.
+export { default } from "./dist/index.js"