@qjp88995/agent-runtime 0.0.0-stage → 0.1.0

package/src/in-process/question-store.ts

@@ -0,0 +1,155 @@
+import { randomUUID } from 'node:crypto';
+
+import type { AgentQuestionAnswer } from '../builtins/ask-schema.js';
+import {
+  type NewQuestion,
+  QuestionConflictError,
+  type QuestionProbe,
+  type QuestionRecord,
+  type QuestionStore,
+  type SettledQuestionStatus,
+} from '../ports/question-store.js';
+
+/**
+ * 内存问题行。时钟可注入（单测拨表判到期）；读—改—写之间没有 await，单线程里
+ * 天然原子（`open` 的「作废残骸 + 插入」与各个 pending 谓词都靠这一点）。
+ */
+export class InMemoryQuestionStore implements QuestionStore {
+  private readonly rows = new Map<string, QuestionRecord>();
+
+  constructor(private readonly clock: () => number = Date.now) {}
+
+  /** 删掉一个会话的全部问题（单测模拟「会话被删」，数据库里是级联删除）。 */
+  deleteSession(sessionId: string): void {
+    for (const [id, row] of this.rows) {
+      if (row.sessionId === sessionId) this.rows.delete(id);
+    }
+  }
+
+  open(
+    input: NewQuestion
+  ): Promise<{ question: QuestionRecord; swept: QuestionRecord[] }> {
+    const pending = [...this.rows.values()].filter(
+      r => r.sessionId === input.sessionId && r.status === 'pending'
+    );
+    if (pending.some(r => r.runId === input.runId)) {
+      return Promise.reject(new QuestionConflictError(input.sessionId));
+    }
+    const now = this.clock();
+    const swept = pending.map(r => {
+      const next = this.write(r.id, {
+        status: 'cancelled',
+        resolvedAt: new Date(now),
+      });
+      return next;
+    });
+    const row: QuestionRecord = {
+      id: randomUUID(),
+      sessionId: input.sessionId,
+      userId: input.userId,
+      runId: input.runId,
+      toolCallId: input.toolCallId,
+      questions: structuredClone(input.questions),
+      status: 'pending',
+      deadlineAt:
+        input.timeoutSeconds === undefined
+          ? null
+          : new Date(now + input.timeoutSeconds * 1000),
+      answers: null,
+      createdAt: new Date(now),
+      resolvedAt: null,
+    };
+    this.rows.set(row.id, row);
+    return Promise.resolve({ question: copy(row), swept });
+  }
+
+  probe(id: string, maxWaitSeconds: number): Promise<QuestionProbe | null> {
+    const row = this.rows.get(id);
+    if (!row) return Promise.resolve(null);
+    const now = this.clock();
+    return Promise.resolve({
+      question: copy(row),
+      due: row.deadlineAt !== null && row.deadlineAt.getTime() <= now,
+      overdue: row.createdAt.getTime() + maxWaitSeconds * 1000 <= now,
+    });
+  }
+
+  get(id: string, sessionId?: string): Promise<QuestionRecord | null> {
+    const row = this.rows.get(id);
+    if (!row || (sessionId !== undefined && row.sessionId !== sessionId)) {
+      return Promise.resolve(null);
+    }
+    return Promise.resolve(copy(row));
+  }
+
+  settle(
+    id: string,
+    status: SettledQuestionStatus,
+    answers: AgentQuestionAnswer[] | null
+  ): Promise<QuestionRecord | null> {
+    const row = this.rows.get(id);
+    if (!row || row.status !== 'pending') return Promise.resolve(null);
+    return Promise.resolve(
+      this.write(id, {
+        status,
+        answers: answers ? structuredClone(answers) : null,
+        resolvedAt: new Date(this.clock()),
+      })
+    );
+  }
+
+  settleSession(
+    sessionId: string,
+    status: 'superseded' | 'cancelled',
+    onlyId?: string
+  ): Promise<QuestionRecord[]> {
+    const resolvedAt = new Date(this.clock());
+    const out: QuestionRecord[] = [];
+    for (const row of this.sorted()) {
+      if (row.sessionId !== sessionId || row.status !== 'pending') continue;
+      if (onlyId !== undefined && row.id !== onlyId) continue;
+      out.push(this.write(row.id, { status, resolvedAt }));
+    }
+    return Promise.resolve(out);
+  }
+
+  hold(id: string, sessionId: string): Promise<QuestionRecord | null> {
+    const row = this.rows.get(id);
+    if (
+      !row ||
+      row.sessionId !== sessionId ||
+      row.status !== 'pending' ||
+      row.deadlineAt === null
+    ) {
+      return Promise.resolve(null);
+    }
+    return Promise.resolve(this.write(id, { deadlineAt: null }));
+  }
+
+  list(sessionId: string): Promise<QuestionRecord[]> {
+    return Promise.resolve(
+      this.sorted()
+        .filter(r => r.sessionId === sessionId)
+        .map(copy)
+    );
+  }
+
+  now(): Promise<Date> {
+    return Promise.resolve(new Date(this.clock()));
+  }
+
+  /** 落行顺序（Map 保插入序；同一毫秒落的两行也分得清先后）。 */
+  private sorted(): QuestionRecord[] {
+    return [...this.rows.values()];
+  }
+
+  private write(id: string, patch: Partial<QuestionRecord>): QuestionRecord {
+    const row = { ...this.rows.get(id)!, ...patch };
+    this.rows.set(id, row);
+    return copy(row);
+  }
+}
+
+function copy(row: QuestionRecord): QuestionRecord {
+  return structuredClone(row);
+}

