@zhushanwen/subagent-engine-sdk 0.2.0

package/dist/chunk-DSQ7JQKM.js

@@ -0,0 +1,39 @@
+// src/relay-env.ts
+var RELAY_ENV_SOCKET = "XYZ_SUBAGENT_RELAY_SOCKET";
+var RELAY_ENV_NODE = "XYZ_SUBAGENT_RELAY_NODE";
+var RELAY_ENV_SCRIPT = "XYZ_SUBAGENT_RELAY_SCRIPT";
+var RELAY_ENV_SESSION_ID = "XYZ_SUBAGENT_RELAY_SESSION_ID";
+var RELAY_ENV_RECORD_ID = "XYZ_SUBAGENT_RELAY_RECORD_ID";
+var RELAY_PROTOCOL_VERSION = 1;
+var RELAY_EXIT_CODES = {
+  /** 握手被拒：协议版本不匹配（安装损坏，重装应用）。 */
+  VERSION_MISMATCH: 10,
+  /** relay socket 不可达（runtime 未运行或已重启）。 */
+  SOCKET_UNREACHABLE: 11,
+  /** socket 中途断开（runtime 崩溃等）——代理生命线断即退。 */
+  SOCKET_CLOSED: 12,
+  /** 归属 env（SESSION_ID/RECORD_ID）缺失——防无归属帧污染广播。 */
+  MISSING_IDENTITY: 13
+};
+function isRelayActive(env) {
+  return Boolean(env[RELAY_ENV_SOCKET] && env[RELAY_ENV_NODE] && env[RELAY_ENV_SCRIPT]);
+}
+function readRelayForwardEnv(env) {
+  const socket = env[RELAY_ENV_SOCKET];
+  const node = env[RELAY_ENV_NODE];
+  const script = env[RELAY_ENV_SCRIPT];
+  if (!isRelayActive(env)) return void 0;
+  return { socket, node, script };
+}
+
+export {
+  RELAY_ENV_SOCKET,
+  RELAY_ENV_NODE,
+  RELAY_ENV_SCRIPT,
+  RELAY_ENV_SESSION_ID,
+  RELAY_ENV_RECORD_ID,
+  RELAY_PROTOCOL_VERSION,
+  RELAY_EXIT_CODES,
+  isRelayActive,
+  readRelayForwardEnv
+};

package/dist/chunk-EJMF63R5.js

@@ -0,0 +1,19 @@
+import {
+  getLogger
+} from "./chunk-75QEMUGV.js";
+
+// src/best-effort.ts
+var logger = getLogger("subagents");
+function bestEffort(err, context, level = "debug") {
+  const detail = err instanceof Error ? err.message : err;
+  const msg = `[subagents] best-effort ${context} failed`;
+  if (level === "error") {
+    logger.error(msg, { detail });
+  } else {
+    logger.debug(msg, { detail });
+  }
+}
+
+export {
+  bestEffort
+};

package/dist/chunk-GT6YLLN4.js

@@ -0,0 +1,46 @@
+import {
+  getLogger
+} from "./chunk-75QEMUGV.js";
+
+// src/data-dir.ts
+var logger = getLogger("subagents");
+var XYZ_DATA_DIR_ENV = "XYZ_AGENT_DATA_DIR";
+var WARNED_SLOT_KEY = /* @__PURE__ */ Symbol.for("@zhushanwen/subagent-engine-sdk.data-dir-warned");
+function getWarnedSlot() {
+  let slot = Reflect.get(globalThis, WARNED_SLOT_KEY);
+  if (!slot) {
+    slot = { current: false };
+    Reflect.set(globalThis, WARNED_SLOT_KEY, slot);
+  }
+  return slot;
+}
+function resetDataDirWarnForTests() {
+  getWarnedSlot().current = false;
+}
+function resolveEngineDataDir(env, opts = {}) {
+  const fromEnv = env[XYZ_DATA_DIR_ENV]?.trim();
+  if (fromEnv !== void 0 && fromEnv !== "") return fromEnv;
+  const fallback = opts.fallbackDataRoot?.trim();
+  if (fallback === void 0 || fallback === "") {
+    throw new Error(
+      `[subagent-engine-sdk] engine_not_found: ${XYZ_DATA_DIR_ENV} is not set and no fallback data root was injected. Recovery: the host must inject ${XYZ_DATA_DIR_ENV} into the engine process env (xyz-agent runtime / pi extension host do this at spawn), or pass { fallbackDataRoot } when calling resolveEngineDataDir from a host that resolves the data root itself.`
+    );
+  }
+  if (!getWarnedSlot().current) {
+    getWarnedSlot().current = true;
+    const warn = opts.warn ?? defaultWarn;
+    warn(
+      `[engine-data-dir] ${XYZ_DATA_DIR_ENV} is not set; engine journal/pool fall back to the injected data root (${fallback}). The xyz-agent host normally injects this env \u2014 if you are running inside xyz-agent, check the runtime spawn env; standalone installs intentionally use the injected root.`
+    );
+  }
+  return fallback;
+}
+function defaultWarn(msg) {
+  logger.warn(msg);
+}
+
+export {
+  XYZ_DATA_DIR_ENV,
+  resetDataDirWarnForTests,
+  resolveEngineDataDir
+};

