@sideboard-ai/core 0.1.262 → 0.1.264

package/dist/agents/claude-runner.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import {
+  AGENT_RPC_CLAUDE_SDK_SERVER,
+  PILOT_TOOL_DESCRIPTIONS,
+  createPilotRpcExecutors
+} from "../chunk-NYBFYFK7.js";
+import {
+  dropNestedElectronEnvFromProcess
+} from "../chunk-4TR3HZFT.js";
+import "../chunk-EHT2DRT4.js";
+
+// src/agents/claude-runner.ts
+import { createInterface } from "readline";
+
+// src/agents/claude-sdk-tools.ts
+import { z } from "zod";
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function createClaudePilotSdkServer(createSdkMcpServer, tool, opts) {
+  const exec = createPilotRpcExecutors(opts);
+  const server = createSdkMcpServer({
+    name: AGENT_RPC_CLAUDE_SDK_SERVER,
+    version: "1.0.0",
+    timeout: 18e4,
+    tools: [
+      tool(
+        "present_artifact",
+        PILOT_TOOL_DESCRIPTIONS.present_artifact,
+        {
+          title: z.string(),
+          type: z.enum(["html", "svg", "markdown", "react", "log"]),
+          content: z.string(),
+          artifact_id: z.string().optional(),
+          status: z.enum(["running", "ok", "failed", "idle"]).optional(),
+          phase: z.string().optional(),
+          mode: z.enum(["append", "replace"]).optional()
+        },
+        async (args) => textResult(await exec.present_artifact(args))
+      ),
+      tool(
+        "wait_for_job",
+        PILOT_TOOL_DESCRIPTIONS.wait_for_job,
+        { id: z.string() },
+        async (args) => textResult(await exec.wait_for_job(args))
+      ),
+      tool(
+        "stop_job",
+        PILOT_TOOL_DESCRIPTIONS.stop_job,
+        { id: z.string(), reason: z.string().optional() },
+        async (args) => textResult(await exec.stop_job(args))
+      )
+    ]
+  });
+  return { server, exec };
+}
+
+// src/agents/claude-runner.ts
+dropNestedElectronEnvFromProcess();
+function emit(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+async function readStdin() {
+  const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
+  const chunks = [];
+  for await (const line of rl) chunks.push(line);
+  return chunks.join("\n").trim();
+}
+async function main() {
+  const raw = await readStdin();
+  if (!raw) {
+    emit({ type: "stderr", data: "claude-runner: empty stdin" });
+    process.exitCode = 1;
+    return;
+  }
+  const req = JSON.parse(raw);
+  if (!req.prompt || !req.cwd || !req.agentRpc || !req.claudePath) {
+    emit({ type: "stderr", data: "claude-runner: prompt, cwd, claudePath, and agentRpc are required" });
+    process.exitCode = 1;
+    return;
+  }
+  let sdk;
+  try {
+    sdk = await import("@anthropic-ai/claude-agent-sdk");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    emit({
+      type: "stderr",
+      data: `claude-runner: @anthropic-ai/claude-agent-sdk is required (${message})`
+    });
+    process.exitCode = 1;
+    return;
+  }
+  const { server, exec } = createClaudePilotSdkServer(
+    sdk.createSdkMcpServer,
+    sdk.tool,
+    { cwd: req.cwd, rpc: req.agentRpc }
+  );
+  const mcpServers = {
+    [AGENT_RPC_CLAUDE_SDK_SERVER]: server
+  };
+  for (const [name, spec] of Object.entries(req.mcpServers ?? {})) {
+    mcpServers[name] = spec;
+  }
+  try {
+    const options = {
+      cwd: req.cwd,
+      pathToClaudeCodeExecutable: req.claudePath,
+      permissionMode: req.permissionMode,
+      allowedTools: req.allowedTools,
+      mcpServers,
+      includePartialMessages: true
+    };
+    if (req.sessionId) options.resume = req.sessionId;
+    if (req.model) options.model = req.model;
+    if (req.systemPrompt) options.appendSystemPrompt = req.systemPrompt;
+    if (req.effort) options.effort = req.effort;
+    if (req.chrome) options.chrome = true;
+    options.settingSources = [];
+    for await (const message of sdk.query({ prompt: req.prompt, options })) {
+      emit(message);
+    }
+  } finally {
+    exec.close();
+  }
+}
+main().catch((err) => {
+  emit({
+    type: "stderr",
+    data: err instanceof Error ? err.message : String(err)
+  });
+  process.exitCode = 1;
+});

package/dist/agents/cursor-runner.cjs

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/agents/cursor-runner.ts
-var import_node_fs16 = require("fs");
+var import_node_fs17 = require("fs");
 var import_node_readline2 = require("readline");
 
 // src/hook/nested-electron-env.ts
@@ -716,9 +716,365 @@ function slicedReadCustomToolConfig(cwd) {
   };
 }
 