package/src/in-process/run-store.ts

@@ -0,0 +1,115 @@
+import type {
+  RunFinishInput,
+  RunOpenInput,
+  RunStore,
+  StaleRun,
+} from '../ports/run-store.js';
+import type {
+  AgentRunStatus,
+  AgentRunStepEntry,
+  StopReason,
+} from '../schema/agent-run.js';
+
+/** 内存里的一条跑次记录（也是 `InMemoryRunStore.get` 的返回形状，便于单测断言）。 */
+export interface StoredRun extends RunOpenInput {
+  status: AgentRunStatus;
+  stopReason: StopReason | null;
+  text: string;
+  steps: AgentRunStepEntry[];
+  usage?: Record<string, number>;
+  error?: string;
+  startedAt: number;
+  finishedAt: number | null;
+}
+
+/**
+ * 内存跑次记录。进程重启即丢；`rootSessionId` 由构造时给的查询函数补
+ * （跑次本身只记 sessionId，根会话归会话存储管）。
+ */
+export class InMemoryRunStore implements RunStore {
+  private readonly runs = new Map<string, StoredRun>();
+  private readonly now: () => number;
+  private readonly rootOf: (sessionId: string) => string | null;
+
+  constructor(
+    options: {
+      now?: () => number;
+      /** sessionId → 根会话 id。缺省把 sessionId 自己当根。 */
+      rootSessionOf?: (sessionId: string) => string | null;
+    } = {}
+  ) {
+    this.now = options.now ?? Date.now;
+    this.rootOf = options.rootSessionOf ?? (id => id);
+  }
+
+  async open(input: RunOpenInput): Promise<void> {
+    if (this.runs.has(input.id)) {
+      throw new Error(`run '${input.id}' already exists`);
+    }
+    this.runs.set(input.id, {
+      ...input,
+      status: 'running',
+      stopReason: null,
+      text: '',
+      steps: [],
+      startedAt: this.now(),
+      finishedAt: null,
+    });
+  }
+
+  async finish(input: RunFinishInput): Promise<void> {
+    const run = this.runs.get(input.id);
+    if (!run) return;
+    Object.assign(run, {
+      status: input.status,
+      stopReason: input.stopReason,
+      text: input.text,
+      steps: input.steps,
+      usage: input.usage,
+      error: input.error,
+      finishedAt: this.now(),
+    });
+  }
+
+  async findStaleRunning(olderThanMs: number): Promise<StaleRun[]> {
+    const cutoff = this.now() - olderThanMs;
+    const out: StaleRun[] = [];
+    for (const run of this.runs.values()) {
+      if (run.status !== 'running' || run.startedAt >= cutoff) continue;
+      out.push({
+        id: run.id,
+        streamId: run.streamId,
+        sessionId: run.sessionId,
+        rootSessionId: run.sessionId ? this.rootOf(run.sessionId) : null,
+        parentRunId: run.parentRunId,
+        depth: run.depth,
+      });
+    }
+    return out;
+  }
+
+  async markInterrupted(id: string, error: string): Promise<boolean> {
+    const run = this.runs.get(id);
+    if (!run || run.status !== 'running') return false;
+    Object.assign(run, {
+      status: 'aborted',
+      stopReason: 'aborted',
+      error,
+      finishedAt: this.now(),
+    });
+    return true;
+  }
+
+  async getSessionId(runId: string): Promise<string | null> {
+    return this.runs.get(runId)?.sessionId ?? null;
+  }
+
+  async getDepth(runId: string): Promise<number> {
+    return this.runs.get(runId)?.depth ?? 0;
+  }
+
+  /** 读一条记录（单测 / 调试用，不在端口上）。 */
+  get(runId: string): StoredRun | undefined {
+    return this.runs.get(runId);
+  }
+}

