pi-opencode-cli-bridge 0.2.7 → 0.2.8

package/README.md

@@ -120,16 +120,18 @@ Without an override, discovery selects active `opencode/` models whose reported
 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 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.
+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, with incomplete blocks rejected rather than executed.
 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.
+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. The bridge always captures CLI reasoning blocks internally, even when Pi thinking is off or unset, so hidden reasoning can still trigger recovery or supply a valid Pi call. This uses the CLI's display flag, not a higher model reasoning variant. Reasoning is shown in Pi only when a non-off thinking level is requested.
+
+Rejected malformed Pi markers, invalid tool-call payloads and incomplete DeepSeek DSML calls also get a fresh attempt to regenerate the call, rather than a generic empty-response error. The bridge does not execute rejected calls or infer missing arguments; valid sibling calls and remaining prose retain their existing behavior. Unavailable Pi tools still fail without retry. Reasoning-only, malformed-call 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.
 - `onResponse` is called once the subprocess has started, with `status: 0` (no HTTP status exists) and the header `x-pi-transport: opencode-cli`.
-- `onProviderStreamEvent` receives each validated `--format json` event in order, and is awaited before the event is processed.
+- `onProviderStreamEvent` receives each validated `--format json` event in order, and is awaited before the event is processed. Raw observers can receive reasoning events even when thinking is hidden in Pi; the display setting does not redact transport instrumentation.
 - 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, and includes both attempts when recovery is needed. Session records and temporary project directories are cleaned up on a best-effort basis.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-opencode-cli-bridge",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Bridge the OpenCode CLI into Pi Coding Agent",
   "type": "module",
   "main": "./src/index.ts",
@@ -15,7 +15,7 @@
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "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",
+    "test:integration": "npm run build && node --test --test-timeout=240000 dist/native-tools.integration.test.js",
     "prepublishOnly": "npm run typecheck && npm test && npm run test:integration"
   },
   "pi": {

package/src/index.ts

@@ -264,9 +264,9 @@ export function reasoningCliArgs(
   requestedReasoning: ModelThinkingLevel | undefined,
   map?: ThinkingLevelMap,
 ): string[] {
-  if (!requestedReasoning || requestedReasoning === "off") return [];
-
+  // Capture blocks for recovery; --thinking controls CLI output, not model effort.
   const args = ["--thinking"];
+  if (!requestedReasoning || requestedReasoning === "off") return args;
   const variant = map?.[requestedReasoning];
   if (typeof variant === "string" && variant.trim()) {
     args.push("--variant", variant);
@@ -1108,11 +1108,11 @@ export function parseToolCallResponse(
   }
 
   if (strippedSpans.length === 0) return { ok: true, calls: parsed };
-  return {
-    ok: true,
-    calls: parsed,
-    cleanedText: stripMarkerSpans(normalizedText, strippedSpans),
-  };
+  const cleanedText = stripMarkerSpans(normalizedText.trim(), strippedSpans);
+  if (parsed.length === 0 && !cleanedText.trim()) {
+    return { ok: false, rejection: { reason: "malformed_markers" } };
+  }
+  return { ok: true, calls: parsed, cleanedText };
 }
 
 export function parseToolCalls(
@@ -1148,7 +1148,7 @@ function toolCallRejectionMessage(
     case "invalid_payload":
       return 'OpenCode returned an invalid Pi tool-call payload. Each marker must contain valid JSON with a non-empty string "name" and object "arguments".';
     case "incomplete_dsml":
-      return 'OpenCode returned an incomplete DeepSeek DSML tool call. Pi tools must be requested with <pi_tool_call>{"name":"...","arguments":{}}</pi_tool_call> markers.';
+      return "OpenCode returned an incomplete DeepSeek DSML tool call.";
     case "unavailable_tool": {
       const available = [...allowedToolNames].map((name) =>
         JSON.stringify(name),
@@ -1544,6 +1544,7 @@ function streamOpenCodeAttempt(
     let capturedSessionId: string | undefined;
     let opencodeToolUse: string | undefined;
     let recoverableFailure: Error | undefined;
+    let toolCallFailure: Extract<ToolCallParseResult, { ok: false }> | undefined;
     // Text after the last blocked native call shows whether the model recovered in-run.
     let nativeTextMark = 0;
     let stepNativeCalls: (ParsedToolCall | undefined)[] = [];
@@ -1778,6 +1779,7 @@ function streamOpenCodeAttempt(
         allowedToolNames,
       );
       if (!toolCallResult.ok) {
+        toolCallFailure = toolCallResult;
         throw new Error(
           toolCallRejectionMessage(toolCallResult, allowedToolNames),
         );
@@ -1798,6 +1800,7 @@ function streamOpenCodeAttempt(
           reasoningResult = { ok: false, rejection: { reason: "malformed_markers" } };
         }
         if (!reasoningResult.ok) {
+          toolCallFailure = reasoningResult;
           throw new Error(
             toolCallRejectionMessage(reasoningResult, allowedToolNames),
           );
@@ -1866,7 +1869,7 @@ function streamOpenCodeAttempt(
         deleteOpenCodeSession(capturedSessionId);
       }
 
-      if (accumulatedThinking) {
+      if (accumulatedThinking && requestedReasoning && requestedReasoning !== "off") {
         const thinkingIndex = output.content.length;
         output.content.push({ type: "thinking", thinking: accumulatedThinking });
         stream.push({
@@ -1943,6 +1946,10 @@ function streamOpenCodeAttempt(
       stream.push({ type: "done", reason: finishReason, message: output });
       stream.end();
     } catch (error) {
+      if (toolCallFailure && toolCallFailure.rejection.reason !== "unavailable_tool" && error instanceof Error) {
+        recoverableFailure = error;
+        if (!allowRecovery) error.message += " Recovery failed after one attempt.";
+      }
       // Any error, timeout, or abort drops the session ID so the next turn
       // starts fresh with the full transcript; the failed session record is
       // deleted best-effort and never fails the turn (#71, #75).
@@ -1953,9 +1960,11 @@ function streamOpenCodeAttempt(
           !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.",
+          toolCallFailure
+            ? `Your previous attempt returned a malformed Pi tool call. ${recoverableFailure.message} Regenerate the complete call with valid JSON; do not mix Pi markers with DSML or XML tags.`
+            : 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.',