@rely-ai/caliber 1.22.0-dev.1773752996 → 1.22.0-dev.1773764723

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,15 +1211,11 @@ var IS_WINDOWS = process.platform === "win32";
 var CursorAcpProvider = class {
   defaultModel;
   cursorApiKey;
-  child = null;
-  rl = null;
-  pending = /* @__PURE__ */ new Map();
-  nextId = 1;
-  connectPromise = null;
-  activeCallbacks = null;
+  connections = /* @__PURE__ */ new Map();
+  connectPromises = /* @__PURE__ */ new Map();
   shutdownRequested = false;
   constructor(config) {
-    this.defaultModel = config.model || "auto";
+    this.defaultModel = config.model || "sonnet-4.6";
     this.cursorApiKey = process.env.CURSOR_API_KEY ?? process.env.CURSOR_AUTH_TOKEN;
     process.once("exit", () => this.shutdown());
   }
@@ -1238,80 +1235,98 @@ var CursorAcpProvider = class {
   }
   shutdown() {
     this.shutdownRequested = true;
-    if (this.child) {
-      this.child.stdin?.end();
-      this.child.kill("SIGTERM");
-      this.child = null;
-    }
-    this.rl = null;
-    this.connectPromise = null;
-  }
-  // -- Connection management --------------------------------------------------
-  async ensureConnection() {
-    if (this.child && !this.child.killed) return;
-    if (this.connectPromise) return this.connectPromise;
-    this.connectPromise = this.connect();
+    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 this.connectPromise;
+      await promise;
     } catch (err) {
-      this.connectPromise = null;
+      this.connectPromises.delete(model);
       throw err;
     }
+    return this.connections.get(model);
   }
-  async connect() {
-    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);
     }
-    this.child = spawn(ACP_AGENT_BIN, args, {
+    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 }
     });
-    this.rl = readline.createInterface({ input: this.child.stdout, crlfDelay: Infinity });
-    this.rl.on("line", (line) => this.handleLine(line));
-    this.child.on("error", (err) => {
-      for (const w of this.pending.values()) w.reject(err);
-      this.pending.clear();
-      this.activeCallbacks?.onError(err);
+    const conn = {
+      child,
+      rl: readline.createInterface({ input: child.stdout, crlfDelay: Infinity }),
+      pending: /* @__PURE__ */ new Map(),
+      nextId: 1,
+      activeCallbacks: null
+    };
+    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);
     });
-    this.child.on("close", () => {
+    child.on("close", () => {
       if (!this.shutdownRequested) {
         const err = new Error("Cursor agent process exited unexpectedly");
-        for (const w of this.pending.values()) w.reject(err);
-        this.pending.clear();
-        this.activeCallbacks?.onError(err);
+        for (const w of conn.pending.values()) w.reject(err);
+        conn.pending.clear();
+        conn.activeCallbacks?.onError(err);
       }
-      this.child = null;
-      this.rl = null;
-      this.connectPromise = null;
+      this.connections.delete(model);
+      this.connectPromises.delete(model);
     });
-    await this.send("initialize", {
+    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("authenticate", { methodId: "cursor_login" });
+    await this.send(conn, "authenticate", { methodId: "cursor_login" });
   }
   // -- JSON-RPC ---------------------------------------------------------------
-  send(method, params) {
-    if (!this.child?.stdin) {
+  send(conn, method, params) {
+    if (!conn.child.stdin) {
       return Promise.reject(new Error("Cursor agent not connected"));
     }
     return new Promise((resolve2, reject) => {
-      const id = this.nextId++;
-      this.pending.set(id, { resolve: resolve2, reject });
+      const id = conn.nextId++;
+      conn.pending.set(id, { resolve: resolve2, reject });
       const msg = { jsonrpc: "2.0", id, method, params };
-      this.child.stdin.write(JSON.stringify(msg) + "\n", (err) => {
+      conn.child.stdin.write(JSON.stringify(msg) + "\n", (err) => {
         if (err) {
-          this.pending.delete(id);
+          conn.pending.delete(id);
           reject(err);
         }
       });
     });
   }
-  handleLine(line) {
+  handleLine(conn, line) {
     let msg;
     try {
       msg = JSON.parse(line);
@@ -1319,9 +1334,9 @@ var CursorAcpProvider = class {
       return;
     }
     if (msg.id != null && (msg.result !== void 0 || msg.error !== void 0)) {
-      const waiter = this.pending.get(msg.id);
+      const waiter = conn.pending.get(msg.id);
       if (waiter) {
-        this.pending.delete(msg.id);
+        conn.pending.delete(msg.id);
         if (msg.error) {
           waiter.reject(new Error(msg.error.message || "ACP error"));
         } else {
@@ -1329,7 +1344,7 @@ var CursorAcpProvider = class {
         }
       }
       if (msg.result && typeof msg.result === "object" && "stopReason" in msg.result) {
-        this.activeCallbacks?.onEnd({
+        conn.activeCallbacks?.onEnd({
           stopReason: msg.result.stopReason
         });
       }
@@ -1338,7 +1353,7 @@ var CursorAcpProvider = class {
     if (msg.method === "session/update" && msg.params?.update) {
       const update = msg.params.update;
       if (update.sessionUpdate === "agent_message_chunk" && update.content?.text) {
-        this.activeCallbacks?.onText(update.content.text);
+        conn.activeCallbacks?.onText(update.content.text);
       }
       return;
     }
@@ -1348,19 +1363,20 @@ var CursorAcpProvider = class {
         id: msg.id,
         result: { outcome: { outcome: "selected", optionId: "allow-once" } }
       }) + "\n";
-      this.child?.stdin?.write(response);
+      conn.child.stdin?.write(response);
     }
   }
   // -- Prompt execution -------------------------------------------------------
   async runPrompt(options, callbacks) {
-    await this.ensureConnection();
-    this.activeCallbacks = callbacks;
+    const model = this.resolveModel(options);
+    const conn = await this.ensureConnection(model);
+    conn.activeCallbacks = callbacks;
     try {
-      const sessionResult = await this.send("session/new", {
+      const sessionResult = await this.send(conn, "session/new", {
         cwd: process.cwd(),
         mcpServers: []
       });
-      await this.send("session/prompt", {
+      await this.send(conn, "session/prompt", {
         sessionId: sessionResult.sessionId,
         prompt: [{ type: "text", text: this.buildCombinedPrompt(options) }]
       });
@@ -1369,7 +1385,7 @@ var CursorAcpProvider = class {
       callbacks.onError(error);
       throw error;
     } finally {
-      this.activeCallbacks = null;
+      conn.activeCallbacks = null;
     }
   }
   buildCombinedPrompt(options) {
@@ -7014,7 +7030,7 @@ function renderCard(card, index, total, cols) {
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var SPINNER_INTERVAL_MS = 80;
 var CARD_ADVANCE_MS = 15e3;
-var NAME_COL_WIDTH = 26;
+var NAME_COL_WIDTH = 30;
 var PREFIX = "    ";
 var ParallelTaskDisplay = class {
   tasks = [];

package/package.json

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