package/src/in-process/session-store.ts

@@ -0,0 +1,118 @@
+import { randomUUID } from 'node:crypto';
+
+import type {
+  NewSubSession,
+  SessionRecord,
+  SessionStore,
+} from '../ports/session-store.js';
+import type { InMemoryConversationStore } from './conversation-store.js';
+
+/**
+ * 内存会话行。兜底扫描要看消息与「更新时间」，所以挂在同一个
+ * `InMemoryConversationStore` 上（数据库实现里那是同一个库的两张表）。
+ *
+ * 读—改—写之间没有 await，单线程里天然原子（`advanceMilestone` 的 CAS 靠这一点）。
+ */
+export class InMemorySessionStore implements SessionStore {
+  private readonly rows = new Map<string, SessionRecord>();
+
+  constructor(
+    private readonly conversations: InMemoryConversationStore,
+    private readonly now: () => number = Date.now
+  ) {}
+
+  /** 建一个根会话（宿主的事；进程内实现给单测与参考宿主用）。 */
+  createRoot(
+    input: {
+      id?: string;
+      userId?: string | null;
+      title?: string | null;
+      metadata?: Readonly<Record<string, unknown>>;
+      attrs?: Readonly<Record<string, unknown>>;
+    } = {}
+  ): SessionRecord {
+    const id = input.id ?? randomUUID();
+    const row: SessionRecord = {
+      id,
+      kind: 'root',
+      rootSessionId: id,
+      parentRunId: null,
+      subagentName: null,
+      title: input.title ?? null,
+      userId: input.userId ?? null,
+      lastMilestoneSeq: null,
+      metadata: input.metadata ?? {},
+      attrs: input.attrs ?? {},
+    };
+    this.rows.set(id, row);
+    return row;
+  }
+
+  /** 删掉一行（单测模拟「会话被删」）。 */
+  delete(id: string): void {
+    this.rows.delete(id);
+  }
+
+  createSubSession(input: NewSubSession): Promise<SessionRecord> {
+    const row: SessionRecord = {
+      id: randomUUID(),
+      kind: 'subagent',
+      rootSessionId: input.rootSessionId,
+      parentRunId: input.parentRunId,
+      subagentName: input.subagentName,
+      title: input.title,
+      userId: input.userId,
+      lastMilestoneSeq: null,
+      metadata: input.metadata ?? {},
+      attrs: input.attrs ?? {},
+    };
+    this.rows.set(row.id, row);
+    return Promise.resolve({ ...row });
+  }
+
+  getSession(id: string): Promise<SessionRecord | null> {
+    const row = this.rows.get(id);
+    return Promise.resolve(row ? { ...row } : null);
+  }
+
+  advanceMilestone(
+    id: string,
+    expected: number | null,
+    next: number
+  ): Promise<boolean> {
+    const row = this.rows.get(id);
+    if (!row || row.lastMilestoneSeq !== expected) {
+      return Promise.resolve(false);
+    }
+    row.lastMilestoneSeq = next;
+    return Promise.resolve(true);
+  }
+
+  async listSubagentSessionsForSweep(
+    idleForMs: number
+  ): Promise<SessionRecord[]> {
+    const cutoff = this.now() - idleForMs;
+    const out: SessionRecord[] = [];
+    for (const row of this.rows.values()) {
+      if (row.kind !== 'subagent') continue;
+      if (this.conversations.touchedAt(row.id) >= cutoff) continue;
+      const pending = await this.conversations.listMessages(row.id, {
+        role: 'assistant',
+        afterSeq: row.lastMilestoneSeq ?? 0,
+      });
+      if (pending.length > 0) out.push({ ...row });
+    }
+    return out;
+  }
+
+  countAliveSubsByRoot(): Promise<{ rootSessionId: string; count: number }[]> {
+    const counts = new Map<string, number>();
+    for (const row of this.rows.values()) {
+      if (row.kind !== 'subagent' || row.lastMilestoneSeq !== null) continue;
+      counts.set(row.rootSessionId, (counts.get(row.rootSessionId) ?? 0) + 1);
+    }
+    return Promise.resolve(
+      [...counts].map(([rootSessionId, count]) => ({ rootSessionId, count }))
+    );
+  }
+}

