@ycodium-ai/agent-grok 0.2.2126 → 0.2.2143

package/dist/index.js

@@ -23751,6 +23751,7 @@ function createAcpConnection(options) {
       options.readable.off("data", onData);
       options.readable.off("end", onEnd);
       options.readable.off("error", onError);
+      options.writable.off("error", onWritableError);
       try {
         await byteWriter.close();
       } catch {
@@ -23889,8 +23890,17 @@ function createAcpConnection(options) {
       endInboundBatch();
     }
   };
+  const failInbound = (error62) => {
+    if (closedError !== void 0) return;
+    options.onInboundFailure?.(error62);
+    void shutdown(
+      new AcpConnectionClosedError(
+        `ACP inbound handling failed: ${error62 instanceof Error ? error62.message : String(error62)}`
+      )
+    );
+  };
   const enqueueInbound = (work) => {
-    inboundTail = inboundTail.then(work, work);
+    inboundTail = inboundTail.then(work).catch(failInbound);
   };
   const onData = (chunk) => {
     if (closedError !== void 0) {
@@ -23940,9 +23950,15 @@ function createAcpConnection(options) {
       );
     });
   };
+  const onWritableError = (error62) => {
+    void shutdown(
+      error62 instanceof Error ? error62 : new AcpConnectionClosedError("ACP output stream error")
+    );
+  };
   options.readable.on("data", onData);
   options.readable.on("end", onEnd);
   options.readable.on("error", onError);