-// src/agents/tool-result-clip.ts
+// src/agent-rpc/client.ts
+var import_ws = require("ws");
+
+// src/agent-rpc/protocol.ts
+var AGENT_RPC_PROTOCOL_VERSION = 1;
+var AGENT_RPC_TOKEN_QUERY = "authToken";
+function isJsonRpcNotification(value) {
+  if (!value || typeof value !== "object") return false;
+  const rec = value;
+  if (rec.jsonrpc !== "2.0") return false;
+  if (typeof rec.method !== "string" || !rec.method.trim()) return false;
+  if ("id" in rec && rec.id !== void 0) return false;
+  if ("error" in rec || "result" in rec) return false;
+  return true;
+}
+function parseRpcFrame(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/agent-rpc/metadata.ts
 var import_node_fs15 = require("fs");
 var import_node_path17 = require("path");
+function agentRuntimeMetadataPath() {
+  return (0, import_node_path17.join)(appDataDir(), "agent-runtime.json");
+}
+function readAgentRuntimeMetadata() {
+  try {
+    const raw = JSON.parse((0, import_node_fs15.readFileSync)(agentRuntimeMetadataPath(), "utf8"));
+    if (!raw || typeof raw !== "object") return null;
+    const rec = raw;
+    if (typeof rec.runtimeId !== "string" || !rec.runtimeId.trim()) return null;
+    if (typeof rec.authToken !== "string" || !rec.authToken.trim()) return null;
+    const pid = Number(rec.pid);
+    if (!Number.isInteger(pid) || pid <= 0) return null;
+    const transports = Array.isArray(rec.transports) ? rec.transports : [];
+    const ws = transports.filter((t) => {
+      if (!t || typeof t !== "object") return false;
+      const row = t;
+      return row.kind === "websocket" && typeof row.url === "string" && Boolean(row.url.trim());
+    });
+    return {
+      runtimeId: rec.runtimeId.trim(),
+      pid,
+      protocolVersion: Number(rec.protocolVersion) || AGENT_RPC_PROTOCOL_VERSION,
+      authToken: rec.authToken,
+      startedAt: Number(rec.startedAt) || 0,
+      transports: ws
+    };
+  } catch {
+    return null;
+  }
+}
+function websocketUrlFromMetadata(meta) {
+  const url = meta?.transports.find((t) => t.kind === "websocket")?.url?.trim();
+  return url || null;
+}
+function agentRpcConnectFromMetadata(meta = readAgentRuntimeMetadata()) {
+  if (!agentRuntimeLooksLive(meta)) return null;
+  const url = websocketUrlFromMetadata(meta);
+  const authToken = meta?.authToken;
+  if (!url || !authToken) return null;
+  return { url, authToken };
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function agentRuntimeLooksLive(meta = readAgentRuntimeMetadata()) {
+  if (!meta) return false;
+  return pidAlive(meta.pid);
+}
+
+// src/agent-rpc/client.ts
+var AgentRpcClient = class {
+  ws = null;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  url;
+  authToken;
+  notifyListeners = /* @__PURE__ */ new Set();
+  constructor(opts = {}) {
+    const connect = opts.url && opts.authToken ? { url: opts.url, authToken: opts.authToken } : agentRpcConnectFromMetadata();
+    if (!connect) throw new Error("Agent RPC runtime is not running (no live agent-runtime.json)");
+    this.url = connect.url;
+    this.authToken = connect.authToken;
+  }
+  onNotify(fn) {
+    this.notifyListeners.add(fn);
+    return () => this.notifyListeners.delete(fn);
+  }
+  async call(method, params) {
+    const ws = await this.ensureSocket();
+    const id = this.nextId;
+    this.nextId += 1;
+    const key = String(id);
+    const payload = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params,
+      authToken: this.authToken
+    };
+    return new Promise((resolve2, reject) => {
+      this.pending.set(key, { resolve: resolve2, reject });
+      try {
+        ws.send(JSON.stringify(payload));
+      } catch (err) {
+        this.pending.delete(key);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  socketUrl() {
+    const url = new URL(this.url);
+    url.searchParams.set(AGENT_RPC_TOKEN_QUERY, this.authToken);
+    return url.toString();
+  }
+  async ensureSocket() {
+    if (this.ws && this.ws.readyState === import_ws.WebSocket.OPEN) return this.ws;
+    const ws = new import_ws.WebSocket(this.socketUrl());
+    this.ws = ws;
+    ws.on("message", (data) => this.onFrame(data.toString()));
+    ws.on("error", (err) => this.drop(ws, err));
+    ws.on("close", () => this.drop(ws, new Error("Agent RPC socket closed")));
+    ws.on("unexpected-response", (_req, res) => {
+      res.resume();
+      this.drop(
+        ws,
+        new Error(
+          res.statusCode === 401 ? "Unauthorized" : `Unexpected server response: ${res.statusCode}`
+        )
+      );
+    });
+    await new Promise((resolve2, reject) => {
+      const fail = (err) => {
+        const message = err.message.includes("401") ? "Unauthorized" : err.message;
+        reject(message === err.message ? err : new Error(message));
+      };
+      ws.once("unexpected-response", (_req, res) => {
+        fail(
+          new Error(
+            res.statusCode === 401 ? "Unauthorized" : `Unexpected server response: ${res.statusCode}`
+          )
+        );
+      });
+      ws.once("error", fail);
+      ws.once("open", () => {
+        ws.off("error", fail);
+        resolve2();
+      });
+    });
+    return ws;
+  }
+  drop(ws, err) {
+    if (this.ws === ws) this.ws = null;
+    if (this.pending.size === 0) return;
+    this.failAll(err);
+  }
+  onFrame(raw) {
+    const parsed = parseRpcFrame(raw);
+    if (parsed === void 0) return;
+    if (isJsonRpcNotification(parsed)) {
+      for (const fn of this.notifyListeners) fn(parsed);
+      return;
+    }
+    if (!parsed || typeof parsed !== "object") return;
+    const rec = parsed;
+    if (rec.id === void 0 || rec.id === null) return;
+    const key = String(rec.id);
+    const waiter = this.pending.get(key);
+    if (!waiter) return;
+    this.pending.delete(key);
+    if (rec.error && typeof rec.error === "object") {
+      const err = rec.error;
+      waiter.reject(new Error(err.message || "Agent RPC error"));
+      return;
+    }
+    waiter.resolve(rec.result);
+  }
+  failAll(err) {
+    for (const waiter of this.pending.values()) waiter.reject(err);
+    this.pending.clear();
+  }
+  close() {
+    const ws = this.ws;
+    this.ws = null;
+    this.failAll(new Error("Agent RPC client closed"));
+    if (ws) {
+      try {
+        ws.close();
+      } catch {
+      }
+    }
+  }
+};
+
+// src/agent-rpc/pilot-tools.ts
+var PILOT_TOOL_DESCRIPTIONS = {
+  present_artifact: "Show a document or live log in Sideboard\u2019s side column. For html/svg/markdown/react, pass the FULL document and do not also fence that same body in chat. For type=log, pass only NEW lines (same artifact_id appends). Prefer type=log for long-running job output \u2014 do not resend HTML. type=react is a single default-export component (JSX/TSX); only react/react-dom imports.",
+  wait_for_job: "Wait until a detached long job (tests, pack, deploy, connector CLI) finishes. This call stays open for up to ~2 minutes. stillRunning true means the runtime hit the max hold; call wait_for_job again immediately. If the job is hanging, producing no useful output, or doing the wrong thing, call stop_job instead. Do not end the turn or tell the user you will let them know later.",
+  stop_job: "Stop a detached job you started with detached-job.cjs when it is hanging, producing no useful output, buffering forever, or doing the wrong thing (wrong project, infinite watch, huge dump). Do not stop a pack/test/deploy that is clearly making progress."
+};
+var WAIT_FOR_TURN_DESCRIPTION = "Wait until the chat finishes its current/queued turn, or return early with a live progress snapshot. This call stays open for up to ~2 minutes. taskState is the A2A-style lifecycle: submitted (queued, not started), working, input-required (ask_user), completed, failed, canceled. stillRunning is true only for submitted/working. If stillRunning, text and usage are empty (they would be the previous turn) \u2014 read progress and call wait_for_turn again. Do not send_to_chat a check-in (that steers / interrupts). On failed, lastError/text is the failure. On canceled, the child did not finish \u2014 resume with send_to_chat or tell the user. On input-required, wait for the user in that chat. When finished, text is this turn\u2019s assistant reply and usage is that turn\u2019s tokens + costUsd (this turn, not the Claude session total; sessionCostUsd is the provider session total when present). lastActivityAt is the latest transcript/live stamp \u2014 present after the turn completes, not only while it is running.";
+var WAIT_FOR_TURN_SCHEMA = {
+  type: "object",
+  properties: {
+    ref: {
+      type: "string",
+      description: "Worktree thread id or ref to wait on (not the orchestrator)"
+    },
+    timeoutMs: {
+      type: "number",
+      description: "Optional cap for this hold (ms). Ignored above the runtime max (~2 minutes)."
+    }
+  },
+  required: ["ref"]
+};
+var PILOT_TOOL_SCHEMAS = {
+  present_artifact: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "Short title shown in the artifact pane header"
+      },
+      type: {
+        type: "string",
+        enum: ["html", "svg", "markdown", "react", "log"],
+        description: "html/svg/markdown/react replace the pane. log appends content to the same artifact_id (new lines only)."
+      },
+      content: {
+        type: "string",
+        description: "html/svg/markdown/react: full document. log: only the new lines since the last call (empty is ok for a status-only update)."
+      },
+      artifact_id: {
+        type: "string",
+        description: "Stable id. Required for type=log so later calls append to the same pane."
+      },
+      status: {
+        type: "string",
+        enum: ["running", "ok", "failed", "idle"]
+      },
+      phase: { type: "string" },
+      mode: { type: "string", enum: ["append", "replace"] }
+    },
+    required: ["title", "type", "content"]
+  },
+  wait_for_job: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: "Detached job id (same kebab-case id passed to detached-job.cjs start)"
+      }
+    },
+    required: ["id"]
+  },
+  stop_job: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: "Detached job id (same kebab-case id passed to detached-job.cjs start)"
+      },
+      reason: { type: "string" }
+    },
+    required: ["id"]
+  }
+};
+function jsonToolResult(value) {
+  return JSON.stringify(value);
+}
+function jsonToolError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return jsonToolResult({ ok: false, error: message });
+}
+function createPilotRpcExecutors(opts) {
+  const client = new AgentRpcClient(opts.rpc);
+  let waitToolCallId;
+  if (opts.onProgress) {
+    const onProgress = opts.onProgress;
+    client.onNotify((msg) => {
+      if (msg.method === "runtime.progress") onProgress(msg.params, waitToolCallId);
+    });
+  }
+  const call = async (method, args) => {
+    try {
+      return jsonToolResult(await client.call(method, args));
+    } catch (err) {
+      return jsonToolError(err);
+    }
+  };
+  const callJob = (method, args) => call(method, { ...args, cwd: opts.cwd });
+  return {
+    present_artifact: (args) => call("ui.presentArtifact", args),
+    wait_for_job: async (args, context) => {
+      const prev = waitToolCallId;
+      waitToolCallId = typeof context?.toolCallId === "string" ? context.toolCallId : void 0;
+      try {
+        return await callJob("job.wait", args);
+      } finally {
+        waitToolCallId = prev;
+      }
+    },
+    stop_job: (args) => callJob("job.stop", args),
+    wait_for_turn: async (args, context) => {
+      const prev = waitToolCallId;
+      waitToolCallId = typeof context?.toolCallId === "string" ? context.toolCallId : void 0;
+      try {
+        return await call("turn.wait", args);
+      } finally {
+        waitToolCallId = prev;
+      }
+    },
+    close: () => client.close()
+  };
+}
+
+// src/agent-rpc/cursor-tools.ts
+function sideboardCursorRpcTools(opts) {
+  const exec = createPilotRpcExecutors(opts);
+  const tools = {
+    present_artifact: {
+      description: PILOT_TOOL_DESCRIPTIONS.present_artifact,
+      inputSchema: PILOT_TOOL_SCHEMAS.present_artifact,
+      execute: exec.present_artifact
+    },
+    wait_for_job: {
+      description: PILOT_TOOL_DESCRIPTIONS.wait_for_job,
+      inputSchema: PILOT_TOOL_SCHEMAS.wait_for_job,
+      execute: exec.wait_for_job
+    },
+    stop_job: {
+      description: PILOT_TOOL_DESCRIPTIONS.stop_job,
+      inputSchema: PILOT_TOOL_SCHEMAS.stop_job,
+      execute: exec.stop_job
+    }
+  };
+  if (opts.includeWaitForTurn) {
+    tools.wait_for_turn = {
+      description: WAIT_FOR_TURN_DESCRIPTION,
+      inputSchema: WAIT_FOR_TURN_SCHEMA,
+      execute: exec.wait_for_turn
+    };
+  }
+  return tools;
+}
+
+// src/agents/tool-result-clip.ts
+var import_node_fs16 = require("fs");
+var import_node_path18 = require("path");
 
 // src/paths/workspace-scratch.ts
 var CLI_DIR = ".context/cli";
