cartethyia 2.5.10 → 2.6.0

package/src/providers/integrations/cursor/cursor.ts

@@ -17,6 +17,7 @@
 // `rejected` so the model can continue without the gateway ever touching a
 // filesystem or a shell on the caller's behalf.
 import { GatewayError } from "../../../protocol/gateway-error";
+import { asRecord as recordOf } from "../../../shared/coerce";
 import type {
   CanonicalEvent,
   CanonicalRequest,
@@ -60,6 +61,7 @@ import { fetchCursorRunOrigin } from "./cursor-catalog";
 import { defaultParameterValues, fetchCursorModels } from "./cursor-catalog";
 import type { CursorModelInfo } from "./cursor-catalog";
 import { decodeValueToJson, decodeStructEntriesToJson } from "./protocol/struct";
+import { cursorVariantForExecArgs } from "./protocol/tool-canonical";
 
 /**
  * Client-heartbeat cadence for every Cursor Run.
@@ -259,12 +261,6 @@ function usageFromTurnEnded(turnEnded: Record<string, unknown>): UsageRecord {
   };
 }
 
-function recordOf(value: unknown): Record<string, unknown> | undefined {
-  return value !== null && typeof value === "object" && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : undefined;
-}
-
 function nonEmptyStringOf(value: unknown): string | undefined {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
@@ -1093,6 +1089,32 @@ class CursorAdapter implements ProviderAdapter {
       await handle.write(buildAllowlistPrecheckResult(execId, precheckKind, execIdString));
       return { kind: "handled" };
     }
+    // Native first. A Cursor host-exec frame (`read_args`, `shell_args`,
+    // `pi_read_args`, …) is relayed to the client as an ordinary tool call
+    // instead of being refused. This is the half the earlier direct-forward
+    // attempt got wrong: it built typed result frames by hand per variant and
+    // they were not matched by the server. The canonical layer owns that
+    // mapping now, keyed by the originating variant, so a result can only ever
+    // come back in the arm it arrived on.
+    const nativeCall = cursorVariantForExecArgs(execServer);
+    // Only a tool the request actually declared may be relayed. A host frame
+    // for something the client never advertised is an undeclared tool like any
+    // other and keeps the refusal — forwarding it would hand the client a call
+    // it has no handler for and nowhere to send the result.
+    const declaredNative = nativeCall !== undefined &&
+      session.descriptors.some((d) => d.toolName === nativeCall.variant.name);
+    if (nativeCall !== undefined && declaredNative) {
+      return {
+        kind: "tool_call",
+        execId,
+        execIdString,
+        toolName: nativeCall.variant.name,
+        arguments: JSON.stringify(nativeCall.args),
+      };
+    }
+    // MCP is the fallback, not the first stop: client-declared tools have no
+    // native slot in `agent.proto`, so they are the ones that must travel this
+    // channel. An arm neither path claims falls through to the refusal below.
     const mcpArgs = recordOf(execServer["mcp_args"]);
     if (mcpArgs !== undefined) {
       const call = readExecutableMcpCall(mcpArgs, session.descriptors);
@@ -1110,17 +1132,7 @@ class CursorAdapter implements ProviderAdapter {
         arguments: call.arguments,
       };
     }
-    // Host exec frames (shell_args, write_args, read_args, and every other
-    // Cursor-native variant) are not executed here. Cursor's own executor on
-    // the local CLI handles them; the MCP channel is the correct path for tool
-    // calls routed through this gateway.
-    //
-    // A direct-forward path (`readHostExecCall`) was implemented experimentally
-    // but produced protocol errors in practice: the typed result frames it sent
-    // back (shell_result, write_result, read_result) were not matched correctly
-    // by the server under all code paths, causing the Run to stall or the model
-    // to receive malformed tool output. The path has been removed; use MCP.
-    const refusal = "Cursor host tools are not executed by this gateway";
+    const refusal = "this tool is not one the request declared";
     await handle.write(buildExecThrow(execId, refusal, execIdString));
     await handle.write(buildExecStreamClose(execId, execIdString));
     return { kind: "handled" };

package/src/providers/integrations/cursor/protocol/framing.ts

@@ -1,129 +1,129 @@
-/**
- * Vendored from `cursor-opencode-provider` (protocol layer only).
- *
- * MIT License
- *
- * Copyright (c) 2026 Oleksiy Akimov
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-import { gunzipSync, gzipSync } from "node:zlib"
-
-export const FLAG_GZIP = 0x01
-export const FLAG_END_STREAM = 0x02
-
-export type Frame = {
-  flags: number
-  payload: Uint8Array
-}
-
-export function encodeFrame(flags: number, payload: Uint8Array): Uint8Array {
-  let data = payload
-  if (flags & FLAG_GZIP) {
-    data = gzipSync(data)
-  }
-  const len = data.length
-  const header = new Uint8Array(5)
-  header[0] = flags
-  header[1] = (len >> 24) & 0xff
-  header[2] = (len >> 16) & 0xff
-  header[3] = (len >> 8) & 0xff
-  header[4] = len & 0xff
-  const out = new Uint8Array(5 + len)
-  out.set(header, 0)
-  out.set(data, 5)
-  return out
-}
-
-export function decodeFramePayload(frame: Frame): Uint8Array {
-  return frame.flags & FLAG_GZIP ? gunzipSync(frame.payload) : frame.payload
-}
-
-export function* streamFrames(buffer: Uint8Array): Generator<Frame, void, void> {
-  let offset = 0
-  while (offset + 5 <= buffer.length) {
-    const flags = buffer[offset] ?? 0
-    const len =
-      (((buffer[offset + 1] ?? 0) << 24) |
-        ((buffer[offset + 2] ?? 0) << 16) |
-        ((buffer[offset + 3] ?? 0) << 8) |
-        (buffer[offset + 4] ?? 0)) >>> 0
-    const start = offset + 5
-    if (start + len > buffer.length) break
-    yield { flags, payload: buffer.subarray(start, start + len) }
-    offset = start + len
-  }
-}
-
-export async function* asyncStreamFrames(
-  stream: ReadableStream<Uint8Array>,
-): AsyncGenerator<Frame, void, void> {
-  const reader = stream.getReader()
-  const chunks: Uint8Array[] = []
-  let pendingLength = 0
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done && chunks.length === 0) return
-      if (value) {
-        chunks.push(value)
-        pendingLength += value.length
-      }
-
-      // Try to parse frames from accumulated data
-      const merged = mergeChunks(chunks)
-      const frames = Array.from(streamFrames(merged))
-      const consumed = frames.reduce((sum, f) => sum + 5 + f.payload.length, 0)
-
-      if (frames.length > 0) {
-        for (const frame of frames) {
-          yield frame
-        }
-        // Keep any trailing bytes for next iteration
-        const remaining = merged.subarray(consumed)
-        chunks.length = 0
-        if (remaining.length > 0) {
-          chunks.push(remaining)
-          pendingLength = remaining.length
-        } else {
-          pendingLength = 0
-        }
-      }
-
-      if (done) return
-    }
-  } finally {
-    reader.releaseLock()
-  }
-}
-
-function mergeChunks(chunks: Uint8Array[]): Uint8Array {
-  const first = chunks[0]
-  if (chunks.length === 1 && first !== undefined) return first
-  const total = chunks.reduce((s, c) => s + c.length, 0)
-  const merged = new Uint8Array(total)
-  let offset = 0
-  for (const c of chunks) {
-    merged.set(c, offset)
-    offset += c.length
-  }
-  return merged
-}
+/**
+ * Vendored from `cursor-opencode-provider` (protocol layer only).
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Oleksiy Akimov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { gunzipSync, gzipSync } from "node:zlib"
+
+export const FLAG_GZIP = 0x01
+export const FLAG_END_STREAM = 0x02
+
+export type Frame = {
+  flags: number
+  payload: Uint8Array
+}
+
+export function encodeFrame(flags: number, payload: Uint8Array): Uint8Array {
+  let data = payload
+  if (flags & FLAG_GZIP) {
+    data = gzipSync(data)
+  }
+  const len = data.length
+  const header = new Uint8Array(5)
+  header[0] = flags
+  header[1] = (len >> 24) & 0xff
+  header[2] = (len >> 16) & 0xff
+  header[3] = (len >> 8) & 0xff
+  header[4] = len & 0xff
+  const out = new Uint8Array(5 + len)
+  out.set(header, 0)
+  out.set(data, 5)
+  return out
+}
+
+export function decodeFramePayload(frame: Frame): Uint8Array {
+  return frame.flags & FLAG_GZIP ? gunzipSync(frame.payload) : frame.payload
+}
+
+export function* streamFrames(buffer: Uint8Array): Generator<Frame, void, void> {
+  let offset = 0
+  while (offset + 5 <= buffer.length) {
+    const flags = buffer[offset] ?? 0
+    const len =
+      (((buffer[offset + 1] ?? 0) << 24) |
+        ((buffer[offset + 2] ?? 0) << 16) |
+        ((buffer[offset + 3] ?? 0) << 8) |
+        (buffer[offset + 4] ?? 0)) >>> 0
+    const start = offset + 5
+    if (start + len > buffer.length) break
+    yield { flags, payload: buffer.subarray(start, start + len) }
+    offset = start + len
+  }
+}
+
+export async function* asyncStreamFrames(
+  stream: ReadableStream<Uint8Array>,
+): AsyncGenerator<Frame, void, void> {
+  const reader = stream.getReader()
+  const chunks: Uint8Array[] = []
+  let pendingLength = 0
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done && chunks.length === 0) return
+      if (value) {
+        chunks.push(value)
+        pendingLength += value.length
+      }
+
+      // Try to parse frames from accumulated data
+      const merged = mergeChunks(chunks)
+      const frames = Array.from(streamFrames(merged))
+      const consumed = frames.reduce((sum, f) => sum + 5 + f.payload.length, 0)
+
+      if (frames.length > 0) {
+        for (const frame of frames) {
+          yield frame
+        }
+        // Keep any trailing bytes for next iteration
+        const remaining = merged.subarray(consumed)
+        chunks.length = 0
+        if (remaining.length > 0) {
+          chunks.push(remaining)
+          pendingLength = remaining.length
+        } else {
+          pendingLength = 0
+        }
+      }
+
+      if (done) return
+    }
+  } finally {
+    reader.releaseLock()
+  }
+}
+
+function mergeChunks(chunks: Uint8Array[]): Uint8Array {
+  const first = chunks[0]
+  if (chunks.length === 1 && first !== undefined) return first
+  const total = chunks.reduce((s, c) => s + c.length, 0)
+  const merged = new Uint8Array(total)
+  let offset = 0
+  for (const c of chunks) {
+    merged.set(c, offset)
+    offset += c.length
+  }
+  return merged
+}