@rely-ai/caliber 1.22.0-dev.1773745340 → 1.22.0-dev.1773764649

package/dist/bin.js

@@ -133,13 +133,14 @@ var init_config = __esm({
       anthropic: "claude-sonnet-4-6",
       vertex: "claude-sonnet-4-6",
       openai: "gpt-4.1",
-      cursor: "auto",
+      cursor: "sonnet-4.6",
       "claude-cli": "default"
     };
     DEFAULT_FAST_MODELS = {
       anthropic: "claude-haiku-4-5-20251001",
       vertex: "claude-haiku-4-5-20251001",
-      openai: "gpt-4.1-mini"
+      openai: "gpt-4.1-mini",
+      cursor: "gpt-5.3-codex-fast"
     };
   }
 });
@@ -1210,13 +1211,17 @@ var IS_WINDOWS = process.platform === "win32";
 var CursorAcpProvider = class {
   defaultModel;
   cursorApiKey;
+  connections = /* @__PURE__ */ new Map();
+  connectPromises = /* @__PURE__ */ new Map();
+  shutdownRequested = false;
   constructor(config) {
-    this.defaultModel = config.model || "default";
+    this.defaultModel = config.model || "sonnet-4.6";
     this.cursorApiKey = process.env.CURSOR_API_KEY ?? process.env.CURSOR_AUTH_TOKEN;
+    process.once("exit", () => this.shutdown());
   }
   async call(options) {
     const chunks = [];
-    await this.runAcpPrompt(options, {
+    await this.runPrompt(options, {
       onText: (text) => chunks.push(text),
       onEnd: () => {
       },
@@ -1226,118 +1231,161 @@ var CursorAcpProvider = class {
     return chunks.join("");
   }
   async stream(options, callbacks) {
-    await this.runAcpPrompt(options, callbacks);
+    await this.runPrompt(options, callbacks);
+  }
+  shutdown() {
+    this.shutdownRequested = true;
+    for (const conn of this.connections.values()) {
+      conn.child.stdin?.end();
+      conn.child.kill("SIGTERM");
+    }
+    this.connections.clear();
+    this.connectPromises.clear();
+  }
+  // -- Connection pool --------------------------------------------------------
+  resolveModel(options) {
+    return options.model || this.defaultModel;
+  }
+  async ensureConnection(model) {
+    const existing = this.connections.get(model);
+    if (existing && !existing.child.killed) return existing;
+    const pending = this.connectPromises.get(model);
+    if (pending) {
+      await pending;
+      return this.connections.get(model);
+    }
+    const promise = this.connect(model);
+    this.connectPromises.set(model, promise);
+    try {
+      await promise;
+    } catch (err) {
+      this.connectPromises.delete(model);
+      throw err;
+    }
+    return this.connections.get(model);
   }
-  async runAcpPrompt(options, callbacks) {
-    const combinedPrompt = this.buildCombinedPrompt(options);
-    const model = options.model || this.defaultModel;
-    const args = ["acp"];
+  async connect(model) {
+    const args = ["--mode", "ask", "acp"];
     if (model && model !== "auto" && model !== "default") {
       args.unshift("--model", model);
     }
     if (this.cursorApiKey) {
       args.unshift("--api-key", this.cursorApiKey);
     }
-    const agent = spawn(ACP_AGENT_BIN, args, {
-      stdio: ["pipe", "pipe", "inherit"],
+    const child = spawn(ACP_AGENT_BIN, args, {
+      stdio: ["pipe", "pipe", "ignore"],
       cwd: process.cwd(),
       env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
       ...IS_WINDOWS && { shell: true }
     });
-    const pending = /* @__PURE__ */ new Map();
-    let nextId = 1;
-    let sessionId = null;
-    const send = (method, params) => {
-      return new Promise((resolve2, reject) => {
-        const id = nextId++;
-        pending.set(id, { resolve: resolve2, reject });
-        const msg = { jsonrpc: "2.0", id, method, params };
-        agent.stdin.write(JSON.stringify(msg) + "\n", (err) => {
-          if (err) {
-            pending.delete(id);
-            reject(err);
-          }
-        });
-      });
+    const conn = {
+      child,
+      rl: readline.createInterface({ input: child.stdout, crlfDelay: Infinity }),
+      pending: /* @__PURE__ */ new Map(),
+      nextId: 1,
+      activeCallbacks: null
     };
-    const rl = readline.createInterface({ input: agent.stdout, crlfDelay: Infinity });
-    rl.on("line", (line) => {
-      let msg;
-      try {
-        msg = JSON.parse(line);
-      } catch {
-        return;
+    conn.rl.on("line", (line) => this.handleLine(conn, line));
+    child.on("error", (err) => {
+      for (const w of conn.pending.values()) w.reject(err);
+      conn.pending.clear();
+      conn.activeCallbacks?.onError(err);
+    });
+    child.on("close", () => {
+      if (!this.shutdownRequested) {
+        const err = new Error("Cursor agent process exited unexpectedly");
+        for (const w of conn.pending.values()) w.reject(err);
+        conn.pending.clear();
+        conn.activeCallbacks?.onError(err);
       }
-      if (msg.id != null && (msg.result !== void 0 || msg.error !== void 0)) {
-        const waiter = pending.get(msg.id);
-        if (waiter) {
-          pending.delete(msg.id);
-          if (msg.error) {
-            waiter.reject(new Error(msg.error.message || "ACP error"));
-          } else {
-            waiter.resolve(msg.result);
-          }
-        }
-        if (msg.result && typeof msg.result === "object" && "sessionId" in msg.result) {
-          sessionId = msg.result.sessionId;
-        }
-        if (msg.result && typeof msg.result === "object" && "stopReason" in msg.result) {
-          callbacks.onEnd({
-            stopReason: msg.result.stopReason
-          });
+      this.connections.delete(model);
+      this.connectPromises.delete(model);
+    });
+    this.connections.set(model, conn);
+    await this.send(conn, "initialize", {
+      protocolVersion: 1,
+      clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+      clientInfo: { name: "caliber", version: "1.0.0" }
+    });
+    await this.send(conn, "authenticate", { methodId: "cursor_login" });
+  }
+  // -- JSON-RPC ---------------------------------------------------------------
+  send(conn, method, params) {
+    if (!conn.child.stdin) {
+      return Promise.reject(new Error("Cursor agent not connected"));
+    }
+    return new Promise((resolve2, reject) => {
+      const id = conn.nextId++;
+      conn.pending.set(id, { resolve: resolve2, reject });
+      const msg = { jsonrpc: "2.0", id, method, params };
+      conn.child.stdin.write(JSON.stringify(msg) + "\n", (err) => {
+        if (err) {
+          conn.pending.delete(id);
+          reject(err);
         }
-        return;
-      }
-      if (msg.method === "session/update" && msg.params?.update) {
-        const update = msg.params.update;
-        if (update.sessionUpdate === "agent_message_chunk" && update.content?.text) {
-          callbacks.onText(update.content.text);
+      });
+    });
+  }
+  handleLine(conn, line) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (msg.id != null && (msg.result !== void 0 || msg.error !== void 0)) {
+      const waiter = conn.pending.get(msg.id);
+      if (waiter) {
+        conn.pending.delete(msg.id);
+        if (msg.error) {
+          waiter.reject(new Error(msg.error.message || "ACP error"));
+        } else {
+          waiter.resolve(msg.result);
         }
-        return;
       }
-      if (msg.method === "session/request_permission" && msg.id != null) {
-        const response = JSON.stringify({
-          jsonrpc: "2.0",
-          id: msg.id,
-          result: { outcome: { outcome: "selected", optionId: "allow-once" } }
-        }) + "\n";
-        agent.stdin.write(response);
+      if (msg.result && typeof msg.result === "object" && "stopReason" in msg.result) {
+        conn.activeCallbacks?.onEnd({
+          stopReason: msg.result.stopReason
+        });
       }
-    });
-    agent.on("error", (err) => {
-      for (const w of pending.values()) w.reject(err);
-      callbacks.onError(err);
-    });
-    agent.on("close", (code) => {
-      if (code !== 0 && code !== null) {
-        const err = new Error(`Cursor agent exited with code ${code}`);
-        for (const w of pending.values()) w.reject(err);
-        callbacks.onError(err);
+      return;
+    }
+    if (msg.method === "session/update" && msg.params?.update) {
+      const update = msg.params.update;
+      if (update.sessionUpdate === "agent_message_chunk" && update.content?.text) {
+        conn.activeCallbacks?.onText(update.content.text);
       }
-    });
+      return;
+    }
+    if (msg.method === "session/request_permission" && msg.id != null) {
+      const response = JSON.stringify({
+        jsonrpc: "2.0",
+        id: msg.id,
+        result: { outcome: { outcome: "selected", optionId: "allow-once" } }
+      }) + "\n";
+      conn.child.stdin?.write(response);
+    }
+  }
+  // -- Prompt execution -------------------------------------------------------
+  async runPrompt(options, callbacks) {
+    const model = this.resolveModel(options);
+    const conn = await this.ensureConnection(model);
+    conn.activeCallbacks = callbacks;
     try {
-      await send("initialize", {
-        protocolVersion: 1,
-        clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
-        clientInfo: { name: "caliber", version: "1.0.0" }
-      });
-      await send("authenticate", { methodId: "cursor_login" });
-      const sessionResult = await send("session/new", {
+      const sessionResult = await this.send(conn, "session/new", {
         cwd: process.cwd(),
         mcpServers: []
       });
-      sessionId = sessionResult.sessionId;
-      await send("session/prompt", {
-        sessionId,
-        prompt: [{ type: "text", text: combinedPrompt }]
+      await this.send(conn, "session/prompt", {
+        sessionId: sessionResult.sessionId,
+        prompt: [{ type: "text", text: this.buildCombinedPrompt(options) }]
       });
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
       callbacks.onError(error);
       throw error;
     } finally {
-      agent.stdin?.end();
-      agent.kill("SIGTERM");
+      conn.activeCallbacks = null;
     }
   }
   buildCombinedPrompt(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rely-ai/caliber",
-  "version": "1.22.0-dev.1773745340",
+  "version": "1.22.0-dev.1773764649",
   "description": "Analyze your codebase and generate optimized AI agent configs (CLAUDE.md, .cursorrules, skills) — no API key needed",
   "type": "module",
   "bin": {