@dudousxd/nestjs-agent-core 0.37.0 → 0.38.0

package/dist/index.cjs

@@ -91,6 +91,7 @@ __export(src_exports, {
   SCHEMA_EXTENSION: () => SCHEMA_EXTENSION,
   SKILL_TOOL_DESCRIPTION: () => SKILL_TOOL_DESCRIPTION,
   SKILL_TOOL_NAME: () => SKILL_TOOL_NAME,
+  SqlTokenStreamSink: () => SqlTokenStreamSink,
   StructuredOutputError: () => StructuredOutputError,
   THREAD_DETAIL_CONTENT_CHARS: () => THREAD_DETAIL_CONTENT_CHARS,
   ToolDisabledError: () => ToolDisabledError,
@@ -321,7 +322,7 @@ __name(decodeStreamEvent, "decodeStreamEvent");
 
 // src/turn-frames.ts
 function observeTurnFrames(writer, now = Date.now) {
-  const decoder2 = new TextDecoder();
+  const decoder3 = new TextDecoder();
   let pending = "";
   let reasoning = "";
   let reasoningMs = 0;
@@ -361,7 +362,7 @@ function observeTurnFrames(writer, now = Date.now) {
   }
   __name(observeLine, "observeLine");
   function observe(chunk) {
-    pending += decoder2.decode(chunk, {
+    pending += decoder3.decode(chunk, {
       stream: true
     });
     let newline = pending.indexOf("\n");
@@ -6330,6 +6331,245 @@ function defineConfirmedTool(options, steps) {
   };
 }
 __name(defineConfirmedTool, "defineConfirmedTool");
+
+// src/sql-token-stream-sink.ts
+var DEFAULT_TTL_SECONDS = 3600;
+var DEFAULT_POLL_INTERVAL_MS = 250;
+var DEFAULT_IDLE_POLL_INTERVAL_MS = 1e3;
+var IDLE_AFTER_MS = 5e3;
+var DEFAULT_FLUSH_MS = 50;
+var READ_PAGE = 500;
+var PURGE_CHUNK = 200;
+var AUTO_PURGE_EVERY_MS = 6e4;
+var APPEND_ATTEMPTS = 8;
+var decoder2 = new TextDecoder();
+var encoder2 = new TextEncoder();
+var sleep = /* @__PURE__ */ __name((ms) => new Promise((resolve) => setTimeout(resolve, ms)), "sleep");
+function textOf(line) {
+  if (!line.startsWith('{"kind":"text"')) return null;
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed === "object" && parsed !== null && Object.keys(parsed).length === 2 && parsed.kind === "text" && typeof parsed.text === "string") {
+      return parsed.text;
+    }
+  } catch {
+  }
+  return null;
+}
+__name(textOf, "textOf");
+var SqlTokenStreamSink = class {
+  static {
+    __name(this, "SqlTokenStreamSink");
+  }
+  table;
+  pollIntervalMs;
+  idlePollIntervalMs;
+  flushMs;
+  ttlSeconds;
+  autoPurge;
+  writes = /* @__PURE__ */ new Map();
+  lastAutoPurge = 0;
+  constructor(table, options = {}) {
+    this.table = table;
+    this.pollIntervalMs = Math.max(1, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+    this.idlePollIntervalMs = Math.max(this.pollIntervalMs, options.idlePollIntervalMs ?? DEFAULT_IDLE_POLL_INTERVAL_MS);
+    this.flushMs = Math.max(0, options.flushMs ?? DEFAULT_FLUSH_MS);
+    this.ttlSeconds = options.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+    this.autoPurge = options.autoPurge ?? true;
+  }
+  runWrites(runId) {
+    let state = this.writes.get(runId);
+    if (state === void 0) {
+      state = {
+        text: null,
+        timer: void 0,
+        tail: Promise.resolve(),
+        pending: 0,
+        failure: void 0
+      };
+      this.writes.set(runId, state);
+    }
+    return state;
+  }
+  /** Forget a run's write state once nothing is gathered, queued or left to report. */
+  release(runId, state) {
+    if (state.pending === 0 && state.text === null && state.failure === void 0 && this.writes.get(runId) === state) {
+      this.writes.delete(runId);
+    }
+  }
+  /** Queue `work` behind every write already queued for the run, so rows land in call order. */
+  enqueue(runId, state, work) {
+    state.pending += 1;
+    const next = state.tail.then(work);
+    state.tail = next.then(() => void 0, () => void 0).then(() => {
+      state.pending -= 1;
+      this.release(runId, state);
+    });
+    return next;
+  }
+  /** Queue the gathered text (if any) as one `text` row. */
+  flushText(runId, state) {
+    if (state.timer !== void 0) {
+      clearTimeout(state.timer);
+      state.timer = void 0;
+    }
+    if (state.text === null) return Promise.resolve();
+    const line = decoder2.decode(encodeStreamEvent({
+      kind: "text",
+      text: state.text
+    }));
+    state.text = null;
+    return this.enqueue(runId, state, () => this.append(runId, line, null));
+  }
+  /** Raise, once, a gathered write that failed with nobody awaiting it. */
+  raiseFailure(state) {
+    const failure = state.failure;
+    if (failure !== void 0) {
+      state.failure = void 0;
+      throw failure.error;
+    }
+  }
+  /** Append one row — a frame, or the terminal row (`frame: null`, with `error` on a failure). */
+  async append(runId, frame, error) {
+    for (let attempt = 1; ; attempt += 1) {
+      try {
+        await this.table.append(runId, {
+          frame,
+          error,
+          createdAt: Date.now()
+        });
+        return;
+      } catch (caught) {
+        if (attempt >= APPEND_ATTEMPTS || !this.table.isUniqueViolation(caught)) throw caught;
+      }
+    }
+  }
+  /** Write out what is gathered, then a terminal row; raise a failure nobody saw. */
+  async terminate(runId, error) {
+    const state = this.runWrites(runId);
+    const flushed = this.flushText(runId, state);
+    const ended = this.enqueue(runId, state, () => this.append(runId, null, error));
+    await Promise.all([
+      flushed,
+      ended
+    ]);
+    this.raiseFailure(state);
+    this.release(runId, state);
+    this.purgeInBackground();
+  }
+  /**
+  * The run's writer. Writers opened for the same run in one process share what they are gathering,
+  * so a delegated run's text (forwarded through a child writer) and its parent's next frame keep
+  * the order they were written in.
+  */
+  open(runId) {
+    return {
+      write: /* @__PURE__ */ __name(async (chunk) => {
+        const state = this.runWrites(runId);
+        this.raiseFailure(state);
+        const line = decoder2.decode(chunk);
+        const text = this.flushMs > 0 ? textOf(line.trimEnd()) : null;
+        if (text !== null) {
+          state.text = (state.text ?? "") + text;
+          if (state.timer === void 0) {
+            state.timer = setTimeout(() => {
+              state.timer = void 0;
+              this.flushText(runId, state).catch((error) => {
+                state.failure = {
+                  error
+                };
+              });
+            }, this.flushMs);
+          }
+          return;
+        }
+        const flushed = this.flushText(runId, state);
+        const appended = this.enqueue(runId, state, () => this.append(runId, line, null));
+        await Promise.all([
+          flushed,
+          appended
+        ]);
+      }, "write"),
+      flush: /* @__PURE__ */ __name(async () => {
+        const state = this.runWrites(runId);
+        const flushed = this.flushText(runId, state);
+        await Promise.all([
+          flushed,
+          state.tail
+        ]);
+        this.raiseFailure(state);
+        this.release(runId, state);
+      }, "flush"),
+      end: /* @__PURE__ */ __name(() => this.terminate(runId, null), "end"),
+      fail: /* @__PURE__ */ __name((error) => this.terminate(runId, JSON.stringify({
+        code: error.code,
+        message: error.message
+      })), "fail")
+    };
+  }
+  async *subscribe(runId) {
+    let cursor = 0;
+    let quietSince = Date.now();
+    while (true) {
+      const rows = await this.table.read(runId, cursor, READ_PAGE);
+      for (const row of rows) {
+        cursor = row.seq;
+        if (row.frame === null) {
+          if (row.error !== null) {
+            throw new AgentStreamError(JSON.parse(row.error));
+          }
+          return;
+        }
+        yield encoder2.encode(row.frame);
+      }
+      if (rows.length > 0) {
+        quietSince = Date.now();
+        if (rows.length >= READ_PAGE) continue;
+      }
+      await sleep(Date.now() - quietSince >= IDLE_AFTER_MS ? this.idlePollIntervalMs : this.pollIntervalMs);
+    }
+  }
+  /** Does the table hold anything for the run — a frame, or its end? */
+  has(runId) {
+    return this.table.has(runId);
+  }
+  async close(runId) {
+    const state = this.writes.get(runId);
+    if (state !== void 0) {
+      if (state.timer !== void 0) clearTimeout(state.timer);
+      state.timer = void 0;
+      state.text = null;
+      state.failure = void 0;
+      await state.tail;
+      this.writes.delete(runId);
+    }
+    await this.table.remove([
+      runId
+    ]);
+  }
+  /**
+  * Delete every run whose last write is older than `ttlSeconds` at `now` (epoch-ms) — ended runs
+  * past their replay window and runs that crashed without ending alike. Returns how many runs went.
+  * Safe from any replica, and from several at once. A no-op under `ttlSeconds: 0`.
+  */
+  async purgeExpired(now = Date.now()) {
+    if (this.ttlSeconds <= 0) return 0;
+    const lapsed = await this.table.lapsedRuns(now - this.ttlSeconds * 1e3);
+    for (let index = 0; index < lapsed.length; index += PURGE_CHUNK) {
+      await this.table.remove(lapsed.slice(index, index + PURGE_CHUNK));
+    }
+    return lapsed.length;
+  }
+  /** {@link purgeExpired}, unawaited and at most once a minute. Its failure is not the run's. */
+  purgeInBackground() {
+    if (!this.autoPurge || this.ttlSeconds <= 0) return;
+    const now = Date.now();
+    if (now - this.lastAutoPurge < AUTO_PURGE_EVERY_MS) return;
+    this.lastAutoPurge = now;
+    this.purgeExpired(now).catch(() => {
+    });
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_ACTOR_DIRECTORY,
@@ -6402,6 +6642,7 @@ __name(defineConfirmedTool, "defineConfirmedTool");
   SCHEMA_EXTENSION,
   SKILL_TOOL_DESCRIPTION,
   SKILL_TOOL_NAME,
+  SqlTokenStreamSink,
   StructuredOutputError,
   THREAD_DETAIL_CONTENT_CHARS,
   ToolDisabledError,