@tangle-network/agent-runtime 0.48.0 → 0.49.0

package/dist/{chunk-656G2XCL.js → chunk-U2VEWKKK.js}

@@ -3,14 +3,14 @@ import {
 } from "./chunk-FNMGYYSS.js";
 import {
   createDefaultCoderDelegate
-} from "./chunk-LX66I3SC.js";
+} from "./chunk-GHX7XOJ2.js";
 import {
   runAnalystLoop
 } from "./chunk-HNUXAZIJ.js";
 import {
   createDriver,
   runLoop
-} from "./chunk-IW2LMLK6.js";
+} from "./chunk-PXUTIMGJ.js";
 import {
   ConfigError
 } from "./chunk-GSUO5QS6.js";
@@ -200,4 +200,4 @@ export {
   runLoopRunnerCli,
   parseLoopRunnerArgv
 };
-//# sourceMappingURL=chunk-656G2XCL.js.map
+//# sourceMappingURL=chunk-U2VEWKKK.js.map

package/dist/{chunk-JNPK46YH.js → chunk-VIEDXELL.js}

@@ -1,23 +1,231 @@
 import {
-  NotFoundError
+  formatDetachedSessionRef
+} from "./chunk-GHX7XOJ2.js";
+import {
+  AgentEvalError,
+  NotFoundError,
+  ValidationError
 } from "./chunk-GSUO5QS6.js";
 
