opencode-next-prompt 0.0.7 → 0.1.0

package/README.md

@@ -2,45 +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
-  }]]
+  "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) |
-| `timeoutMs` | `20000` | Per-prediction timeout; the suggestion is dropped on timeout |
+| `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 |
+| `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 |
+| `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 background session that reuses the conversation prefix — each prediction only processes the new content, so it stays fast regardless of conversation length. 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. 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,145 +1,365 @@
-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,
+    includeToolContext: false,
 };
-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 RETRY_DELAY_MS = 800;
+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 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 predictedUserMessageID;
-    const predictor = createPredictor(api.client, api.state.path.directory, options);
-    const maybePredict = async () => {
-        const sessionID = currentSessionID();
-        if (!sessionID)
-            return;
-        const userMessageID = lastUserMessageID(sessionID);
-        if (userMessageID && userMessageID === predictedUserMessageID)
-            return;
-        const turns = conversationTurns(sessionID);
-        if (turns.length === 0)
-            return;
-        const generation = store.beginPredict(sessionID);
-        if (generation === null)
-            return;
-        predictedUserMessageID = userMessageID;
-        const session = api.state.session.get(sessionID);
-        try {
-            const text = await predictor.predict(session?.model, turns);
-            store.commit(generation, sessionID, text);
-        }
-        catch (error) {
-            log(api, "prediction failed", error);
+                return;
+            }
+            const turns = conversationTurns(sessionID);
+            if (turns.length === 0) {
+                debug("skip", "no conversation turns");
+                return;
+            }
+            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);
+            }
+            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();
-        }
-    };
-    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", 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", (event) => {
-        store.discard();
-        void predictor.dispose();
-    });
-    api.event.on("session.compacted", () => {
-        void predictor.dispose();
-    });
-    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: JSON.stringify(extra) },
-    });
+        // 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, id: modelID, model: findModel(context, providerID, modelID) };
+    }
+    const providerID = sessionModel?.providerID;
+    const modelID = spec ?? sessionModel?.id;
+    if (!providerID || !modelID)
+        return undefined;
+    return { providerID, id: modelID, model: findModel(context, providerID, modelID) };
+}
+function findModel(context, providerID, modelID) {
+    return context.data.location.model.list()?.find((item) => item.providerID === providerID && item.modelID === modelID);
+}
+function checkModelConfig(spec, ref, context) {
+    if (!spec || !ref)
+        return undefined;
+    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})` : ""}`;
+    }
+    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;
+}
+const VARIANT_ORDER = ["none", "low", "min", "medium", "high", "xhigh", "max"];
+function resolveVariant(configVariant, ref) {
+    if (configVariant === "default")
+        return undefined;
+    if (configVariant)
+        return configVariant;
+    const variants = ref?.model?.variants;
+    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;
+    return names.toSorted((a, b) => variantRank(a) - variantRank(b))[0];
+}
+function variantRank(name) {
+    const index = VARIANT_ORDER.indexOf(name.toLowerCase());
+    return index === -1 ? VARIANT_ORDER.length : index;
+}
+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);
+    }
 }
 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";
@@ -6,12 +6,27 @@ export type ConversationTurn = {
 };
 export type PredictOptions = {
     timeoutMs: number;
+    model?: string;
+};
+export type PredictResult = {
+    ok: true;
+    text: string | null;
+} | {
+    ok: false;
 };
 export type Predictor = {
-    predict(model: {
-        providerID: string;
-        id: string;
-    } | undefined, turns: ConversationTurn[]): Promise<string | null>;
+    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.
 
@@ -13,76 +13,109 @@ If nothing plausible remains to say, reply with exactly: NO_SUGGESTION
 Conversation (oldest first):
 `;
 const MAX_PREDICTION_CHARS = 170;