package/dist/chunk-HYES77BR.js

@@ -0,0 +1,109 @@
+// src/logs/stderr-rotation.ts
+import * as fs from "fs";
+import { dirname, join } from "path";
+var BYTES_PER_KB = 1024;
+var DEFAULT_MAX_FILE_MB = 50;
+var MS_PER_SECOND = 1e3;
+var SECONDS_PER_MINUTE = 60;
+var MINUTES_PER_HOUR = 60;
+var HOURS_PER_DAY = 24;
+var DEFAULT_STDERR_MAX_BYTES = DEFAULT_MAX_FILE_MB * BYTES_PER_KB * BYTES_PER_KB;
+var DAY_MS = HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MS_PER_SECOND;
+var DEFAULT_STDERR_KEEP_DAYS = 7;
+function positiveIntEnv(env, key) {
+  const raw = env[key];
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function stderrRotationParams(env) {
+  return {
+    maxBytes: positiveIntEnv(env, "XYZ_LOG_MAX_BYTES") ?? DEFAULT_STDERR_MAX_BYTES,
+    keepDays: positiveIntEnv(env, "XYZ_LOG_KEEP_DAYS") ?? DEFAULT_STDERR_KEEP_DAYS
+  };
+}
+function stderrLogPathFor(engineDataDir, pid, prefix) {
+  return join(engineDataDir, "logs", `${prefix}${pid}.log`);
+}
+function stderrLogPidOf(fileName, prefix) {
+  if (!fileName.startsWith(prefix)) return void 0;
+  const rest = fileName.slice(prefix.length);
+  const pidToken = rest.split(".", 1)[0] ?? "";
+  if (!/^\d+$/.test(pidToken)) return void 0;
+  return Number(pidToken);
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function rotateStderrLogIfNeeded(path, params) {
+  let size;
+  try {
+    size = fs.statSync(path).size;
+  } catch {
+    return false;
+  }
+  if (size <= params.maxBytes) return false;
+  const rotated = `${path}.${Date.now()}`;
+  try {
+    fs.renameSync(path, rotated);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cleanupStaleStderrLogs(logsDir, env, prefix, now = Date.now()) {
+  const params = stderrRotationParams(env);
+  const expiryMs = params.keepDays * DAY_MS;
+  let deleted = 0;
+  let skipped = 0;
+  let names;
+  try {
+    names = fs.readdirSync(logsDir);
+  } catch {
+    return { deleted, skipped };
+  }
+  for (const name of names) {
+    const pid = stderrLogPidOf(name, prefix);
+    if (pid === void 0) continue;
+    if (isPidAlive(pid)) {
+      skipped += 1;
+      continue;
+    }
+    const full = join(logsDir, name);
+    try {
+      if (fs.statSync(full).mtimeMs > now - expiryMs) {
+        skipped += 1;
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    try {
+      fs.rmSync(full, { force: true });
+      deleted += 1;
+    } catch {
+      skipped += 1;
+    }
+  }
+  return { deleted, skipped };
+}
+function cleanupSiblingStderrLogs(logPath, env, prefix, now) {
+  return cleanupStaleStderrLogs(dirname(logPath), env, prefix, now);
+}
+
+export {
+  DEFAULT_STDERR_MAX_BYTES,
+  DEFAULT_STDERR_KEEP_DAYS,
+  stderrRotationParams,
+  stderrLogPathFor,
+  stderrLogPidOf,
+  isPidAlive,
+  rotateStderrLogIfNeeded,
+  cleanupStaleStderrLogs,
+  cleanupSiblingStderrLogs
+};

package/dist/chunk-JSBRDJBE.js

@@ -0,0 +1,30 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};

package/dist/chunk-LEOBWKRM.js

@@ -0,0 +1,128 @@
+import {
+  toErrorMessage
+} from "./chunk-PYO3YR7W.js";
+import {
+  engineTimeoutDetail
+} from "./chunk-PPEPBVCC.js";
+import {
+  getLogger
+} from "./chunk-75QEMUGV.js";
+
+// src/kill-chain.ts
+var logger = getLogger("subagents");
+var MS_PER_SECOND = 1e3;
+var DEFAULT_KILL_GRACE_MS = 5e3;
+var SIGKILL_REAP_TIMEOUT_MS = 1e4;
+var HOST_TIMEOUT_ABORT_REASON = "agent-call-timeout";
+async function killChain(child, opts) {
+  if (child.exitCode !== null || child.signalCode !== null) return "terminated";
+  const exited = waitForExit(child);
+  safeKill(child, "SIGTERM");
+  const graceful = await raceTimeout(exited, opts.graceMs, opts.unrefTimers === true);
+  if (graceful === "settled") return "terminated";
+  if (child.exitCode !== null || child.signalCode !== null) return "terminated";
+  if (opts.escalationNote !== void 0) {
+    logger.warn(
+      `[kill-chain] ${opts.escalationNote} still alive ${opts.graceMs / MS_PER_SECOND}s after SIGTERM, escalating to SIGKILL`
+    );
+  }
+  safeKill(child, "SIGKILL");
+  await raceTimeout(exited, SIGKILL_REAP_TIMEOUT_MS, opts.unrefTimers === true);
+  return "killed";
+}
+function safeKill(child, signal) {
+  try {
+    child.kill(signal);
+  } catch (err) {
+    logger.debug(
+      `[kill-chain] ${signal} on exited process: ${toErrorMessage(err)}`
+    );
+  }
+}
+function synthesizeTimeoutOutcome(task, stdoutTail, engineId) {
+  return {
+    content: "",
+    // slug 进错误信息：单看 outcome（record 之外）也能定位是哪个任务超时
+    error: `engine_timeout: [slug=${task.description ?? "unknown"}] ${engineTimeoutDetail(stdoutTail)}`,
+    // 被信号杀死：退出码语义为 null（§3.3.5 AgentOutcome.exitCode 注释）
+    exitCode: null,
+    engineId
+  };
+}
+var DEFAULT_NATIVE_INTERRUPT_GRACE_MS = 3e3;
+function abortWithFallback(child, signal, tryNativeInterrupt, opts) {
+  const graceMs = opts?.graceMs ?? DEFAULT_KILL_GRACE_MS;
+  const nativeGraceMs = opts?.nativeGraceMs ?? DEFAULT_NATIVE_INTERRUPT_GRACE_MS;
+  return new Promise((resolve) => {
+    let settled = false;
+    function finish(result) {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      resolve(result);
+    }
+    function onExit() {
+      finish("terminated");
+    }
+    function runChain() {
+      void (async () => {
+        if (tryNativeInterrupt) {
+          try {
+            await tryNativeInterrupt();
+          } catch (err) {
+            logger.debug(
+              `[kill-chain] native interrupt failed, falling back to kill chain: ${toErrorMessage(err)}`
+            );
+          }
+          const stopped = await raceTimeout(waitForExit(child), nativeGraceMs);
+          if (stopped === "settled" || settled) return;
+        }
+        finish(await killChain(child, { graceMs }));
+      })();
+    }
+    function onAbort() {
+      runChain();
+    }
+    child.once("exit", onExit);
+    if (child.exitCode !== null || child.signalCode !== null) {
+      finish("terminated");
+      return;
+    }
+    if (signal.aborted) runChain();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function waitForExit(child) {
+  return new Promise((resolve) => {
+    if (child.exitCode !== null || child.signalCode !== null) {
+      resolve();
+      return;
+    }
+    child.once("exit", () => resolve());
+  });
+}
+function raceTimeout(p, ms, unref = false) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve("timeout"), ms);
+    if (unref) timer.unref();
+    p.then(
+      () => {
+        clearTimeout(timer);
+        resolve("settled");
+      },
+      () => {
+        clearTimeout(timer);
+        resolve("settled");
+      }
+    );
+  });
+}
+
+export {
+  DEFAULT_KILL_GRACE_MS,
+  HOST_TIMEOUT_ABORT_REASON,
+  killChain,
+  synthesizeTimeoutOutcome,
+  DEFAULT_NATIVE_INTERRUPT_GRACE_MS,
+  abortWithFallback
+};

package/dist/chunk-N3RL6OVM.js

@@ -0,0 +1,38 @@
+import {
+  configureLoggerSink,
+  getLogger
+} from "./chunk-75QEMUGV.js";
+
+// src/cli-entry.ts
+import * as readline from "readline";
+var INBOUND_LOG_CHARS = 200;
+function runEngineCliEntry(opts) {
+  const logger = getLogger(opts.component);
+  const server = opts.server;
+  configureLoggerSink({
+    log(level, component, message, data) {
+      process.stderr.write(`[${level}] [${component}] ${message}${data !== void 0 ? ` ${JSON.stringify(data)}` : ""}
+`);
+      void server.reverseRequest("host/log", { level, component, message }).catch(() => void 0);
+    }
+  });
+  const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+  rl.on("line", (line) => {
+    const text = line.trim();
+    if (text === "") return;
+    try {
+      server.handleFrame(JSON.parse(text));
+    } catch (err) {
+      logger.warn(`unparseable inbound protocol line (ignored): ${text.slice(0, INBOUND_LOG_CHARS)}`, {
+        reason: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
+  rl.on("close", () => {
+    logger.debug("stdin closed (host exit path)");
+  });
+}
+
+export {
+  runEngineCliEntry
+};

package/dist/chunk-OPMY4G4M.js

@@ -0,0 +1,27 @@
+// src/paths.ts
+import { join } from "path";
+var MAX_SEG_CHARS = 80;
+function sanitizeSeg(input) {
+  const s = input.replace(/[^A-Za-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+  return s.length > 0 ? s.slice(0, MAX_SEG_CHARS) : "default";
+}
+function resolveEnginesRoot(dataDir) {
+  return join(dataDir, "engines");
+}
+function resolveEngineDir(dataDir, engineId) {
+  return join(resolveEnginesRoot(dataDir), sanitizeSeg(engineId));
+}
+function resolvePoolDir(dataDir, engineId, poolKey) {
+  return join(resolveEngineDir(dataDir, sanitizeSeg(engineId)), sanitizeSeg(poolKey));
+}
+function resolveJournalPath(dataDir, engineId, poolKey, taskId) {
+  return join(resolvePoolDir(dataDir, engineId, poolKey), `journal-${sanitizeSeg(taskId)}.jsonl`);
+}
+
+export {
+  sanitizeSeg,
+  resolveEnginesRoot,
+  resolveEngineDir,
+  resolvePoolDir,
+  resolveJournalPath
+};

package/dist/chunk-PPEPBVCC.js

@@ -0,0 +1,120 @@
+// src/protocol/engine-protocol.ts
+var ENGINE_PROTOCOL_VERSION = 1;
+var SUPPORTED_PROTOCOL_RANGE = { min: 1, max: 2 };
+function isProtocolVersionCompatible(version) {
+  return Number.isInteger(version) && version >= SUPPORTED_PROTOCOL_RANGE.min && version < SUPPORTED_PROTOCOL_RANGE.max;
+}
+var REVERSE_REQUEST_TIMEOUT_MS = 1e4;
+var HANDSHAKE_TIMEOUT_MS = 1e4;
+var CANCEL_SETTLE_GRACE_MS = 3e3;
+var CRASH_REBUILD_MAX_ATTEMPTS = 3;
+var CRASH_REBUILD_BACKOFF_STEP_1_MS = 1e3;
+var CRASH_REBUILD_BACKOFF_STEP_2_MS = 2e3;
+var CRASH_REBUILD_BACKOFF_STEP_3_MS = 4e3;
+var CRASH_REBUILD_BACKOFF_MS = [
+  CRASH_REBUILD_BACKOFF_STEP_1_MS,
+  CRASH_REBUILD_BACKOFF_STEP_2_MS,
+  CRASH_REBUILD_BACKOFF_STEP_3_MS
+];
+var STDERR_TAIL_CHARS = 400;
+var ENGINE_EVENT_COALESCE_ENV = "XYZ_ENGINE_EVENT_COALESCE";
+var ENGINE_EVENT_COALESCE_DEFAULT = "0";
+
+// src/protocol/error-codes.ts
+var ENGINE_PROTOCOL_ERROR_CODES = [
+  "engine_not_found",
+  "engine_protocol_mismatch",
+  "engine_capability_unsupported",
+  "engine_capability_mismatch",
+  "engine_model_unknown",
+  "engine_model_mismatch",
+  "engine_handshake_timeout",
+  "engine_crashed",
+  "engine_probe_failed"
+];
+function isEngineProtocolErrorCode(value) {
+  return typeof value === "string" && ENGINE_PROTOCOL_ERROR_CODES.includes(value);
+}
+var ENGINE_ERROR_CODE_PREFIX = "engine_";
+function isEngineErrorPassthroughCode(value) {
+  return !isEngineProtocolErrorCode(value) && value.startsWith(ENGINE_ERROR_CODE_PREFIX);
+}
+var EngineSdkError = class extends Error {
+  code;
+  recovery;
+  data;
+  constructor(code, detail, recovery, data) {
+    super(`${code}: ${detail}`);
+    this.name = "EngineSdkError";
+    this.code = code;
+    this.recovery = recovery;
+    this.data = data;
+  }
+  /** 协议 error 帧载荷投影。 */
+  toStructured() {
+    return { code: this.code, message: this.message, recovery: this.recovery, data: this.data };
+  }
+};
+function engineProtocolMismatchError(engineVersion) {
+  return new EngineSdkError(
+    "engine_protocol_mismatch",
+    `engine speaks protocol v${engineVersion}, host supports [${SUPPORTED_PROTOCOL_RANGE.min}, ${SUPPORTED_PROTOCOL_RANGE.max})`,
+    "Upgrade the engine package (or the host) so both sides speak a protocol version in the supported range, then re-run the task. The engine is marked unavailable until then.",
+    {
+      engineProtocolVersion: engineVersion,
+      supportedMin: SUPPORTED_PROTOCOL_RANGE.min,
+      supportedMaxExclusive: SUPPORTED_PROTOCOL_RANGE.max
+    }
+  );
+}
+function engineConversationUnsupportedError(engineId) {
+  return new EngineSdkError(
+    "engine_capability_unsupported",
+    `engine '${engineId}' \u4E0D\u652F\u6301 conversation\uFF08capabilities.conversation = 'unsupported'\uFF0Cmanifest \u65E0 conversation gate \u4F4D\u2014\u2014\u65E0\u540C\u8FDB\u7A0B idle \u590D\u7528\uFF0Cmessage/close \u4EA4\u4E92\u63A7\u5236\u9762\u4E0D\u53EF\u7528\uFF09`,
+    `\u53BB\u6389 conversation \u53C2\u6570\uFF08\u4E00\u6B21\u6027\u4EFB\u52A1\u9ED8\u8BA4\u5F62\u6001\uFF09\uFF0C\u6216\u4FEE manifest capabilities / \u5347\u7EA7\u5F15\u64CE\u5305\uFF08\u82E5\u5F15\u64CE\u5B9E\u9645\u652F\u6301\u8BE5\u80FD\u529B\uFF09`,
+    { engineId, capability: "conversation", declared: "unsupported" }
+  );
+}
+function assertChatConversationSupported(engineId, capabilities) {
+  if (capabilities.conversation === "unsupported") {
+    throw engineConversationUnsupportedError(engineId);
+  }
+}
+var DETAIL_ECHO_MAX_CHARS = 200;
+var STDOUT_TAIL_ECHO_CHARS = 2e3;
+function truncate(text, max) {
+  return text.length <= max ? text : `${text.slice(0, max)}...`;
+}
+var ENGINE_TIMEOUT_RECOVERY = "The engine was killed by the host timeout chain. Inspect the captured stdout tail, then re-run with a larger timeout, a narrower task, or `engine: pi`.";
+function engineTimeoutDetail(stdoutTail) {
+  return `host timeout chain exhausted (SIGTERM -> grace -> SIGKILL). Stdout tail (last ${STDOUT_TAIL_ECHO_CHARS} chars): ${truncate(stdoutTail, STDOUT_TAIL_ECHO_CHARS)}. Recovery: ${ENGINE_TIMEOUT_RECOVERY}`;
+}
+function schemaEmulationFailedDetail(error, tail) {
+  return `structured output emulation failed after tolerant extraction and one host-side retry: ${error}. Raw output tail: ${truncate(tail, DETAIL_ECHO_MAX_CHARS)}. Recovery: retry with a strengthened prompt or relax the schema; if it still fails switch to a schema-native engine (engine: pi).`;
+}
+
+export {
+  ENGINE_PROTOCOL_VERSION,
+  SUPPORTED_PROTOCOL_RANGE,
+  isProtocolVersionCompatible,
+  REVERSE_REQUEST_TIMEOUT_MS,
+  HANDSHAKE_TIMEOUT_MS,
+  CANCEL_SETTLE_GRACE_MS,
+  CRASH_REBUILD_MAX_ATTEMPTS,
+  CRASH_REBUILD_BACKOFF_MS,
+  STDERR_TAIL_CHARS,
+  ENGINE_EVENT_COALESCE_ENV,
+  ENGINE_EVENT_COALESCE_DEFAULT,
+  ENGINE_PROTOCOL_ERROR_CODES,
+  isEngineProtocolErrorCode,
+  ENGINE_ERROR_CODE_PREFIX,
+  isEngineErrorPassthroughCode,
+  EngineSdkError,
+  engineProtocolMismatchError,
+  engineConversationUnsupportedError,
+  assertChatConversationSupported,
+  STDOUT_TAIL_ECHO_CHARS,
+  ENGINE_TIMEOUT_RECOVERY,
+  engineTimeoutDetail,
+  schemaEmulationFailedDetail
+};

package/dist/chunk-PYO3YR7W.js

@@ -0,0 +1,16 @@
+// src/error-message.ts
+function toErrorMessage(e) {
+  if (e instanceof Error) return e.message;
+  if (typeof e === "object" && e !== null) {
+    try {
+      return JSON.stringify(e);
+    } catch {
+      return String(e);
+    }
+  }
+  return String(e);
+}
+
+export {
+  toErrorMessage
+};

package/dist/chunk-RDH3ZOV6.js

@@ -0,0 +1,46 @@
+// src/journal-io.ts
+import { readFileSync } from "fs";
+function replayJournal(path) {
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return [];
+  }
+  const lines = [];
+  for (const row of raw.split("\n")) {
+    const trimmed = row.trim();
+    if (trimmed === "") continue;
+    const parsed = parseLine(trimmed);
+    if (parsed !== void 0) lines.push(parsed);
+  }
+  lines.sort((a, b) => a.seq - b.seq);
+  return lines.map((l) => l.event);
+}
+function parseLine(trimmed) {
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null) return void 0;
+  const rec = parsed;
+  const event = rec.event;
+  if (rec.v !== 1 || typeof rec.ts !== "number" || typeof rec.seq !== "number") return void 0;
+  if (typeof event !== "object" || event === null || typeof event.type !== "string") {
+    return void 0;
+  }
+  return {
+    v: 1,
+    ts: rec.ts,
+    taskId: typeof rec.taskId === "string" ? rec.taskId : "",
+    engineId: typeof rec.engineId === "string" ? rec.engineId : "",
+    seq: rec.seq,
+    event
+  };
+}
+
+export {
+  replayJournal
+};

package/dist/chunk-RULLX6C6.js

@@ -0,0 +1,11 @@
+// src/port-contract.ts
+function parseCtxModel(ref) {
+  if (ref === void 0 || ref.trim() === "") return void 0;
+  const slash = ref.indexOf("/");
+  if (slash <= 0 || slash === ref.length - 1) return void 0;
+  return { provider: ref.slice(0, slash), id: ref.slice(slash + 1) };
+}
+
+export {
+  parseCtxModel
+};