clay-server 3.3.2-beta.3 → 3.4.0-beta.2

package/lib/yoke/acp-event-normalizer.js

@@ -0,0 +1,179 @@
+// ACP Event Normalizer
+// --------------------
+// Converts standard session/update payloads to stable YOKE events.
+
+function toolNameForKind(kind, title) {
+  switch (kind) {
+    case "execute": return "Bash";
+    case "read": return "Read";
+    case "edit": return "Edit";
+    case "delete": return "Edit";
+    case "move": return "Edit";
+    case "search": return "Grep";
+    case "fetch": return "WebFetch";
+    case "think": return "Think";
+    default: return title || "Tool";
+  }
+}
+
+function createEventState(opts) {
+  opts = opts || {};
+  return {
+    vendor: opts.vendor || "acp",
+    blockCounter: 0,
+    textBlockOpen: false,
+    textBlockId: null,
+    thinkBlockOpen: false,
+    thinkBlockId: null,
+    toolBlocks: {},
+    toolMeta: {},
+    toolContent: {},
+    lastInputTokens: null,
+    contextWindow: opts.contextWindow || null,
+    configOptions: [],
+  };
+}
+
+function extractContent(content) {
+  if (!Array.isArray(content)) return "";
+  var parts = [];
+  for (var i = 0; i < content.length; i++) {
+    var item = content[i];
+    if (!item) continue;
+    if (item.type === "content" && item.content && typeof item.content.text === "string") {
+      parts.push(item.content.text);
+    } else if (item.type === "diff") {
+      parts.push((item.path ? "--- " + item.path + "\n" : "") + (item.newText || ""));
+    } else if (typeof item.text === "string") {
+      parts.push(item.text);
+    }
+  }
+  return parts.join("\n");
+}
+
+function finalToolContent(state, callId, update) {
+  if (callId && state.toolContent[callId]) return state.toolContent[callId];
+  var direct = extractContent(update.content);
+  if (direct) return direct;
+  if (typeof update.rawOutput === "string") return update.rawOutput;
+  if (update.rawOutput && typeof update.rawOutput.output === "string") return update.rawOutput.output;
+  return "";
+}
+
+function normalizeStatus(status) {
+  if (status === "in_progress" || status === "inProgress") return "in_progress";
+  if (status === "completed") return "completed";
+  return "pending";
+}
+
+function normalizeAcpUpdate(update, state) {
+  var events = [];
+  if (!update) return events;
+  var type = update.sessionUpdate;
+
+  if (type === "agent_message_chunk") {
+    var text = update.content && typeof update.content.text === "string" ? update.content.text : "";
+    if (!state.textBlockOpen) {
+      state.textBlockOpen = true;
+      state.textBlockId = "blk_" + (++state.blockCounter);
+      events.push({ yokeType: "text_start", blockId: state.textBlockId });
+    }
+    if (text) events.push({ yokeType: "text_delta", blockId: state.textBlockId, text: text });
+    return events;
+  }
+
+  if (type === "agent_thought_chunk") {
+    var thought = update.content && typeof update.content.text === "string" ? update.content.text : "";
+    if (!state.thinkBlockOpen) {
+      state.thinkBlockOpen = true;
+      state.thinkBlockId = "blk_" + (++state.blockCounter);
+      events.push({ yokeType: "thinking_start", blockId: state.thinkBlockId });
+    }
+    if (thought) events.push({ yokeType: "thinking_delta", blockId: state.thinkBlockId, text: thought });
+    return events;
+  }
+
+  if (type === "tool_call" || type === "tool_call_update") {
+    var callId = update.toolCallId;
+    var name = toolNameForKind(update.kind, update.title);
+    if (callId && update.kind) {
+      state.toolMeta[callId] = { kind: update.kind, title: update.title, rawInput: update.rawInput || {} };
+    }
+    if (callId && !state.toolBlocks[callId]) {
+      state.toolBlocks[callId] = "blk_" + (++state.blockCounter);
+      events.push({ yokeType: "tool_start", blockId: state.toolBlocks[callId], toolId: callId, toolName: name });
+      events.push({ yokeType: "tool_executing", blockId: state.toolBlocks[callId], toolId: callId, toolName: name, input: update.rawInput || {} });
+    }
+    var chunk = extractContent(update.content);
+    if (callId && chunk) state.toolContent[callId] = (state.toolContent[callId] || "") + chunk;
+    if (update.status === "completed" || update.status === "failed") {
+      events.push({
+        yokeType: "tool_result",
+        blockId: state.toolBlocks[callId],
+        toolId: callId,
+        content: finalToolContent(state, callId, update),
+        isError: update.status === "failed",
+      });
+    }
+    return events;
+  }
+
+  if (type === "plan") {
+    var entries = Array.isArray(update.entries) ? update.entries : [];
+    events.push({
+      yokeType: "plan_updated",
+      title: "Plan",
+      explanation: "",
+      plan: entries.map(function(entry) {
+        return { step: entry.content || "", status: normalizeStatus(entry.status) };
+      }),
+    });
+    return events;
+  }
+
+  if (type === "usage_update") {
+    if (typeof update.used === "number") state.lastInputTokens = update.used;
+    if (typeof update.size === "number") state.contextWindow = update.size;
+    return events;
+  }
+
+  if (type === "config_option_update") {
+    state.configOptions = Array.isArray(update.configOptions) ? update.configOptions : [];
+    return events;
+  }
+
+  events.push({
+    yokeType: "runtime_specific",
+    vendor: state.vendor,
+    eventType: "session/update:" + type,
+    raw: update,
+  });
+  return events;
+}
+
+function closeOpenBlocks(state) {
+  var events = [];
+  if (state.thinkBlockOpen) {
+    events.push({ yokeType: "thinking_stop", blockId: state.thinkBlockId });
+    state.thinkBlockOpen = false;
+  }
+  return events;
+}
+
+function resetTurnState(state) {
+  state.textBlockOpen = false;
+  state.textBlockId = null;
+  state.thinkBlockOpen = false;
+  state.thinkBlockId = null;
+  state.toolBlocks = {};
+  state.toolMeta = {};
+  state.toolContent = {};
+}
+
+module.exports = {
+  createEventState: createEventState,
+  normalizeAcpUpdate: normalizeAcpUpdate,
+  closeOpenBlocks: closeOpenBlocks,
+  resetTurnState: resetTurnState,
+  toolNameForKind: toolNameForKind,
+};