+  options.writable.once("error", onWritableError);
   const request = (async (method, params) => {
     failIfClosed();
     const id = nextRequestId;
@@ -23951,7 +23967,7 @@ function createAcpConnection(options) {
     pending.set(String(id), { method, resolve: resolve2, reject });
     const message = params === void 0 ? { jsonrpc: "2.0", id, method } : { jsonrpc: "2.0", id, method, params };
     try {
-      await writeMessage(message);
+      await Promise.race([writeMessage(message), promise2]);
     } catch (error62) {
       if (pending.delete(String(id))) {
         reject(error62);
@@ -25726,6 +25742,12 @@ function createAcpExecutor(options) {
   const connection = createAcpConnection({
     readable: options.readable,
     writable: options.writable,
+    onInboundFailure: (error62) => {
+      options.log?.warn?.("acp connection closed: an inbound request could not be answered", {
+        threadId: options.threadId,
+        error: error62 instanceof Error ? error62.message : String(error62)
+      });
+    },
     onNotification: (notification) => {
       if (notification.method === "session/update") {
         handleSessionUpdate(notification.params);
@@ -26363,10 +26385,10 @@ function createAcpExecutor(options) {
 }
 
 // ../../packages/ycodium-acp-executor/src/probe.ts
-function withProbeTimeout(promise2, timeoutMs, method) {
+function withProbeTimeout(promise2, timeoutMs, what) {
   return new Promise((resolve2, reject) => {
     const timer = setTimeout(() => {
-      reject(new Error(`ACP probe request '${method}' timed out after ${timeoutMs}ms`));
+      reject(new Error(`${what} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
     timer.unref?.();
     promise2.then(
@@ -26391,11 +26413,15 @@ async function openAcpProbeHandshake(input2) {
     const initializeResult = await withProbeTimeout(
       connection.request("initialize", acpInitializePayload(input2.clientInfo)),
       input2.requestTimeoutMs,
-      "initialize"
+      "ACP probe request 'initialize'"
     );
     return {
       initializeResult,
-      request: (method, params) => withProbeTimeout(connection.request(method, params), input2.requestTimeoutMs, method),
+      request: (method, params) => withProbeTimeout(
+        connection.request(method, params),
+        input2.requestTimeoutMs,
+        `ACP probe request '${method}'`
+      ),
       close: () => connection.close()
     };
   } catch (error62) {
@@ -26403,6 +26429,57 @@ async function openAcpProbeHandshake(input2) {
     throw error62;
   }
 }
+var CLI_VERSION_PATTERN = /(?<![\d.])(\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?)/;
+function parseCliVersion(output2) {
+  return CLI_VERSION_PATTERN.exec(output2)?.[1] ?? null;
+}
+async function collectCappedText(stream, maxBytes) {
+  const decoder = new TextDecoder();
+  let text = "";
+  let total = 0;
+  for await (const chunk of stream) {
+    total += chunk.byteLength;
+    if (total <= maxBytes) text += decoder.decode(chunk, { stream: true });
+  }
+  return { text: text + decoder.decode(), overflowed: total > maxBytes };
+}
+async function collectProbeProcess(child, input2) {
+  try {
+    await child.closeStdin().catch(() => void 0);
+    const [stdout, stderr, exitCode] = await withProbeTimeout(
+      Promise.all([
+        collectCappedText(child.stdout, input2.maxOutputBytes),
+        collectCappedText(child.stderr, input2.maxOutputBytes),
+        child.exited
+      ]),
+      input2.timeoutMs,
+      input2.what
+    );
+    return { stdout: stdout.overflowed ? void 0 : stdout.text, stderr: stderr.text, exitCode };
+  } finally {
+    await child.kill("SIGTERM").catch(() => void 0);
+  }
+}
+var MAX_VERSION_OUTPUT_BYTES = 64 * 1024;
+async function probeCliVersion(input2) {
+  let child;
+  try {
+    child = await input2.spawn();
+  } catch {
+    return null;
+  }
+  try {
+    const run = await collectProbeProcess(child, {
+      timeoutMs: input2.timeoutMs,
+      maxOutputBytes: MAX_VERSION_OUTPUT_BYTES,
+      what: "--version"
+    });
+    if (run.exitCode !== 0) return null;
+    return parseCliVersion(run.stdout ?? "") ?? parseCliVersion(run.stderr);
+  } catch {
+    return null;
+  }
+}
 
 // src/config.ts
 var GROK_DEFAULT_LAUNCH_ARGS = "agent stdio";
@@ -26880,6 +26957,9 @@ var grokPromptSettlement = {
 };
 
 // src/probeModels.ts
+import {
+  ExecutorSpawnRefusedError
+} from "@ycodium-ai/plugin-api/executor";
 import { nodeStreamsFromHandle } from "@ycodium-ai/plugin-api/process-stdin";
 var PROBE_REQUEST_TIMEOUT_MS = 2e4;
 function grokProbeModels(initializeResult) {
@@ -26904,6 +26984,7 @@ async function probeGrokModels(input2) {
       ...Object.keys(env).length > 0 ? { env } : {}
     });
   } catch (error62) {
+    if (error62 instanceof ExecutorSpawnRefusedError) throw error62;
     return { kind: "not-started", detail: failureDetail(error62) };
   }
   let handshake;
@@ -26923,6 +27004,18 @@ async function probeGrokModels(input2) {
     await handle.kill("SIGTERM").catch(() => void 0);
   }
 }
+async function probeGrokVersion(input2) {
+  const { recipe, host, env } = input2;
+  return probeCliVersion({
+    spawn: () => host.process.spawn({
+      program: recipe.binaryPath,
+      args: ["--version"],
+      owner: { bindingId: host.bindingId },
+      ...Object.keys(env).length > 0 ? { env } : {}
+    }),
+    timeoutMs: PROBE_REQUEST_TIMEOUT_MS
+  });
+}
 
 // src/grokInstance.ts
 var RESUME_SCHEMA_VERSION = 1;
@@ -26978,6 +27071,9 @@ function resolveGrokHomePath(value) {
   if (trimmed2.length === 0) return NodePath2.join(NodeOS.homedir(), ".grok");
   return NodePath2.resolve(expandHomePath(trimmed2));
 }
+function grokContinuationKey(recipe) {
+  return `grok:home:${resolveGrokHomePath(recipe.homePath)}`;
+}
 function resolveAccountHomePath(recipe, configuredHome) {
   const fromEnvironment = recipe.environment["GROK_HOME"]?.trim();
   if (fromEnvironment !== void 0 && fromEnvironment.length > 0) {
@@ -27048,19 +27144,19 @@ var createGrokInstance = (config2, host) => {
       };
     }
     const configuredHome = recipe.homePath;
-    const outcome = await probeGrokModels({
+    const env = buildSpawnEnv(
       recipe,
-      host,
-      env: buildSpawnEnv(
-        recipe,
-        resolveGrokHomePath(configuredHome),
-        configuredHome.trim().length > 0
-      )
-    });
+      resolveGrokHomePath(configuredHome),
+      configuredHome.trim().length > 0
+    );
+    const [outcome, version2] = await Promise.all([
+      probeGrokModels({ recipe, host, env }),
+      probeGrokVersion({ recipe, host, env })
+    ]);
     if (outcome.kind !== "answered") {
       return {
         installed: outcome.kind === "failed",
-        version: null,
+        version: version2,
         readiness: "error",
         auth: probeAuth(),
         ...outcome.detail === void 0 ? {} : { detail: outcome.detail },
@@ -27071,7 +27167,7 @@ var createGrokInstance = (config2, host) => {
     }
     return {
       installed: true,
-      version: null,
+      version: version2,
       readiness: "ready",
       auth: probeAuth(),
       ...outcome.models === void 0 ? {} : { models: outcome.models },
@@ -27305,6 +27401,7 @@ var createGrokInstance = (config2, host) => {
       return { threadId, turns: booked.turns };
     },
     events,
+    continuationKey: grokContinuationKey(recipe),
     dispose: async () => {
       if (disposed) return;
       disposed = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-grok",
-  "version": "0.2.2126",
+  "version": "0.2.2143",
   "description": "Grok executor: grok CLI over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -20,7 +20,7 @@
     "@types/node": "24.12.4",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.2126",
+    "@ycodium-ai/plugin-api": "0.2.2143",
     "ycodium-acp-executor": "0.0.0",
     "ycodium-acp-protocol": "0.0.0"
   },