-export function createPredictor(client, directory, options) {
-    let sessionID;
-    let predictedTurns = 0;
-    let predictedLastMessageID;
-    let accumulatedChars = 0;
-    const deleteSession = async () => {
-        if (sessionID) {
-            await client.session.delete({ sessionID, directory }).catch(() => { });
-            sessionID = undefined;
-            predictedTurns = 0;
-            predictedLastMessageID = undefined;
-            accumulatedChars = 0;
-        }
-    };
+const MAX_TURNS = 8;
+const MAX_TURN_CHARS = 800;
+/**
+ * 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) {
-            const expectedID = turns[predictedTurns - 1]?.id;
-            if (predictedLastMessageID && expectedID && expectedID !== predictedLastMessageID) {
-                await deleteSession();
+        async predict(model, turns, variant) {
+            if (turns.length === 0)
+                return { ok: true, text: null };
+            const prompt = PROMPT + renderConversation(turns);
+            const ref = resolveModel(options.model, model);
+            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));
             }
-            let delta = turns.slice(predictedTurns);
-            if (delta.length === 0)
-                return null;
-            let input = PROMPT + renderConversation(delta);
-            if (sessionID && accumulatedChars + input.length > MAX_ACCUMULATED_CHARS) {
-                await deleteSession();
-                delta = turns;
-                input = PROMPT + renderConversation(delta);
+            try {
+                return await attempt(undefined);
             }
-            if (!sessionID) {
-                const created = await client.session.create({ directory, title: TITLE, model });
-                if (created.error)
-                    throw created.error;
-                sessionID = created.data.id;
+            catch (error) {
+                debug("generate failed", errorMessage(error));
+                return { ok: false };
             }
-            const result = await withTimeout(client.session.prompt({ sessionID, directory, parts: [{ type: "text", text: input }] }), options.timeoutMs);
-            if (result.error)
-                throw result.error;
-            predictedTurns = turns.length;
-            predictedLastMessageID = turns.at(-1)?.id;
-            accumulatedChars += input.length;
-            return parsePrediction(result.data.parts);
         },
         async dispose() {
-            await deleteSession();
+            // Nothing to clean up: predictions do not own a session.
         },
     };
 }
-const MAX_ASSISTANT_MESSAGES = 10;
-const MAX_ACCUMULATED_CHARS = 80_000;
+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;
+    const slash = spec.indexOf("/");
+    if (slash > 0 && slash < spec.length - 1) {
+        return { providerID: spec.slice(0, slash), id: spec.slice(slash + 1) };
+    }
+    return sessionModel ? { providerID: sessionModel.providerID, id: spec } : undefined;
+}
 function renderConversation(turns) {
-    const assistantCount = turns.reduce((count, turn) => count + (turn.role === "assistant" ? 1 : 0), 0);
-    const skip = Math.max(0, assistantCount - MAX_ASSISTANT_MESSAGES);
-    let skipped = 0;
-    return turns
-        .filter((turn) => {
-        if (turn.role !== "assistant" || skipped >= skip)
-            return true;
-        skipped += 1;
-        return false;
-    })
-        .map((turn) => `${turn.role}: ${turn.text}`)
-        .join("\n");
+    if (turns.length === 0)
+        return "";
+    const recent = turns.slice(-MAX_TURNS);
+    const lines = recent.map((turn) => `${turn.role}: ${truncate(turn.text, MAX_TURN_CHARS)}`);
+    const first = turns[0];
+    if (turns.length > MAX_TURNS && first?.role === "user" && first.id !== recent[0]?.id) {
+        lines.unshift(`user: [original goal] ${truncate(first.text, MAX_TURN_CHARS)}`);
+    }
+    return lines.join("\n");
 }
-function parsePrediction(parts) {
-    const line = parts
-        .filter((part) => part.type === "text")
-        .map((part) => part.text)
-        .join("")
-        .replace(/<think>[\s\S]*?<\/think>\s*/g, "")
+function truncate(text, max) {
+    return text.length > max ? text.slice(0, max - 1) + "…" : text;
+}
+function parsePrediction(raw) {
+    const line = raw
+        .replace(/<\/?think>[\s\S]*?<\/think>\s*/g, "")
         .split("\n")
         .map((item) => item.trim())
         .find((item) => item.length > 0);
@@ -96,10 +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) {
-    let timer;
-    const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => 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.7",
-  "description": "Predicts your next message after the assistant replies in OpenCode \u2014 accept it with the right 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"