package/src/in-process/stream-bus.ts

@@ -0,0 +1,244 @@
+import { EventEmitter } from 'node:events';
+
+import type { SessionStreamEntry, StreamBus } from '../ports/stream-bus.js';
+import { type AgentEvent, createSeqCounter } from '../schema/agent-event.js';
+
+interface StreamState {
+  buffer: AgentEvent[];
+  emitter: EventEmitter;
+  controller: AbortController;
+  active: boolean;
+  closedAt?: number;
+}
+
+interface SessionState {
+  buffer: SessionStreamEntry[];
+  emitter: EventEmitter;
+  seq: number;
+  /** 最后一次有事件进来的时刻，过期清理用。 */
+  touchedAt: number;
+}
+
+export interface InProcessStreamBusOptions {
+  /** close 后 buffer 保留多久（供重连补发）。缺省 5 分钟。 */
+  bufferTtlMs?: number;
+  /** 会话面多久没有新事件就整块清掉。缺省 1 小时。 */
+  sessionTtlMs?: number;
+  /** 清理间隔。缺省 1 分钟；0 = 不起定时器（单测手动调 `sweep`）。 */
+  sweepIntervalMs?: number;
+  now?: () => number;
+}
+
+/**
+ * 进程内事件总线。搬自 agent-base `InProcessStreamBus`，改动：
+ * 去掉 Nest；会话面也按 TTL 清理（agent-base 生产走 Redis，进程内的会话面只在单测里用，
+ * 从没清过——在这里它是默认实现，不清就无界增长）；加 `dispose()` 停定时器。
+ *
+ * **只在单进程内成立。**
+ */
+export class InProcessStreamBus implements StreamBus {
+  private readonly streams = new Map<string, StreamState>();
+  private readonly sessions = new Map<string, SessionState>();
+  private readonly bufferTtlMs: number;
+  private readonly sessionTtlMs: number;
+  private readonly now: () => number;
+  private readonly timer: NodeJS.Timeout | null;
+
+  constructor(options: InProcessStreamBusOptions = {}) {
+    this.bufferTtlMs = options.bufferTtlMs ?? 5 * 60_000;
+    this.sessionTtlMs = options.sessionTtlMs ?? 60 * 60_000;
+    this.now = options.now ?? Date.now;
+    const interval = options.sweepIntervalMs ?? 60_000;
+    this.timer =
+      interval > 0 ? setInterval(() => this.sweep(), interval) : null;
+    this.timer?.unref();
+  }
+
+  open(streamId: string): { nextSeq: () => number } {
+    if (this.streams.has(streamId)) {
+      throw new Error(`stream '${streamId}' already open`);
+    }
+    const emitter = new EventEmitter();
+    emitter.setMaxListeners(0);
+    this.streams.set(streamId, {
+      buffer: [],
+      emitter,
+      controller: new AbortController(),
+      active: true,
+    });
+    return { nextSeq: createSeqCounter() };
+  }
+
+  publish(event: AgentEvent): void {
+    if (this.publishToStream(event)) this.publishToSession(event);
+  }
+
+  publishSessionEvent(event: AgentEvent): void {
+    this.publishToSession(event);
+  }
+
+  /**
+   * 只喂 per-stream 面。流已 close 或不存在时不接收（不入 buffer、不 emit）。返回是否投递了。
+   * 给子类用：Redis 适配保留进程内的 per-stream 面（pump 与取消信号都在跑这一轮的进程里），
+   * 只把会话面换成跨实例的实现。
+   */
+  protected publishToStream(event: AgentEvent): boolean {
+    const state = this.streams.get(event.streamId);
+    if (!state || !state.active) return false;
+    state.buffer.push(event);
+    state.emitter.emit('event', event);
+    return true;
+  }
+
+  private publishToSession(event: AgentEvent): void {
+    let s = this.sessions.get(event.rootSessionId);
+    if (!s) {
+      const emitter = new EventEmitter();
+      emitter.setMaxListeners(0);
+      s = { buffer: [], emitter, seq: 0, touchedAt: this.now() };
+      this.sessions.set(event.rootSessionId, s);
+    }
+    s.touchedAt = this.now();
+    const entry: SessionStreamEntry = { id: String(++s.seq), event };
+    s.buffer.push(entry);
+    s.emitter.emit('entry', entry);
+  }
+
+  subscribe(
+    streamId: string,
+    fromSeq = 1,
+    signal?: AbortSignal
+  ): AsyncIterable<AgentEvent> {
+    const state = this.streams.get(streamId);
+    if (!state) return (async function* () {})();
+    const queue: AgentEvent[] = state.buffer.filter(e => e.seq >= fromSeq);
+    let notify: (() => void) | null = null;
+    let ended = !state.active;
+    let aborted = signal?.aborted ?? false;
+
+    const onEvent = (e: AgentEvent) => {
+      queue.push(e);
+      notify?.();
+    };
+    const onClose = () => {
+      ended = true;
+      notify?.();
+    };
+    const onAbort = () => {
+      aborted = true;
+      notify?.();
+    };
+    state.emitter.on('event', onEvent);
+    state.emitter.on('close', onClose);
+    signal?.addEventListener('abort', onAbort);
+
+    return {
+      async *[Symbol.asyncIterator]() {
+        try {
+          for (;;) {
+            // abort 只阻止「等待」，不阻止排空已入队的事件。
+            while (queue.length > 0) yield queue.shift() as AgentEvent;
+            if (ended || aborted || signal?.aborted) return;
+            await new Promise<void>(resolve => {
+              notify = resolve;
+            });
+            notify = null;
+          }
+        } finally {
+          state.emitter.off('event', onEvent);
+          state.emitter.off('close', onClose);
+          signal?.removeEventListener('abort', onAbort);
+        }
+      },
+    };
+  }
+
+  async *subscribeSession(
+    rootSessionId: string,
+    fromId: string | undefined,
+    signal: AbortSignal
+  ): AsyncIterable<SessionStreamEntry> {
+    // 还没有任何事件时也要能订阅：先建出会话面，之后的事件才收得到。
+    let s = this.sessions.get(rootSessionId);
+    if (!s) {
+      const emitter = new EventEmitter();
+      emitter.setMaxListeners(0);
+      s = { buffer: [], emitter, seq: 0, touchedAt: this.now() };
+      this.sessions.set(rootSessionId, s);
+    }
+    const session = s;
+    const from = fromId ? Number(fromId) : 0;
+    const queue = session.buffer.filter(e => Number(e.id) > from);
+    let notify: (() => void) | null = null;
+    let aborted = signal.aborted;
+    const onEntry = (e: SessionStreamEntry) => {
+      queue.push(e);
+      notify?.();
+    };
+    const onAbort = () => {
+      aborted = true;
+      notify?.();
+    };
+    session.emitter.on('entry', onEntry);
+    signal.addEventListener('abort', onAbort);
+    try {
+      for (;;) {
+        while (queue.length > 0) yield queue.shift() as SessionStreamEntry;
+        if (aborted || signal.aborted) return;
+        await new Promise<void>(resolve => {
+          notify = resolve;
+        });
+        notify = null;
+      }
+    } finally {
+      session.emitter.off('entry', onEntry);
+      signal.removeEventListener('abort', onAbort);
+    }
+  }
+
+  /** 进程内没有「重放量」这回事：buffer 随 TTL 整体过期，退役是 no-op。 */
+  retireUpTo(_runId: string, _uptoSeq: number): void {}
+
+  close(streamId: string): void {
+    const state = this.streams.get(streamId);
+    if (!state || !state.active) return;
+    state.active = false;
+    state.closedAt = this.now();
+    state.emitter.emit('close');
+  }
+
+  abort(streamId: string): void {
+    this.streams.get(streamId)?.controller.abort();
+  }
+
+  isActive(streamId: string): boolean {
+    return this.streams.get(streamId)?.active ?? false;
+  }
+
+  signalOf(streamId: string): AbortSignal | undefined {
+    return this.streams.get(streamId)?.controller.signal;
+  }
+
+  /** 清掉过期的流与没人订阅的过期会话面。定时器会调它；单测可以手动调。 */
+  sweep(): void {
+    const now = this.now();
+    for (const [id, state] of this.streams) {
+      if (!state.active && now - (state.closedAt ?? 0) > this.bufferTtlMs) {
+        this.streams.delete(id);
+      }
+    }
+    for (const [id, s] of this.sessions) {
+      if (
+        now - s.touchedAt > this.sessionTtlMs &&
+        s.emitter.listenerCount('entry') === 0
+      ) {
+        this.sessions.delete(id);
+      }
+    }
+  }
+
+  /** 停掉清理定时器。 */
+  dispose(): void {
+    if (this.timer) clearInterval(this.timer);
+  }
+}