@@ -727,15 +1083,15 @@ var CLI_DIR = ".context/cli";
 function spillPath(cwd, prefix) {
   const stamp = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   const safe = prefix.replace(/[^a-zA-Z0-9_-]+/g, "-").slice(0, 40) || "tool";
-  return (0, import_node_path17.join)(cwd, CLI_DIR, `${safe}-${stamp}.txt`);
+  return (0, import_node_path18.join)(cwd, CLI_DIR, `${safe}-${stamp}.txt`);
 }
 function spillToolResultToCli(content, opts) {
   const cwd = opts?.cwd?.trim();
   if (!cwd || !content) return null;
   const file = spillPath(cwd, opts?.prefix ?? "tool-result");
   try {
-    (0, import_node_fs15.mkdirSync)((0, import_node_path17.join)(cwd, CLI_DIR), { recursive: true });
-    (0, import_node_fs15.writeFileSync)(file, content, "utf8");
+    (0, import_node_fs16.mkdirSync)((0, import_node_path18.join)(cwd, CLI_DIR), { recursive: true });
+    (0, import_node_fs16.writeFileSync)(file, content, "utf8");
     return file;
   } catch {
     return null;
@@ -1062,11 +1418,18 @@ function cursorDeltaToEvents(update) {
 function buildCursorModelSelection(model, opts) {
   const raw = model && model.trim() || "";
   const id = !raw || raw.toLowerCase() === "auto" || raw.toLowerCase() === "default" ? "default" : raw;
+  const isGrok47 = /^grok-4\.7(?:$|-)/i.test(id);
   const params = [];
+  if (isGrok47) {
+    params.push({ id: "context", value: "256k" });
+  }
   const effort = (opts.effort ?? "").trim().toLowerCase();
   const normalized = effort === "normal" ? "medium" : effort === "low" || effort === "medium" || effort === "high" || effort === "xhigh" || effort === "max" ? effort : "";
   if (normalized) {
-    params.push({ id: "effort", value: normalized });
+    params.push({
+      id: isGrok47 ? "reasoning_effort" : "effort",
+      value: isGrok47 && normalized === "max" ? "xhigh" : normalized
+    });
   }
   params.push({ id: "fast", value: opts.fast ? "true" : "false" });
   return { id, params };
@@ -1139,7 +1502,7 @@ function emit(event) {
 }
 function localAgentStore(Store, threadId) {
   const root = cursorSdkStoreDir(threadId);
-  (0, import_node_fs16.mkdirSync)(root, { recursive: true });
+  (0, import_node_fs17.mkdirSync)(root, { recursive: true });
   return new Store(root);
 }
 async function cancelStaleLocalRuns(Agent, agentId, opts) {
@@ -1210,8 +1573,29 @@ async function main() {
   const mode = req.planMode ? "plan" : "agent";
   const store = localAgentStore(JsonlLocalAgentStore, req.threadId);
   const isolateSources = [];
+  let onRpcProgress = () => {
+  };
+  const rpcTools = req.agentRpc ? sideboardCursorRpcTools({
+    cwd: req.cwd,
+    rpc: req.agentRpc,
+    includeWaitForTurn: Boolean(req.rpcWaitForTurn),
+    onProgress: (params, toolCallId) => {
+      onRpcProgress();
+      if (!toolCallId) return;
+      try {
+        emit({
+          type: "tool_result",
+          id: toolCallId,
+          content: JSON.stringify(params),
+          partial: true
+        });
+      } catch {
+      }
+    }
+  }) : {};
   const customTools = {
-    read: slicedReadCustomToolConfig(req.cwd)
+    read: slicedReadCustomToolConfig(req.cwd),
+    ...rpcTools
   };
   const local = withCursorLocalHangGuards({
     cwd: req.cwd,
@@ -1306,6 +1690,7 @@ async function main() {
     const bump = () => {
       activity.at = Date.now();
     };
+    onRpcProgress = bump;
     let usageBefore = null;
     try {
       usageBefore = await agent.getUsage();

package/dist/agents/cursor-runner.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import {
-  clipAgentEventForEmit
-} from "../chunk-HHEKVR6C.js";
+  clipAgentEventForEmit,
+  sideboardCursorRpcTools
+} from "../chunk-F5MFNUAA.js";
 import {
   createAgentStreamCoalescer
 } from "../chunk-AXQ4ZWHK.js";
@@ -19,15 +20,16 @@ import {
   importCursorSdk,
   looksLikeCursorHttp2StreamClose,
   resolveCursorSdkRoot
-} from "../chunk-WV7KJH2E.js";
+} from "../chunk-A5SAYFJ4.js";
 import "../chunk-6K64FJDD.js";
+import {
+  cursorSdkStoreDir
+} from "../chunk-UWQ6UCIB.js";
 import "../chunk-QVN2WOKJ.js";
+import "../chunk-NYBFYFK7.js";
 import {
   dropNestedElectronEnvFromProcess
 } from "../chunk-4TR3HZFT.js";
-import {
-  cursorSdkStoreDir
-} from "../chunk-UWQ6UCIB.js";
 import "../chunk-EHT2DRT4.js";
 
 // src/agents/cursor-runner.ts
@@ -275,11 +277,18 @@ function slicedReadCustomToolConfig(cwd) {
 function buildCursorModelSelection(model, opts) {
   const raw = model && model.trim() || "";
   const id = !raw || raw.toLowerCase() === "auto" || raw.toLowerCase() === "default" ? "default" : raw;
+  const isGrok47 = /^grok-4\.7(?:$|-)/i.test(id);
   const params = [];
+  if (isGrok47) {
+    params.push({ id: "context", value: "256k" });
+  }
   const effort = (opts.effort ?? "").trim().toLowerCase();
   const normalized = effort === "normal" ? "medium" : effort === "low" || effort === "medium" || effort === "high" || effort === "xhigh" || effort === "max" ? effort : "";
   if (normalized) {
-    params.push({ id: "effort", value: normalized });
+    params.push({
+      id: isGrok47 ? "reasoning_effort" : "effort",
+      value: isGrok47 && normalized === "max" ? "xhigh" : normalized
+    });
   }
   params.push({ id: "fast", value: opts.fast ? "true" : "false" });
   return { id, params };
@@ -364,8 +373,29 @@ async function main() {
   const mode = req.planMode ? "plan" : "agent";
   const store = localAgentStore(JsonlLocalAgentStore, req.threadId);
   const isolateSources = [];
+  let onRpcProgress = () => {
+  };
+  const rpcTools = req.agentRpc ? sideboardCursorRpcTools({
+    cwd: req.cwd,
+    rpc: req.agentRpc,
+    includeWaitForTurn: Boolean(req.rpcWaitForTurn),
+    onProgress: (params, toolCallId) => {
+      onRpcProgress();
+      if (!toolCallId) return;
+      try {
+        emit({
+          type: "tool_result",
+          id: toolCallId,
+          content: JSON.stringify(params),
+          partial: true
+        });
+      } catch {
+      }
+    }
+  }) : {};
   const customTools = {
-    read: slicedReadCustomToolConfig(req.cwd)
+    read: slicedReadCustomToolConfig(req.cwd),
+    ...rpcTools
   };
   const local = withCursorLocalHangGuards({
     cwd: req.cwd,
@@ -460,6 +490,7 @@ async function main() {
     const bump = () => {
       activity.at = Date.now();
     };
+    onRpcProgress = bump;
     let usageBefore = null;
     try {
       usageBefore = await agent.getUsage();