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

package/dist/bin.js

@@ -114,10 +114,13 @@ function getDisplayModel(config) {
 }
 function getFastModel() {
   if (process.env.CALIBER_FAST_MODEL) return process.env.CALIBER_FAST_MODEL;
-  if (process.env.ANTHROPIC_SMALL_FAST_MODEL) return process.env.ANTHROPIC_SMALL_FAST_MODEL;
   const config = loadConfig();
+  const provider = config?.provider;
+  if (process.env.ANTHROPIC_SMALL_FAST_MODEL && (!provider || provider === "anthropic" || provider === "vertex")) {
+    return process.env.ANTHROPIC_SMALL_FAST_MODEL;
+  }
   if (config?.fastModel) return config.fastModel;
-  if (config?.provider) return DEFAULT_FAST_MODELS[config.provider];
+  if (provider) return DEFAULT_FAST_MODELS[provider];
   return void 0;
 }
 var CONFIG_DIR, CONFIG_FILE, DEFAULT_MODELS, DEFAULT_FAST_MODELS;
@@ -130,7 +133,7 @@ var init_config = __esm({
       anthropic: "claude-sonnet-4-6",
       vertex: "claude-sonnet-4-6",
       openai: "gpt-4.1",
-      cursor: "default",
+      cursor: "auto",
       "claude-cli": "default"
     };
     DEFAULT_FAST_MODELS = {
@@ -1207,13 +1210,21 @@ 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;
+  shutdownRequested = false;
   constructor(config) {
-    this.defaultModel = config.model || "default";
+    this.defaultModel = config.model || "auto";
     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: () => {
       },
@@ -1223,114 +1234,142 @@ var CursorAcpProvider = class {
     return chunks.join("");
   }
   async stream(options, callbacks) {
-    await this.runAcpPrompt(options, callbacks);
+    await this.runPrompt(options, callbacks);
+  }
+  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();
+    try {
+      await this.connectPromise;
+    } catch (err) {
+      this.connectPromise = null;
+      throw err;
+    }
   }
-  async runAcpPrompt(options, callbacks) {
-    const combinedPrompt = this.buildCombinedPrompt(options);
+  async connect() {
     const args = ["acp"];
     if (this.cursorApiKey) {
       args.unshift("--api-key", this.cursorApiKey);
     }
-    const agent = spawn(ACP_AGENT_BIN, args, {
-      stdio: ["pipe", "pipe", "inherit"],
+    this.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 rl = readline.createInterface({ input: agent.stdout, crlfDelay: Infinity });
-    rl.on("line", (line) => {
-      let msg;
-      try {
-        msg = JSON.parse(line);
-      } catch {
-        return;
+    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);
+    });
+    this.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);
       }
-      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.child = null;
+      this.rl = null;
+      this.connectPromise = null;
+    });
+    await this.send("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" });
+  }
+  // -- JSON-RPC ---------------------------------------------------------------
+  send(method, params) {
+    if (!this.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 msg = { jsonrpc: "2.0", id, method, params };
+      this.child.stdin.write(JSON.stringify(msg) + "\n", (err) => {
+        if (err) {
+          this.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(line) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (msg.id != null && (msg.result !== void 0 || msg.error !== void 0)) {
+      const waiter = this.pending.get(msg.id);
+      if (waiter) {
+        this.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) {
+        this.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) {
+        this.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";
+      this.child?.stdin?.write(response);
+    }
+  }
+  // -- Prompt execution -------------------------------------------------------
+  async runPrompt(options, callbacks) {
+    await this.ensureConnection();
+    this.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("session/new", {
         cwd: process.cwd(),
         mcpServers: []
       });
-      sessionId = sessionResult.sessionId;
-      await send("session/prompt", {
-        sessionId,
-        prompt: [{ type: "text", text: combinedPrompt }]
+      await this.send("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");
+      this.activeCallbacks = null;
     }
   }
   buildCombinedPrompt(options) {
@@ -1745,6 +1784,7 @@ async function validateModel(options) {
   const provider = getProvider();
   const config = cachedConfig;
   if (!config) return;
+  if (config.provider === "cursor" || config.provider === "claude-cli") return;
   const modelsToCheck = [config.model];
   if (options?.fast) {
     const { getFastModel: getFastModel2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -4043,7 +4083,7 @@ async function runInteractiveProviderSetup(options) {
       break;
     }
     case "cursor": {
-      config.model = "default";
+      config.model = DEFAULT_MODELS.cursor;
       if (!isCursorAgentAvailable()) {
         console.log(chalk5.yellow("\n  Cursor Agent CLI not found."));
         console.log(chalk5.dim("  Install it: ") + chalk5.hex("#83D1EB")("curl https://cursor.com/install -fsS | bash"));

package/package.json

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