pi-opencode-cli-bridge 0.2.0 → 0.2.1

package/README.md

@@ -116,7 +116,7 @@ Without an override, discovery selects active models whose reported input and ou
 3. It creates a temporary OpenCode project containing a `pi-model` agent and a `tool.execute.before` plugin. Native tool declarations remain on the request. Execution is stopped twice: the plugin throws before any native tool runs, and the agent sets every permission to `ask`, which non-interactive `opencode run` rejects automatically. The second layer still holds if the plugin is missing or fails to load.
 4. It sends the prompt over standard input to `opencode run --format json`. 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`, `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.
-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.
+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.
 
 Pi's provider instrumentation hooks follow the CLI transport, not OpenCode's internal HTTP traffic:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-opencode-cli-bridge",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Bridge the OpenCode CLI into Pi Coding Agent",
   "type": "module",
   "main": "./src/index.ts",

package/src/index.ts

@@ -100,6 +100,7 @@ export type ToolCallParseResult =
       rejection:
         | { reason: "malformed_markers" }
         | { reason: "invalid_payload" }
+        | { reason: "incomplete_dsml" }
         | { reason: "unavailable_tool"; toolName: string };
     };
 
@@ -948,11 +949,70 @@ function stripMarkerSpans(text: string, spans: MarkerSpan[]): string {
   return cleaned;
 }
 
+// DeepSeek sometimes ignores the markers and writes its native DSML tool-call
+// syntax as plain text. Each complete block is rewritten in place as markers,
+// so call order and the tool-list check stay those of the marker parser.
+const DSML = String.raw`[｜|]+\s*DSML\s*[｜|]+`;
+const DSML_TAG = new RegExp(String.raw`<\/?${DSML}`);
+const DSML_BLOCK = new RegExp(String.raw`^<${DSML}(?:tool|function)_calls>([\s\S]*?)<\/${DSML}(?:tool|function)_calls>`);
+const DSML_INVOKE = new RegExp(String.raw`<${DSML}invoke\s+name="([^"]+)"\s*>([\s\S]*?)<\/${DSML}invoke>`, "g");
+const DSML_PARAMETER = new RegExp(String.raw`<${DSML}parameter\s+name="([^"]+)"(?:\s+string="(true|false)")?\s*>([\s\S]*?)<\/${DSML}parameter>`, "g");
+
+function dsmlBlockToMarkers(body: string): string {
+  let markers = "";
+  for (const [, name, params] of body.matchAll(DSML_INVOKE)) {
+    const args: Record<string, unknown> = {};
+    for (const [, key, isString, raw] of params.matchAll(DSML_PARAMETER)) {
+      if (isString === "true") {
+        args[key] = raw;
+        continue;
+      }
+      try {
+        args[key] = JSON.parse(raw);
+      } catch {
+        args[key] = raw;
+      }
+    }
+    markers += `${MARKER_OPEN}${JSON.stringify({ name, arguments: args })}</pi_tool_call>`;
+  }
+  return markers;
+}
+
+// Scans left to right and consumes whichever starts first, a marker or a DSML
+// block, so each keeps the other's syntax intact inside its own arguments.
+// Returns undefined for a truncated DSML block, which would otherwise end the
+// turn silently or let Pi run only the calls before it.
+function dsmlToMarkers(text: string): string | undefined {
+  let result = "";
+  let rest = text;
+  for (;;) {
+    const dsmlAt = rest.search(DSML_TAG);
+    const markerAt = rest.indexOf(MARKER_OPEN);
+    if (dsmlAt < 0) return result + rest;
+    if (markerAt >= 0 && markerAt < dsmlAt) {
+      // The slice starts at the marker, so trimming cannot shift its span.
+      const extraction = toolCallMarkers(rest.slice(markerAt));
+      const span = [...(extraction?.markers ?? []), ...(extraction?.invalidSpans ?? [])].find((s) => s.start === 0);
+      const end = markerAt + (span?.end ?? MARKER_OPEN.length);
+      result += rest.slice(0, end);
+      rest = rest.slice(end);
+      continue;
+    }
+    const block = DSML_BLOCK.exec(rest.slice(dsmlAt));
+    if (!block) return undefined;
+    result += rest.slice(0, dsmlAt) + dsmlBlockToMarkers(block[1]);
+    rest = rest.slice(dsmlAt + block[0].length);
+  }
+}
+
 export function parseToolCallResponse(
   text: string,
   allowedToolNames?: ReadonlySet<string>,
 ): ToolCallParseResult {
-  const normalizedText = normalizeQuotedToolCallResponse(text);
+  const normalizedText = dsmlToMarkers(normalizeQuotedToolCallResponse(text));
+  if (normalizedText === undefined) {
+    return { ok: false, rejection: { reason: "incomplete_dsml" } };
+  }
   if (!isToolCallMarkerResponse(normalizedText)) return { ok: true, calls: [] };
 
   const extraction = toolCallMarkers(normalizedText);
@@ -1032,6 +1092,8 @@ function toolCallRejectionMessage(
       return "OpenCode returned malformed Pi tool-call markers. Ensure each marker contains valid JSON with a string \"name\" and object \"arguments\".";
     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.';
     case "unavailable_tool": {
       const available = [...allowedToolNames].map((name) =>
         JSON.stringify(name),