@dadado/agent-kit-cli 6.3.0 → 6.4.0

package/dist/chunk-MWTXI6C5.js

@@ -0,0 +1,223 @@
+import {
+  formatHitlGateLine
+} from "./chunk-IRTS7WEA.js";
+
+// src/plan-loop/driver-events.ts
+import { createInterface } from "readline";
+import { StringDecoder } from "string_decoder";
+var DRIVER_PROTOCOL_MAJOR = 1;
+var DRIVER_PROTOCOL_VERSION = "1.1.0";
+var DRIVER_EVENTS_FORMATS = ["ndjson"];
+var INBOUND_MAX_CHARS = 64 * 1024;
+var AGENT_PENDING_MAX_CHARS = 4 * 1024 * 1024;
+function formatDriverEvent(event, now = () => /* @__PURE__ */ new Date()) {
+  return `${JSON.stringify({ v: DRIVER_PROTOCOL_MAJOR, ts: now().toISOString(), ...event })}
+`;
+}
+function createDriverEmitter(write = (text) => {
+  process.stdout.write(text);
+}, now) {
+  return {
+    emit(event) {
+      try {
+        write(formatDriverEvent(event, now));
+      } catch {
+      }
+    }
+  };
+}
+function parseDriverInbound(line) {
+  const text = line.trim();
+  if (text.length > INBOUND_MAX_CHARS) return { ok: false, error: "line too long" };
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return { ok: false, error: "not JSON" };
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, error: "not a JSON object" };
+  }
+  const msg = value;
+  if (msg.v !== void 0 && msg.v !== DRIVER_PROTOCOL_MAJOR) {
+    return { ok: false, error: `unsupported protocol v${String(msg.v)}` };
+  }
+  if (msg.type === "stop") {
+    return {
+      ok: true,
+      message: { type: "stop", ...typeof msg.reason === "string" ? { reason: msg.reason } : {} }
+    };
+  }
+  if (msg.type !== "hitl_reply")
+    return { ok: false, error: `unknown type ${JSON.stringify(msg.type)}` };
+  if (typeof msg.askId !== "string" || !/^[a-z0-9-]+$/.test(msg.askId)) {
+    return { ok: false, error: "hitl_reply.askId must be a kebab-case string" };
+  }
+  if (typeof msg.reply === "number") {
+    if (!Number.isInteger(msg.reply) || msg.reply < 1) {
+      return { ok: false, error: "hitl_reply.reply number must be a positive integer" };
+    }
+    return { ok: true, message: { type: "hitl_reply", askId: msg.askId, reply: msg.reply } };
+  }
+  if (typeof msg.reply === "string" && msg.reply.trim() && !/[\r\n]/.test(msg.reply)) {
+    return { ok: true, message: { type: "hitl_reply", askId: msg.askId, reply: msg.reply.trim() } };
+  }
+  return { ok: false, error: "hitl_reply.reply must be a number or a one-line non-empty string" };
+}
+function inboundToRawAnswer(gate, parsed) {
+  if (!parsed.ok) return { kind: "stop", cause: "protocol error", detail: parsed.error };
+  const message = parsed.message;
+  if (message.type === "stop") return { kind: "stop", cause: "driver stop" };
+  if (message.askId !== gate.askId) {
+    return {
+      kind: "stop",
+      cause: "protocol error",
+      detail: `reply for ${message.askId} while gate ${gate.askId} is open`
+    };
+  }
+  return { kind: "line", text: String(message.reply) };
+}
+function createDriverAnswerReader(opts) {
+  const input = opts.input ?? process.stdin;
+  const queue = [];
+  let ended = false;
+  let waiter = null;
+  let rl = null;
+  const ensure = () => {
+    if (rl) return;
+    rl = createInterface({ input, terminal: false, crlfDelay: Number.POSITIVE_INFINITY });
+    rl.on("line", (line) => {
+      if (!line.trim()) return;
+      if (waiter) {
+        const w = waiter;
+        waiter = null;
+        w(line);
+      } else queue.push(line);
+    });
+    rl.on("close", () => {
+      ended = true;
+      if (waiter) {
+        const w = waiter;
+        waiter = null;
+        w(null);
+      }
+    });
+  };
+  const nextLine = (signal) => new Promise((resolve) => {
+    const queued = queue.shift();
+    if (queued !== void 0) {
+      resolve(queued);
+      return;
+    }
+    if (ended) {
+      resolve(null);
+      return;
+    }
+    const onAbort = () => {
+      if (waiter === settle) waiter = null;
+      resolve(null);
+    };
+    const settle = (line) => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve(line);
+    };
+    if (signal?.aborted) {
+      resolve(null);
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    waiter = settle;
+  });
+  return {
+    read: async (gate, readOpts) => {
+      ensure();
+      opts.emitter.emit({
+        type: "hitl_gate",
+        tick: opts.tick(),
+        askId: gate.askId,
+        labels: [...gate.labels],
+        detection: gate.detection,
+        line: formatHitlGateLine(gate)
+      });
+      const line = await nextLine(readOpts.signal);
+      if (line === null) return { kind: "eof" };
+      return inboundToRawAnswer(gate, parseDriverInbound(line));
+    },
+    close: () => {
+      const r = rl;
+      rl = null;
+      r?.close();
+      if (typeof input.pause === "function") {
+        input.pause();
+      }
+    }
+  };
+}
+var DriverAgentSink = class {
+  constructor(emitter, tick) {
+    this.emitter = emitter;
+    this.tick = tick;
+  }
+  emitter;
+  tick;
+  pending = "";
+  dropped = false;
+  decoder = new StringDecoder("utf8");
+  feed(chunk) {
+    try {
+      const text = typeof chunk === "string" ? chunk : this.decoder.write(chunk);
+      if (!text) return;
+      const lines = (this.pending + text).split("\n");
+      this.pending = lines.pop() ?? "";
+      for (const line of lines) {
+        if (this.dropped) {
+          this.dropped = false;
+          continue;
+        }
+        this.take(line);
+      }
+      if (this.pending.length > AGENT_PENDING_MAX_CHARS) {
+        this.pending = "";
+        this.dropped = true;
+      }
+    } catch {
+    }
+  }
+  end() {
+    try {
+      const rest = this.pending + this.decoder.end();
+      this.pending = "";
+      if (rest && !this.dropped) this.take(rest);
+      this.dropped = false;
+    } catch {
+    }
+  }
+  take(raw) {
+    const line = raw.replace(/\r$/, "");
+    if (!line.trim()) return;
+    const trimmed = line.trim();
+    if (trimmed.startsWith("{")) {
+      try {
+        const event = JSON.parse(trimmed);
+        if (typeof event === "object" && event !== null && !Array.isArray(event)) {
+          this.emitter.emit({
+            type: "agent_event",
+            tick: this.tick,
+            event
+          });
+          return;
+        }
+      } catch {
+      }
+    }
+    this.emitter.emit({ type: "agent_text", tick: this.tick, text: line });
+  }
+};
+
+export {
+  DRIVER_PROTOCOL_VERSION,
+  DRIVER_EVENTS_FORMATS,
+  createDriverEmitter,
+  createDriverAnswerReader,
+  DriverAgentSink
+};