opencode-next-prompt 0.0.7 → 0.0.8

package/README.md

@@ -28,7 +28,10 @@ Restart opencode. The package and its dependencies are installed automatically.
 {
   "plugin": [["opencode-next-prompt", {
     "acceptKey": "down",
-    "timeoutMs": 20000
+    "timeoutMs": 20000,
+    "model": "my-provider/fast-model",
+    "disableTools": true,
+    "includeToolContext": false
   }]]
 }
 ```
@@ -36,11 +39,17 @@ Restart opencode. The package and its dependencies are installed automatically.
 | 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 |
+| `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 |
+| `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) |
 
 ## 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 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.
+
+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.
 
 ## License
 

package/dist/index.js

@@ -5,7 +5,10 @@ import { renderSuggestionPlaceholder } from "./ui.js";
 const DEFAULT_OPTIONS = {
     acceptKey: "down",
     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();
@@ -33,7 +36,7 @@ const opencodeNextPrompt = async (api, rawOptions) => {
                 if (part.type === "text" && !part.synthetic && !part.ignored) {
                     return part.text.replace(/<think>[\s\S]*?<\/think>\s*/g, "");
                 }
-                return summarizeToolPart(part);
+                return options.includeToolContext ? summarizeToolPart(part) : "";
             })
                 .join("\n")
                 .trim();
@@ -50,31 +53,84 @@ const opencodeNextPrompt = async (api, rawOptions) => {
         }
         return undefined;
     };
-    let predictedUserMessageID;
-    const predictor = createPredictor(api.client, api.state.path.directory, options);
+    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 && userMessageID === predictedUserMessageID)
+        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;
+        }
         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);
+        inFlightUserMessageID = userMessageID;
+        const variant = resolveVariant(options.variant, modelRef);
         try {
-            const text = await predictor.predict(session?.model, turns);
-            store.commit(generation, sessionID, text);
+            const result = await predictor.predict(session?.model, turns, variant);
+            if (inFlightUserMessageID !== userMessageID)
+                return;
+            if (result.ok) {
+                completedUserMessageID = userMessageID;
+                store.commit(generation, sessionID, result.text);
+            }
+            else {
+                store.discard();
+                scheduleRetry(userMessageID);
+            }
         }
         catch (error) {
-            log(api, "prediction failed", error);
+            log(api, "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();
+        inFlightUserMessageID = undefined;
+        completedUserMessageID = undefined;
+        retriedUserMessageID = undefined;
+        void predictor.dispose();
     };
     const accept = async () => {
         const current = store.read();
@@ -84,7 +140,7 @@ const opencodeNextPrompt = async (api, rawOptions) => {
             await api.client.tui.appendPrompt({ text: current.text });
         }
         catch (error) {
-            log(api, "append prompt failed", error);
+            log(api, "append prompt failed", errorMessage(error));
         }
     };
     api.event.on("session.status", (event) => {
@@ -99,12 +155,19 @@ const opencodeNextPrompt = async (api, rawOptions) => {
                 void maybePredict();
         }
     });
-    api.event.on("tui.session.select", (event) => {
-        store.discard();
-        void predictor.dispose();
+    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("session.compacted", () => {
-        void predictor.dispose();
+    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();
@@ -129,9 +192,77 @@ function log(api, message, extra) {
         service: "opencode-next-prompt",
         level: "info",
         message,
-        extra: { data: JSON.stringify(extra) },
+        extra: { data: extra },
     });
 }
+function resolveModelRef(spec, sessionModel, providers) {
+    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) };
+    }
+    const providerID = sessionModel?.providerID;
+    const modelID = spec ?? sessionModel?.id;
+    if (!providerID || !modelID)
+        return undefined;
+    return { providerID, modelID, model: findModel(providerID, modelID, providers) };
+}
+function findModel(providerID, modelID, providers) {
+    return providers.find((item) => item.id === providerID)?.models[modelID];
+}
+function checkModelConfig(spec, ref, providers) {
+    if (!spec || !ref)
+        return undefined;
+    const provider = providers.find((item) => item.id === ref.providerID);
+    if (!provider) {
+        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 ? ", ..." : ""})` : ""}`;
+    }
+    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)
+        return undefined;
+    const names = Object.keys(variants);
+    if (names.length === 0)
+        return undefined;
+    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")

package/dist/predict.d.ts

@@ -6,12 +6,20 @@ export type ConversationTurn = {
 };
 export type PredictOptions = {
     timeoutMs: number;
+    model?: string;
+    disableTools?: boolean;
+};
+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>;
+    } | undefined, turns: ConversationTurn[], variant?: string): Promise<PredictResult>;
     dispose(): Promise<void>;
 };
 export declare function createPredictor(client: OpencodeClient, directory: string | undefined, options: PredictOptions): Predictor;

package/dist/predict.js

@@ -13,69 +13,78 @@ If nothing plausible remains to say, reply with exactly: NO_SUGGESTION
 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;
-    let predictedTurns = 0;
-    let predictedLastMessageID;
-    let accumulatedChars = 0;
     const deleteSession = async () => {
         if (sessionID) {
-            await client.session.delete({ sessionID, directory }).catch(() => { });
+            const current = sessionID;
             sessionID = undefined;
-            predictedTurns = 0;
-            predictedLastMessageID = undefined;
-            accumulatedChars = 0;
+            await client.session.abort({ sessionID: current, directory }).catch(() => { });
+            await client.session.delete({ sessionID: current, directory }).catch(() => { });
         }
     };
     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 input = 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;
+            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);
             }
-            let delta = turns.slice(predictedTurns);
-            if (delta.length === 0)
-                return null;
-            let input = PROMPT + renderConversation(delta);
-            if (sessionID && accumulatedChars + input.length > MAX_ACCUMULATED_CHARS) {
+            catch (error) {
                 await deleteSession();
-                delta = turns;
-                input = PROMPT + renderConversation(delta);
-            }
-            if (!sessionID) {
-                const created = await client.session.create({ directory, title: TITLE, model });
-                if (created.error)
-                    throw created.error;
-                sessionID = created.data.id;
+                throw error;
             }
-            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);
+            await deleteSession();
+            return { ok: true, text };
         },
         async dispose() {
             await deleteSession();
         },
     };
 }
-const MAX_ASSISTANT_MESSAGES = 10;
-const MAX_ACCUMULATED_CHARS = 80_000;
+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 truncate(text, max) {
+    return text.length > max ? text.slice(0, max - 1) + "…" : text;
 }
 function parsePrediction(parts) {
     const line = parts
@@ -96,10 +105,13 @@ function parsePrediction(parts) {
         return null;
     return text.length > MAX_PREDICTION_CHARS ? text.slice(0, MAX_PREDICTION_CHARS - 3) + "..." : text;
 }
-function withTimeout(promise, ms) {
+function withTimeout(promise, ms, onTimeout) {
     let timer;
     const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(`prediction timed out after ${ms}ms`)), ms);
+        timer = setTimeout(() => {
+            onTimeout();
+            reject(new Error(`prediction timed out after ${ms}ms`));
+        }, ms);
     });
     return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }

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.0.8",
+  "description": "Predicts your next message after the assistant replies in OpenCode \u2014 accept it with the down arrow",
   "type": "module",
   "exports": {
     "./tui": {