package/lib/yoke/acp-process-manager.js

@@ -0,0 +1,264 @@
+// Shared ACP Process Manager
+// --------------------------
+// Manages an ACP child process over line-delimited JSON-RPC 2.0. The child can
+// answer client requests and initiate its own requests or notifications.
+
+var { spawn } = require("child_process");
+var readline = require("readline");
+
+function AcpProcessManager(executablePath, opts) {
+  this.proc = null;
+  this.rl = null;
+  this.nextId = 1;
+  this.pendingRequests = {};
+  this.requestHandlers = {};
+  this.handlers = [];
+  this.executablePath = executablePath;
+  this.opts = opts || {};
+  this.started = false;
+  this._stderrBuf = "";
+  this._logPrefix = this.opts.logPrefix || "acp-process-manager";
+}
+
+AcpProcessManager.prototype._log = function() {
+  var args = Array.prototype.slice.call(arguments);
+  args.unshift("[" + this._logPrefix + "]");
+  console.log.apply(console, args);
+};
+
+AcpProcessManager.prototype._warn = function() {
+  var args = Array.prototype.slice.call(arguments);
+  args.unshift("[" + this._logPrefix + "]");
+  console.warn.apply(console, args);
+};
+
+AcpProcessManager.prototype._error = function() {
+  var args = Array.prototype.slice.call(arguments);
+  args.unshift("[" + this._logPrefix + "]");
+  console.error.apply(console, args);
+};
+
+AcpProcessManager.prototype.start = function() {
+  var self = this;
+
+  return new Promise(function(resolve, reject) {
+    try {
+      var args = self.opts.args ? self.opts.args.slice() : [];
+      var env = Object.assign({}, process.env, self.opts.env || {});
+
+      self._log("Spawning:", self.executablePath, args.join(" "));
+      self.proc = spawn(self.executablePath, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: env,
+        cwd: self.opts.cwd || process.cwd(),
+      });
+
+      self.proc.on("error", function(err) {
+        self._error("Process error:", err.message);
+        if (!self.started) reject(err);
+        self._rejectAllPending(err);
+      });
+
+      self.proc.on("exit", function(code, signal) {
+        self._log("Process exited: code=" + code + " signal=" + signal);
+        self.started = false;
+        self._rejectAllPending(new Error("Process exited: code=" + code));
+      });
+
+      self.proc.stderr.on("data", function(chunk) {
+        self._stderrBuf += chunk.toString();
+        var lines = self._stderrBuf.split("\n");
+        while (lines.length > 1) {
+          var line = lines.shift();
+          if (line.trim() && self.opts.logStderr !== false) self._log("stderr", line);
+          if (self.opts.onStderrLine) self.opts.onStderrLine(line, self);
+        }
+        self._stderrBuf = lines[0] || "";
+      });
+
+      self.rl = readline.createInterface({ input: self.proc.stdout, crlfDelay: Infinity });
+      self.rl.on("line", function(line) {
+        if (!line.trim()) return;
+        try {
+          self._handleMessage(JSON.parse(line));
+        } catch (e) {
+          self._error("Failed to parse line:", line.substring(0, 200));
+        }
+      });
+      self.rl.on("close", function() {
+        self._log("stdout closed");
+      });
+
+      self.started = true;
+      resolve();
+    } catch (e) {
+      reject(e);
+    }
+  });
+};
+
+AcpProcessManager.prototype._handleMessage = function(msg) {
+  if (msg.id !== undefined && msg.id !== null && (msg.result !== undefined || msg.error !== undefined)) {
+    var pending = this.pendingRequests[msg.id];
+    if (pending) {
+      delete this.pendingRequests[msg.id];
+      if (pending.timer) clearTimeout(pending.timer);
+      if (msg.error) {
+        var err = new Error(msg.error.message || JSON.stringify(msg.error));
+        err.rpcError = msg.error;
+        pending.reject(err);
+      } else {
+        pending.resolve(msg.result);
+      }
+    }
+    return;
+  }
+
+  if (!msg.method) return;
+
+  var isRequest = msg.id !== undefined && msg.id !== null;
+  var directHandler = isRequest && this.requestHandlers[msg.method];
+  if (directHandler) {
+    var self = this;
+    Promise.resolve().then(function() {
+      return directHandler(msg.params || {}, msg);
+    }).then(function(result) {
+      self.respond(msg.id, result);
+    }).catch(function(err) {
+      self._error("Request handler failed for " + msg.method + ":", err && err.message ? err.message : err);
+      self.respondError(msg.id, -32002, err && err.message ? err.message : "Request handler failed");
+    });
+    return;
+  }
+
+  var sessionId = msg.params && msg.params.sessionId;
+  if (isRequest && !sessionId) {
+    this._warn("No process handler for request " + msg.method + ", rejecting");
+    this.respondError(msg.id, -32601, "No process handler for method " + msg.method);
+    return;
+  }
+  var targets;
+  if (sessionId) {
+    targets = this.handlers.filter(function(handler) { return handler.sessionId === sessionId; });
+  } else {
+    targets = this.handlers.slice();
+  }
+
+  if (!targets.length) {
+    if (isRequest) {
+      this._warn("No handler for request " + msg.method + " (session=" + (sessionId || "none") + "), rejecting");
+      this.respondError(msg.id, -32001, "No active handler for session " + (sessionId || "none"));
+    } else {
+      this._log("Unhandled event:", msg.method);
+    }
+    return;
+  }
+
+  if (isRequest) {
+    try {
+      targets[0].fn(msg);
+    } catch (e) {
+      this._error("Handler threw for " + msg.method + ":", e && e.message ? e.message : e);
+      this.respondError(msg.id, -32000, "Handler error");
+    }
+    return;
+  }
+
+  targets.forEach(function(handler) {
+    try {
+      handler.fn(msg);
+    } catch (e) {
+      this._error("Handler threw for " + msg.method + ":", e && e.message ? e.message : e);
+    }
+  }, this);
+};
+
+AcpProcessManager.prototype.addHandler = function(fn) {
+  var entry = { sessionId: null, fn: fn };
+  this.handlers.push(entry);
+  return entry;
+};
+
+AcpProcessManager.prototype.removeHandler = function(entry) {
+  var index = this.handlers.indexOf(entry);
+  if (index !== -1) this.handlers.splice(index, 1);
+};
+
+AcpProcessManager.prototype.addRequestHandler = function(method, fn) {
+  this.requestHandlers[method] = fn;
+};
+
+AcpProcessManager.prototype.send = function(method, params, timeoutMs) {
+  var self = this;
+  var id = this.nextId++;
+  timeoutMs = timeoutMs || 30000;
+
+  return new Promise(function(resolve, reject) {
+    if (!self.proc || !self.started) {
+      reject(new Error("ACP server not started"));
+      return;
+    }
+    var timer = setTimeout(function() {
+      delete self.pendingRequests[id];
+      reject(new Error("Request timeout: " + method + " (id=" + id + ")"));
+    }, timeoutMs);
+    self.pendingRequests[id] = { resolve: resolve, reject: reject, timer: timer };
+
+    var msg = { jsonrpc: "2.0", id: id, method: method };
+    if (params !== undefined) msg.params = params;
+    self._write(msg);
+  });
+};
+
+AcpProcessManager.prototype.notify = function(method, params) {
+  if (!this.proc || !this.started) return;
+  var msg = { jsonrpc: "2.0", method: method };
+  if (params !== undefined) msg.params = params;
+  this._write(msg);
+};
+
+AcpProcessManager.prototype.respond = function(id, result) {
+  if (!this.proc || !this.started) return;
+  this._write({ jsonrpc: "2.0", id: id, result: result });
+};
+
+AcpProcessManager.prototype.respondError = function(id, code, message) {
+  if (!this.proc || !this.started) return;
+  this._write({ jsonrpc: "2.0", id: id, error: { code: code || -1, message: message || "Error" } });
+};
+
+AcpProcessManager.prototype._write = function(msg) {
+  if (!this.proc || !this.proc.stdin || this.proc.stdin.destroyed) return;
+  try {
+    this.proc.stdin.write(JSON.stringify(msg) + "\n");
+  } catch (e) {
+    this._error("Write error:", e.message);
+  }
+};
+
+AcpProcessManager.prototype._rejectAllPending = function(err) {
+  var ids = Object.keys(this.pendingRequests);
+  for (var i = 0; i < ids.length; i++) {
+    var pending = this.pendingRequests[ids[i]];
+    if (pending.timer) clearTimeout(pending.timer);
+    pending.reject(err);
+  }
+  this.pendingRequests = {};
+};
+
+AcpProcessManager.prototype.stop = function() {
+  this.started = false;
+  this._rejectAllPending(new Error("Stopped"));
+
+  if (this.rl) {
+    this.rl.close();
+    this.rl = null;
+  }
+  if (this.proc) {
+    try { this.proc.stdin.end(); } catch (e) {}
+    try { this.proc.kill("SIGTERM"); } catch (e) {}
+    this.proc = null;
+  }
+};
+
+module.exports = { AcpProcessManager: AcpProcessManager };