package/src/in-process/vendor-file-cache.ts

@@ -0,0 +1,67 @@
+import type {
+  VendorFileCache,
+  VendorFileKey,
+  VendorFileRecord,
+} from '../ports/vendor-file-cache.js';
+
+const keyOf = (k: VendorFileKey) =>
+  `${k.vendor}\u0000${k.account}\u0000${k.contentHash}`;
+
+/** `VendorFileCache` 的进程内实现：一张 Map。进程重启后要重传（厂商侧旧副本到期自清）。 */
+export class InMemoryVendorFileCache implements VendorFileCache {
+  private readonly rows = new Map<string, VendorFileRecord>();
+
+  find(
+    vendor: string,
+    contentHashes: readonly string[]
+  ): Promise<VendorFileRecord[]> {
+    const wanted = new Set(contentHashes);
+    const out: VendorFileRecord[] = [];
+    for (const row of this.rows.values()) {
+      if (row.vendor === vendor && wanted.has(row.contentHash)) {
+        out.push({ ...row });
+      }
+    }
+    return Promise.resolve(out);
+  }
+
+  put(record: VendorFileRecord): Promise<void> {
+    this.rows.set(keyOf(record), { ...record });
+    return Promise.resolve();
+  }
+
+  touch(key: VendorFileKey, at: Date): Promise<void> {
+    const row = this.rows.get(keyOf(key));
+    if (row) row.lastUsedAt = at;
+    return Promise.resolve();
+  }
+
+  forget(
+    vendor: string,
+    account: string,
+    fileIds: readonly string[]
+  ): Promise<void> {
+    const ids = new Set(fileIds);
+    for (const [k, row] of this.rows) {
+      if (
+        row.vendor === vendor &&
+        row.account === account &&
+        ids.has(row.fileId)
+      ) {
+        this.rows.delete(k);
+      }
+    }
+    return Promise.resolve();
+  }
+
+  sweepExpired(now: Date): Promise<number> {
+    let n = 0;
+    for (const [k, row] of this.rows) {
+      if (row.expiresAt && row.expiresAt.getTime() < now.getTime()) {
+        this.rows.delete(k);
+        n++;
+      }
+    }
+    return Promise.resolve(n);
+  }
+}