pi-opencode-cli-bridge 0.2.5 → 0.2.7

package/README.md

@@ -33,7 +33,7 @@ The original MIT copyright notice is preserved in [LICENSE](LICENSE). The new pa
 
 - Node.js **22.19.0 or newer**.
 - Pi Coding Agent **1.2.0 or newer**; the development SDK is pinned to 1.2.0.
-- OpenCode installed on the same machine and available on `PATH`, or selected with `OPENCODE_PI_BIN`. Tested with OpenCode **1.19.0** and **2.0.30**; other releases are unverified.
+- OpenCode installed on the same machine and available on `PATH`, or selected with `OPENCODE_PI_BIN`. Supports OpenCode up to **2.0.30**. Real-CLI integration tests cover **1.19.0** and **2.0.30**; intermediate releases are not individually verified.
 
 Check OpenCode before starting Pi:
 
@@ -119,10 +119,12 @@ Without an override, discovery selects active `opencode/` models whose reported
 2. It replays Pi's transcript system messages to recover the current system prompt and tool declarations, including later changes.
 3. It creates a temporary OpenCode project containing a `pi-model` agent whose permissions are all `ask`. Non-interactive `opencode run` rejects those permission requests automatically, while native tool declarations remain on the model request. On 1.x, a generated `tool.execute.before` plugin provides a second guard; 2.x relies on the permission guard, not the legacy plugin.
 4. It sends the prompt over standard input to `opencode run --format json`. On 2.x, it uses a private `--standalone` server, sets the subprocess working directory instead of the removed `--dir` flag, and selects reasoning variants with `provider/model#variant` instead of `--variant`. User and tool-result images are written to temporary files and attached only when the model supports images.
-5. If the model calls a native OpenCode tool anyway, the call is still blocked. When every native call in that step has a Pi equivalent in the current tool list (`bash` or 2.x `shell`, `read`, `write`, `edit` with a single replacement, `grep`, and `glob` as `find`), the bridge stops OpenCode and returns them as Pi tool calls. Paths inside the temporary project become relative to Pi's working directory. Otherwise OpenCode continues: the model sees a correction asking it to use a Pi tool, and the turn fails only if it does not recover.
+5. If the model calls a native OpenCode tool anyway, the call is still blocked. When every native call in that step has a Pi equivalent in the current tool list (`bash` or 2.x `shell`, `read`, `write`, `edit` with a single replacement, `grep`, and `glob` as `find`), the bridge stops OpenCode and returns them as Pi tool calls. Paths inside the temporary project become relative to Pi's working directory. Otherwise OpenCode continues and the model can correct itself. If it ends without recovering, the bridge makes one fresh attempt with the original transcript and a correction listing the available Pi tools. For example, when Pi has no `grep` tool, the model can request a search through Pi `bash` instead. Native tools stay blocked on both attempts, which share the turn timeout. A second failure produces an error rather than retrying indefinitely.
 6. Text markers such as `<pi_tool_call>{"name":"read","arguments":{"path":"example.txt"}}</pi_tool_call>` become Pi tool calls. Tool names must be in the current Pi tool list; execution then follows Pi's normal validation and permission pipeline. DeepSeek models sometimes write their native DSML tool-call blocks (`<｜DSML｜invoke name="...">`) as text instead; complete blocks are converted the same way, and an incomplete one fails the turn with a diagnostic instead of ending it silently.
 7. Successful continuation turns reuse an OpenCode session and send only the new transcript. Changes to the model, prompt, tools or transcript prefix start a fresh session.
 
+A turn containing only reasoning, with no answer or usable Pi tool call, also gets one fresh recovery attempt instead of silently ending the conversation. The model is asked to answer or request an available Pi tool; normal text answers and valid calls found in reasoning are unchanged. Reasoning-only and blocked-native failures share the same single retry and remaining turn timeout. If recovery fails, Pi receives an explicit error, not another thinking-only message.
+
 Pi's provider instrumentation hooks follow the CLI transport, not OpenCode's internal HTTP traffic:
 
 - `onPayload` receives `{ prompt }`, the exact text written to the CLI's standard input. Returning `{ prompt: "..." }` replaces it; any other non-`undefined` value fails the turn. A turn with a payload hook always starts a fresh OpenCode session.
@@ -130,7 +132,7 @@ Pi's provider instrumentation hooks follow the CLI transport, not OpenCode's int
 - `onProviderStreamEvent` receives each validated `--format json` event in order, and is awaited before the event is processed.
 - Provider-scoped `env` values are passed to the subprocess. The bridge's own configuration directory and update-check settings always take precedence.
 