+// src/mcp/delegation-store.ts
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname } from "path";
+var DelegationStateCorruptError = class extends AgentEvalError {
+  constructor(message, options) {
+    super("validation", message, options);
+  }
+};
+var DelegationPersistenceError = class extends AgentEvalError {
+  constructor(message, options) {
+    super("config", message, options);
+  }
+};
+var InMemoryDelegationStore = class {
+  records = /* @__PURE__ */ new Map();
+  async loadAll() {
+    return [...this.records.values()].map(cloneRecord);
+  }
+  async upsert(record) {
+    this.records.set(record.taskId, cloneRecord(record));
+  }
+  async lookupIdempotencyKey(key) {
+    for (const record of this.records.values()) {
+      if (record.idempotencyKey === key) return record.taskId;
+    }
+    return void 0;
+  }
+  async remove(taskIds) {
+    for (const taskId of taskIds) this.records.delete(taskId);
+  }
+};
+var STATE_FORMAT_VERSION = 1;
+var FileDelegationStore = class {
+  filePath;
+  recoverCorrupt;
+  records = /* @__PURE__ */ new Map();
+  loaded = false;
+  writeTail = Promise.resolve();
+  tmpSeq = 0;
+  constructor(options) {
+    this.filePath = options.filePath;
+    this.recoverCorrupt = options.recoverCorrupt ?? false;
+  }
+  async loadAll() {
+    let raw;
+    try {
+      raw = await readFile(this.filePath, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        this.loaded = true;
+        return [];
+      }
+      throw new DelegationPersistenceError(
+        `FileDelegationStore: failed to read ${this.filePath}: ${errorMessage(err)}`,
+        { cause: err }
+      );
+    }
+    let state;
+    try {
+      state = parsePersistedState(raw);
+    } catch (err) {
+      if (!this.recoverCorrupt) {
+        throw new DelegationStateCorruptError(
+          `FileDelegationStore: state file ${this.filePath} is corrupt (${errorMessage(err)}). Repair or archive the file, or opt into automatic recovery (recoverCorrupt / AGENT_RUNTIME_DELEGATION_STATE_RECOVER=1) to archive it and start empty.`,
+          { cause: err }
+        );
+      }
+      const archivePath = `${this.filePath}.corrupt-${Date.now()}`;
+      await rename(this.filePath, archivePath);
+      this.loaded = true;
+      return [];
+    }
+    this.records.clear();
+    for (const record of state.records) this.records.set(record.taskId, record);
+    this.loaded = true;
+    return [...this.records.values()].map(cloneRecord);
+  }
+  async upsert(record) {
+    this.assertLoaded("upsert");
+    this.records.set(record.taskId, cloneRecord(record));
+    await this.enqueueWrite();
+  }
+  async lookupIdempotencyKey(key) {
+    this.assertLoaded("lookupIdempotencyKey");
+    for (const record of this.records.values()) {
+      if (record.idempotencyKey === key) return record.taskId;
+    }
+    return void 0;
+  }
+  async remove(taskIds) {
+    this.assertLoaded("remove");
+    let changed = false;
+    for (const taskId of taskIds) {
+      if (this.records.delete(taskId)) changed = true;
+    }
+    if (changed) await this.enqueueWrite();
+  }
+  assertLoaded(op) {
+    if (this.loaded) return;
+    throw new DelegationPersistenceError(
+      `FileDelegationStore: ${op} called before loadAll() \u2014 the on-disk state has not been read yet`
+    );
+  }
+  enqueueWrite() {
+    const write = this.writeTail.then(() => this.writeSnapshot());
+    this.writeTail = write.catch(() => {
+    });
+    return write;
+  }
+  async writeSnapshot() {
+    const state = {
+      version: STATE_FORMAT_VERSION,
+      records: [...this.records.values()]
+    };
+    const payload = `${JSON.stringify(state)}
+`;
+    this.tmpSeq += 1;
+    const tmpPath = `${this.filePath}.tmp-${process.pid}-${this.tmpSeq}`;
+    try {
+      await mkdir(dirname(this.filePath), { recursive: true });
+      await writeFile(tmpPath, payload, "utf8");
+      await rename(tmpPath, this.filePath);
+    } catch (err) {
+      throw new DelegationPersistenceError(
+        `FileDelegationStore: failed to write ${this.filePath}: ${errorMessage(err)}`,
+        { cause: err }
+      );
+    }
+  }
+};
+function parsePersistedState(raw) {
+  const parsed = JSON.parse(raw);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("top-level value is not an object");
+  }
+  const state = parsed;
+  if (state.version !== STATE_FORMAT_VERSION) {
+    throw new Error(`unsupported state version ${JSON.stringify(state.version)}`);
+  }
+  if (!Array.isArray(state.records)) {
+    throw new Error("`records` is not an array");
+  }
+  for (const record of state.records) {
+    if (record === null || typeof record !== "object") {
+      throw new Error("a record entry is not an object");
+    }
+    const candidate = record;
+    if (typeof candidate.taskId !== "string" || typeof candidate.status !== "string") {
+      throw new Error("a record entry is missing `taskId`/`status`");
+    }
+  }
+  return { version: STATE_FORMAT_VERSION, records: state.records };
+}
+function cloneRecord(record) {
+  return structuredClone(record);
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
 // src/mcp/task-queue.ts
-var DelegationTaskQueue = class {
+var DelegationTaskQueue = class _DelegationTaskQueue {
   records = /* @__PURE__ */ new Map();
   controllers = /* @__PURE__ */ new Map();
   byIdempotencyKey = /* @__PURE__ */ new Map();
   generateId;
   now;
+  store;
+  resumeDelegate;
+  maxTerminalRecords;
+  onPersistError;
+  persistTail = Promise.resolve();
+  persistFailure;
   constructor(options = {}) {
     this.generateId = options.generateId ?? randomTaskId;
     this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    this.store = options.store ?? new InMemoryDelegationStore();
+    this.resumeDelegate = options.resumeDelegate;
+    if (options.maxTerminalRecords !== void 0) {
+      if (!Number.isInteger(options.maxTerminalRecords) || options.maxTerminalRecords < 1) {
+        throw new ValidationError(
+          `DelegationTaskQueue: maxTerminalRecords must be a positive integer, got ${String(options.maxTerminalRecords)}`
+        );
+      }
+    }
+    this.maxTerminalRecords = options.maxTerminalRecords ?? Number.POSITIVE_INFINITY;
+    this.onPersistError = options.onPersistError ?? ((error) => {
+      queueMicrotask(() => {
+        throw error;
+      });
+    });
+  }
+  /**
+   * Construct a queue from previously-persisted state. Loads every record
+   * from `options.store`, rebuilds the idempotency index (so a re-submitted
+   * identical task returns the prior taskId and its terminal state), then:
+   *
+   *   - terminal records stay queryable via `status()` / `history()`
+   *   - in-flight records with a `detachedSessionRef` re-attach through
+   *     `options.resumeDelegate` and report `running`
+   *   - other in-flight records settle as failed — their driver died with
+   *     the previous process and the result is unrecoverable
+   *
+   * The retention cap applies to the loaded set as well.
+   */
+  static async restore(options = {}) {
+    const queue = new _DelegationTaskQueue(options);
+    const loaded = await queue.store.loadAll();
+    queue.rehydrate(loaded);
+    return queue;
   }
   /**
    * Kick off a delegation in the background. Returns immediately. The
-   * `taskId` is queryable via `status` once this method returns.
+   * `taskId` is queryable via `status` once this method returns. Throws
+   * the recorded `DelegationPersistenceError` once the store has failed —
+   * the queue does not accept work it cannot journal.
    */
   submit(input) {
+    if (this.persistFailure) throw this.persistFailure;
     if (input.idempotencyKey) {
       const existing = this.byIdempotencyKey.get(input.idempotencyKey);
       if (existing && this.records.has(existing)) {
@@ -34,11 +242,13 @@ var DelegationTaskQueue = class {
       status: "pending",
       startedAt: this.now(),
       feedback: [],
-      idempotencyKey: input.idempotencyKey
+      idempotencyKey: input.idempotencyKey,
+      detachedSessionRef: input.detachedSessionRef
     };
     this.records.set(taskId, record);
     this.controllers.set(taskId, controller);
     if (input.idempotencyKey) this.byIdempotencyKey.set(input.idempotencyKey, taskId);
+    this.persist(record);
     queueMicrotask(() => {
       this.execute(taskId, input, controller);
     });
@@ -69,6 +279,8 @@ var DelegationTaskQueue = class {
     record.status = "cancelled";
     record.completedAt = this.now();
     record.error = { message: "cancelled by caller", kind: "CancelledError" };
+    this.persist(record);
+    this.enforceRetention();
     return true;
   }
   /**
@@ -81,6 +293,7 @@ var DelegationTaskQueue = class {
     const record = this.records.get(taskId);
     if (!record) return false;
     record.feedback.push(snapshot);
+    this.persist(record);
     return true;
   }
   /**
@@ -100,6 +313,15 @@ var DelegationTaskQueue = class {
     out.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
     return out.slice(0, limit);
   }
+  /**
+   * Await every journal write issued so far. Rejects with the recorded
+   * `DelegationPersistenceError` when any of them failed. Call before
+   * handing the store's backing file to another process.
+   */
+  async flush() {
+    await this.persistTail;
+    if (this.persistFailure) throw this.persistFailure;
+  }
   /** Test-only — number of in-flight (non-terminal) records. */
   inflightCount() {
     let n = 0;
@@ -112,26 +334,173 @@ var DelegationTaskQueue = class {
     const record = this.records.get(taskId);
     if (!record) return;
     record.status = "running";
+    this.persist(record);
     try {
       const output = await input.run({
         signal: controller.signal,
         report: (progress) => {
-          if (record.status === "running") record.progress = progress;
+          if (record.status === "running") {
+            record.progress = progress;
+            this.persist(record);
+          }
+        },
+        ...record.detachedSessionRef !== void 0 ? { detachedSessionRef: record.detachedSessionRef } : {},
+        updateDetachedSessionRef: (ref) => {
+          if (typeof ref !== "string" || ref.length === 0) {
+            throw new ValidationError(
+              "DelegationTaskQueue: updateDetachedSessionRef requires a non-empty ref"
+            );
+          }
+          if (isTerminal(currentStatus(record))) return;
+          record.detachedSessionRef = ref;
+          this.persist(record);
         }
       });
       if (currentStatus(record) === "cancelled") return;
       record.status = "completed";
       record.completedAt = this.now();
       record.result = { profile: input.profile, output };
+      this.persist(record);
+      this.enforceRetention();
     } catch (err) {
       if (currentStatus(record) === "cancelled") return;
       record.status = "failed";
       record.completedAt = this.now();
       record.error = errorToShape(err);
+      this.persist(record);
+      this.enforceRetention();
     } finally {
       this.controllers.delete(taskId);
     }
   }
+  rehydrate(loaded) {
+    const records = [...loaded].sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+    for (const record of records) {
+      this.records.set(record.taskId, record);
+      if (record.idempotencyKey) this.byIdempotencyKey.set(record.idempotencyKey, record.taskId);
+    }
+    for (const record of this.records.values()) {
+      if (isTerminal(record.status)) continue;
+      if (record.detachedSessionRef && this.resumeDelegate) {
+        record.status = "running";
+        this.persist(record);
+        this.startResume(record, record.detachedSessionRef, this.resumeDelegate);
+        continue;
+      }
+      record.status = "failed";
+      record.completedAt = this.now();
+      record.error = {
+        message: record.detachedSessionRef ? `delegation driver restarted while the task was in flight; detached session "${record.detachedSessionRef}" needs a resumeDelegate to be resumed` : "delegation driver restarted while the task was in flight; the run was not detached and cannot be resumed",
+        kind: "DriverRestartError"
+      };
+      this.persist(record);
+    }
+    this.enforceRetention();
+  }
+  startResume(record, detachedSessionRef, driver) {
+    const controller = new AbortController();
+    this.controllers.set(record.taskId, controller);
+    void this.driveResume(record, detachedSessionRef, driver, controller);
+  }
+  async driveResume(record, detachedSessionRef, driver, controller) {
+    const intervalMs = driver.intervalMs ?? 5e3;
+    const ctx = {
+      signal: controller.signal,
+      report: (progress) => {
+        if (currentStatus(record) !== "running") return;
+        record.progress = progress;
+        this.persist(record);
+      }
+    };
+    try {
+      while (!controller.signal.aborted && currentStatus(record) === "running") {
+        const tick = await driver.tick({ record: structuredClone(record), detachedSessionRef }, ctx);
+        if (currentStatus(record) === "cancelled") return;
+        if (tick.state === "completed") {
+          record.status = "completed";
+          record.completedAt = this.now();
+          record.result = {
+            profile: record.profile,
+            output: tick.output
+          };
+          if (tick.costUsd !== void 0) record.costUsd = tick.costUsd;
+          this.persist(record);
+          this.enforceRetention();
+          return;
+        }
+        if (tick.state === "failed") {
+          record.status = "failed";
+          record.completedAt = this.now();
+          record.error = tick.error;
+          this.persist(record);
+          this.enforceRetention();
+          return;
+        }
+        await abortableDelay(intervalMs, controller.signal);
+      }
+    } catch (err) {
+      if (currentStatus(record) === "cancelled") return;
+      record.status = "failed";
+      record.completedAt = this.now();
+      record.error = errorToShape(err);
+      this.persist(record);
+      this.enforceRetention();
+    } finally {
+      this.controllers.delete(record.taskId);
+    }
+  }
+  persist(record) {
+    if (this.persistFailure) return;
+    const snapshot = structuredClone(record);
+    this.persistTail = this.persistTail.then(async () => {
+      if (this.persistFailure) return;
+      try {
+        await this.store.upsert(snapshot);
+      } catch (err) {
+        this.failPersistence(err);
+      }
+    });
+  }
+  persistRemoval(taskIds) {
+    if (this.persistFailure || taskIds.length === 0) return;
+    this.persistTail = this.persistTail.then(async () => {
+      if (this.persistFailure) return;
+      try {
+        await this.store.remove(taskIds);
+      } catch (err) {
+        this.failPersistence(err);
+      }
+    });
+  }
+  failPersistence(cause) {
+    if (this.persistFailure) return;
+    const error = cause instanceof DelegationPersistenceError ? cause : new DelegationPersistenceError(
+      `DelegationTaskQueue: store write failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+      { cause }
+    );
+    this.persistFailure = error;
+    this.onPersistError(error);
+  }
+  enforceRetention() {
+    if (!Number.isFinite(this.maxTerminalRecords)) return;
+    const terminal = [];
+    for (const record of this.records.values()) {
+      if (isTerminal(record.status)) terminal.push(record);
+    }
+    const excess = terminal.length - this.maxTerminalRecords;
+    if (excess <= 0) return;
+    terminal.sort(
+      (a, b) => (a.completedAt ?? a.startedAt).localeCompare(b.completedAt ?? b.startedAt)
+    );
+    const evicted = terminal.slice(0, excess);
+    for (const record of evicted) {
+      this.records.delete(record.taskId);
+      if (record.idempotencyKey && this.byIdempotencyKey.get(record.idempotencyKey) === record.taskId) {
+        this.byIdempotencyKey.delete(record.idempotencyKey);
+      }
+    }
+    this.persistRemoval(evicted.map((record) => record.taskId));
+  }
 };
 function isTerminal(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
@@ -145,6 +514,23 @@ function clampLimit(raw) {
   if (n <= 0) return 50;
   return Math.min(n, 500);
 }
+function abortableDelay(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 function toStatusResult(record) {
   const out = {
     taskId: record.taskId,
@@ -351,11 +737,17 @@ function createDelegateCodeHandler(options) {
       config: args.config,
       namespace: args.namespace
     });
+    const detached = options.detachedDispatch === true && (args.variants ?? 1) <= 1;
     const submitted = options.queue.submit({
       profile: "coder",
       args,
       namespace: args.namespace,
       idempotencyKey,
+      ...detached ? {
+        detachedSessionRef: formatDetachedSessionRef({
+          sessionId: `dlg-turn-coder-${idempotencyKey}`
+        })
+      } : {},
       run: async (ctx) => options.delegate(args, ctx)
     });
     return {
@@ -702,11 +1094,17 @@ function createDelegateResearchHandler(options) {
       variants: args.variants ?? 1,
       config: args.config
     });
+    const detached = options.detachedDispatch === true && (args.variants ?? 1) <= 1;
     const submitted = options.queue.submit({
       profile: "researcher",
       args,
       namespace: args.namespace,
       idempotencyKey,
+      ...detached ? {
+        detachedSessionRef: formatDetachedSessionRef({
+          sessionId: `dlg-turn-research-${idempotencyKey}`
+        })
+      } : {},
       run: async (ctx) => options.delegate(args, ctx)
     });
     return {
@@ -1170,6 +1568,10 @@ async function exportEvalRuns(events, config) {
 }
 
 export {
+  DelegationStateCorruptError,
+  DelegationPersistenceError,
+  InMemoryDelegationStore,
+  FileDelegationStore,
   DelegationTaskQueue,
   hashIdempotencyInput,
   DELEGATE_CODE_TOOL_NAME,
@@ -1205,4 +1607,4 @@ export {
   INTELLIGENCE_WIRE_VERSION,
   exportEvalRuns
 };
-//# sourceMappingURL=chunk-JNPK46YH.js.map
+//# sourceMappingURL=chunk-VIEDXELL.js.map