-Reasoning variants, image support and token limits follow CLI discovery. Token usage is taken from CLI events when available, otherwise estimated. Session records and temporary project directories are cleaned up on a best-effort basis.
+Reasoning variants, image support and token limits follow CLI discovery. Token usage is taken from CLI events when available, otherwise estimated, and includes both attempts when recovery is needed. Session records and temporary project directories are cleaned up on a best-effort basis.
 
 ## Security, privacy and limits
 
@@ -140,7 +142,7 @@ Reasoning variants, image support and token limits follow CLI discovery. Token u
 - Pi and OpenCode can both retain local conversation data. Best-effort cleanup is not a guarantee of secure deletion.
 - Free-tier model availability and accepted request shapes can change. This fork makes no guarantee of continued access or compliance with a hosted provider's terms; review the applicable terms yourself.
 - Live tests with DeepSeek v4.1 Flash Free used thinking off. The first high-thinking test timed out; no default thinking setting is changed by this package.
-- At startup Pi warns if your OpenCode version is neither 1.19.0 nor 2.0.30, the exact releases covered by the native-tool guard tests.
+- At startup Pi warns when your OpenCode version exceeds the supported maximum, **2.0.30**, or its version cannot be determined.
 - Timeouts and cancellation escalate from `SIGTERM` to `SIGKILL` on the CLI's process group after 250 ms; on Windows the whole process tree is ended with `taskkill /T /F` (not tested on Windows). If OpenCode quits before reading the prompt, the turn shows OpenCode's own error rather than a broken-pipe error. Malformed or unexpected CLI events end the turn with an error instead of crashing Pi. Shutdown waits for session cleanup.
 
 See [SECURITY.md](SECURITY.md) for the trust boundaries and [docs/code-review.md](https://github.com/Gybra/pi-opencode-cli-bridge/blob/main/docs/code-review.md) for what was fixed and what remains. This is an experimental, unaudited fork.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-opencode-cli-bridge",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Bridge the OpenCode CLI into Pi Coding Agent",
   "type": "module",
   "main": "./src/index.ts",
@@ -14,7 +14,7 @@
   "scripts": {
     "build": "tsc",
     "typecheck": "tsc --noEmit",
-    "test": "npm run build && node --test --test-timeout=30000 dist/index.test.js dist/process.test.js",
+    "test": "npm run build && node --test --test-timeout=60000 dist/index.test.js dist/process.test.js",
     "test:integration": "npm run build && node --test --test-timeout=120000 dist/native-tools.integration.test.js",
     "prepublishOnly": "npm run typecheck && npm test && npm run test:integration"
   },

package/src/index.ts

@@ -29,8 +29,7 @@ import {
 const PROVIDER_ID = "opencode-cli";
 const API_ID = "opencode-cli-runner";
 const AGENT_ID = "pi-model";
-// Only exact releases exercised by the real-CLI native-side-effect tests belong here.
-const VERIFIED_OPENCODE_VERSIONS = ["1.19.0", "2.0.30"];
+const MAX_SUPPORTED_OPENCODE_VERSION = "2.0.30";
 const cliVersions = new Map<string, string | undefined>();
 
 async function usesV2Cli(): Promise<boolean> {
@@ -1511,8 +1510,18 @@ export function streamOpenCode(
   model: Model<Api>,
   context: Context,
   options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+  return streamOpenCodeAttempt(model, context, options, true);
+}
+
+function streamOpenCodeAttempt(
+  model: Model<Api>,
+  context: Context,
+  options: SimpleStreamOptions | undefined,
+  allowRecovery: boolean,
 ): AssistantMessageEventStream {
   const stream = createAssistantMessageEventStream();
+  const deadline = Date.now() + resolveTurnTimeoutMs(options?.timeoutMs);
 
   (async () => {
     const output: AssistantMessage = {
@@ -1527,12 +1536,14 @@ export function streamOpenCode(
     };
 
     let tempDir: string | undefined;
+    let prompt = "";
     let accumulatedText = "";
     let accumulatedThinking = "";
     let stderr = "";
     let stdoutRemainder = "";
     let capturedSessionId: string | undefined;
     let opencodeToolUse: string | undefined;
+    let recoverableFailure: Error | undefined;
     // Text after the last blocked native call shows whether the model recovered in-run.
     let nativeTextMark = 0;
     let stepNativeCalls: (ParsedToolCall | undefined)[] = [];
@@ -1578,7 +1589,7 @@ export function streamOpenCode(
         dropOpencodeSession(piState);
       }
       const isContinuation = delta !== undefined;
-      let prompt = isContinuation
+      prompt = isContinuation
         ? buildContinuationPrompt(delta)
         : buildPrompt(context);
       const sentMessages = isContinuation
@@ -1756,9 +1767,10 @@ export function streamOpenCode(
       }
       if (opencodeError) throw new Error(opencodeError);
       if (opencodeToolUse && !nativeCalls && !accumulatedText.slice(nativeTextMark).trim()) {
-        throw new Error(
-          `OpenCode attempted to use its disabled native tool (${JSON.stringify(opencodeToolUse)}). Retry the request; Pi tools must be requested with <pi_tool_call>{"name":"...","arguments":{}}</pi_tool_call> markers.`,
+        recoverableFailure = new Error(
+          `OpenCode could not use the available Pi tools${allowRecovery ? "" : " after one recovery attempt"} (blocked native tool: ${JSON.stringify(opencodeToolUse)}). Retry the request or select another OpenCode model.`,
         );
+        throw recoverableFailure;
       }
 
       const toolCallResult = parseToolCallResponse(
@@ -1803,6 +1815,12 @@ export function streamOpenCode(
           );
         }
       }
+      if (toolCalls.length === 0 && !displayText.trim() && accumulatedThinking.trim()) {
+        recoverableFailure = new Error(
+          `OpenCode returned only reasoning without an answer or Pi tool call${allowRecovery ? "" : " after one recovery attempt"}. Retry the request or select another OpenCode model.`,
+        );
+        throw recoverableFailure;
+      }
       if (
         toolCalls.length === 0 &&
         !displayText.trim() &&
@@ -1930,6 +1948,38 @@ export function streamOpenCode(
       // deleted best-effort and never fails the turn (#71, #75).
       deleteOpenCodeSession(capturedSessionId);
       if (piState) dropOpencodeSession(piState);
+      const remainingMs = deadline - Date.now();
+      if (recoverableFailure && error === recoverableFailure && allowRecovery &&
+          !options?.signal?.aborted && remainingMs > 0 && (!opencodeToolUse || context.tools?.length)) {
+        setEstimatedUsage(model, output, prompt, accumulatedText + accumulatedThinking);
+        const correction = [
+          opencodeToolUse
+            ? `Your previous attempt used the disabled OpenCode native tool ${JSON.stringify(opencodeToolUse)}.`
+            : "Your previous attempt ended with reasoning only, without an answer or Pi tool call. Provide a final answer or request a Pi tool, not just a plan to act.",
+          `Available Pi tools: ${context.tools?.map(tool => tool.name).join(", ") || "none"}.`,
+          "Complete the original request using only those Pi tools. Do not call any OpenCode native tool.",
+          'Request Pi tools as <pi_tool_call>{"name":"tool_name","arguments":{}}</pi_tool_call> markers, or answer normally if no tool is needed.',
+          "If Pi has no grep tool, request a search through Pi bash when it is available instead.",
+        ].join("\n");
+        // A fresh attempt keeps rejected native calls out of the continued transcript.
+        const recovery = streamOpenCodeAttempt(model, {
+          ...context,
+          messages: [...context.messages, { role: "user", content: correction, timestamp: Date.now() }],
+        }, { ...options, timeoutMs: remainingMs }, false);
+        for await (const event of recovery) {
+          if (event.type === "start") continue;
+          const message = event.type === "done" ? event.message : event.type === "error" ? event.error : undefined;
+          if (message) {
+            for (const key of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"] as const) {
+              message.usage[key] += output.usage[key];
+            }
+            calculateCost(model, message.usage);
+          }
+          stream.push(event);
+        }
+        stream.end();
+        return;
+      }
       output.stopReason = options?.signal?.aborted ? "aborted" : "error";
       output.errorMessage =
         error instanceof Error ? error.message : String(error);
@@ -2053,9 +2103,9 @@ export default async function opencodePiExtension(pi: ExtensionAPI) {
       "info",
     );
     const version = /\d+\.\d+\.\d+/.exec(cliStatus.summary)?.[0];
-    if (!version || !VERIFIED_OPENCODE_VERSIONS.includes(version)) {
+    if (!version || version.localeCompare(MAX_SUPPORTED_OPENCODE_VERSION, undefined, { numeric: true }) > 0) {
       ctx.ui.notify(
-        `opencode-pi: OpenCode ${version ?? cliStatus.summary} is not one of ${VERIFIED_OPENCODE_VERSIONS.join(", ")}, the versions the native-tool guard was verified with. Native OpenCode tools may not stay blocked.`,
+        `opencode-pi: detected OpenCode ${version ?? cliStatus.summary}. This bridge supports OpenCode up to ${MAX_SUPPORTED_OPENCODE_VERSION}. Please install a supported version.`,
         "warning",
       );
     }