@qjp88995/agent-runtime 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,304 @@
+import { randomUUID } from 'node:crypto';
+
+import type { ContextInputs, ContextRow } from '../ports/context-store.js';
+import type {
+  ConversationMessage,
+  ConversationStore,
+  InboxItem,
+  ListMessagesFilter,
+  NewConversationMessage,
+} from '../ports/conversation-store.js';
+import {
+  COMPACTION_CHECKPOINT_KIND,
+  type MessagePart,
+} from '../schema/index.js';
+
+interface SessionState {
+  messages: ConversationMessage[];
+  nextSeq: number;
+  prunedUptoSeq: number | null;
+  compactedUptoSeq: number | null;
+  /** 最近一次「有了新动静」的时刻（`updatedAt` 的对应物）。 */
+  touchedAt: number;
+}
+
+/**
+ * 内存会话存储：消息、inbox、裁剪 / 压缩指针。进程重启即丢；只保证单进程正确。
+ *
+ * 所有方法的「读—改—写」之间没有 await，单线程里天然原子——`takeInbox` 的
+ * 「取出即落库」、`appendCheckpoint` 的「行与指针一起」都靠这一点。
+ */
+export class InMemoryConversationStore implements ConversationStore {
+  private readonly sessions = new Map<string, SessionState>();
+  private readonly byId = new Map<string, ConversationMessage>();
+  private inbox: InboxItem[] = [];
+  private inboxSeq = 0;
+
+  constructor(private readonly now: () => number = Date.now) {}
+
+  private state(sessionId: string): SessionState {
+    let s = this.sessions.get(sessionId);
+    if (!s) {
+      s = {
+        messages: [],
+        nextSeq: 1,
+        prunedUptoSeq: null,
+        compactedUptoSeq: null,
+        touchedAt: 0,
+      };
+      this.sessions.set(sessionId, s);
+    }
+    return s;
+  }
+
+  private insert(
+    m: NewConversationMessage,
+    touch: boolean
+  ): ConversationMessage {
+    if (m.id) {
+      const existing = this.byId.get(m.id);
+      if (existing) return existing;
+    }
+    const s = this.state(m.sessionId);
+    const row: ConversationMessage = {
+      id: m.id ?? randomUUID(),
+      sessionId: m.sessionId,
+      seq: s.nextSeq++,
+      role: m.role,
+      parts: m.parts,
+      metadata: m.metadata ?? null,
+      ...(m.tokenUsage ? { tokenUsage: m.tokenUsage } : {}),
+    };
+    s.messages.push(row);
+    this.byId.set(row.id, row);
+    if (touch) s.touchedAt = this.now();
+    return row;
+  }
+
+  // ─── 读（单测与参考宿主用） ─────────────────────────────────────────────
+
+  /** 两个指针的当前值。 */
+  pointers(sessionId: string): {
+    prunedUptoSeq: number | null;
+    compactedUptoSeq: number | null;
+  } {
+    const s = this.sessions.get(sessionId);
+    return {
+      prunedUptoSeq: s?.prunedUptoSeq ?? null,
+      compactedUptoSeq: s?.compactedUptoSeq ?? null,
+    };
+  }
+
+  /** 会话最近一次有新动静的时刻（从未有过为 0）。 */
+  touchedAt(sessionId: string): number {
+    return this.sessions.get(sessionId)?.touchedAt ?? 0;
+  }
+
+  listMessages(
+    sessionId: string,
+    filter: ListMessagesFilter = {}
+  ): Promise<ConversationMessage[]> {
+    const { role, afterSeq } = filter;
+    return Promise.resolve(
+      (this.sessions.get(sessionId)?.messages ?? []).filter(
+        m =>
+          (role === undefined || m.role === role) &&
+          (afterSeq == null || m.seq > afterSeq)
+      )
+    );
+  }
+
+  reserveSeq(sessionId: string): Promise<number> {
+    return Promise.resolve(this.state(sessionId).nextSeq++);
+  }
+
+  listTurnSegmentIds(runId: string): Promise<string[]> {
+    return Promise.resolve(this.segmentsOf(runId).map(m => m.id));
+  }
+
+  private segmentsOf(runId: string): ConversationMessage[] {
+    const out: ConversationMessage[] = [];
+    for (const s of this.sessions.values()) {
+      for (const m of s.messages) {
+        if (m.role === 'assistant' && m.metadata?.runId === runId) out.push(m);
+      }
+    }
+    return out;
+  }
+
+  // ─── ContextStore ──────────────────────────────────────────────────────
+
+  loadContextInputs(sessionId: string): Promise<ContextInputs> {
+    const s = this.state(sessionId);
+    let baseline: number | null = null;
+    for (let i = s.messages.length - 1; i >= 0; i--) {
+      const m = s.messages[i];
+      const tokens = m.metadata?.contextTokens;
+      if (m.role === 'assistant' && typeof tokens === 'number') {
+        baseline = tokens;
+        break;
+      }
+    }
+    return Promise.resolve({
+      // 数组复制：调用方持有的是轮初快照，之后的追加不该漂进去。
+      rows: s.messages.map(toContextRow),
+      prunedUptoSeq: s.prunedUptoSeq,
+      compactedUptoSeq: s.compactedUptoSeq,
+      baselineContextTokens: baseline,
+    });
+  }
+
+  advancePrunedUpto(sessionId: string, seq: number): Promise<void> {
+    const s = this.state(sessionId);
+    s.prunedUptoSeq = Math.max(s.prunedUptoSeq ?? 0, seq);
+    return Promise.resolve();
+  }
+
+  appendCheckpoint(input: {
+    sessionId: string;
+    seq: number;
+    summary: string;
+  }): Promise<ContextRow & { id: string }> {
+    // 不记新动静：后台腾空间不是会话有了新内容。
+    const row = this.insert(
+      {
+        sessionId: input.sessionId,
+        role: 'user',
+        parts: [{ type: 'text', text: input.summary }],
+        metadata: { kind: COMPACTION_CHECKPOINT_KIND },
+      },
+      false
+    );
+    const s = this.state(input.sessionId);
+    s.compactedUptoSeq = Math.max(s.compactedUptoSeq ?? 0, input.seq);
+    return Promise.resolve({ ...toContextRow(row), id: row.id });
+  }
+
+  // ─── inbox ─────────────────────────────────────────────────────────────
+
+  enqueue(item: Omit<InboxItem, 'id' | 'seq'>): Promise<void> {
+    this.inbox.push({ ...item, id: randomUUID(), seq: ++this.inboxSeq });
+    return Promise.resolve();
+  }
+
+  takeInbox(
+    sessionId: string,
+    toMessage: (item: InboxItem) => NewConversationMessage
+  ): Promise<Array<{ item: InboxItem; message: ConversationMessage }>> {
+    const mine = this.inbox
+      .filter(i => i.sessionId === sessionId)
+      .sort((a, b) => a.seq - b.seq);
+    if (mine.length === 0) return Promise.resolve([]);
+    // 先全部换算（`toMessage` 抛错 = 整批不取，同事务回滚），再一起删、一起落。
+    let converted: Array<{ item: InboxItem; next: NewConversationMessage }>;
+    try {
+      converted = mine.map(item => ({ item, next: toMessage(item) }));
+    } catch (err) {
+      return Promise.reject(
+        err instanceof Error ? err : new Error(String(err))
+      );
+    }
+    this.inbox = this.inbox.filter(i => i.sessionId !== sessionId);
+    return Promise.resolve(
+      converted.map(({ item, next }) => ({
+        item,
+        message: this.insert(next, true),
+      }))
+    );
+  }
+
+  hasPending(sessionId: string): Promise<boolean> {
+    return Promise.resolve(this.inbox.some(i => i.sessionId === sessionId));
+  }
+
+  listPending(sessionId: string): Promise<InboxItem[]> {
+    return Promise.resolve(
+      this.inbox
+        .filter(i => i.sessionId === sessionId)
+        .sort((a, b) => a.seq - b.seq)
+    );
+  }
+
+  listSessionIdsWithPending(): Promise<string[]> {
+    return Promise.resolve([...new Set(this.inbox.map(i => i.sessionId))]);
+  }
+
+  withdraw(id: string, userId: string): Promise<InboxItem | null> {
+    const found = this.inbox.find(
+      i => i.id === id && i.sourceUserId === userId
+    );
+    if (!found) return Promise.resolve(null);
+    this.inbox = this.inbox.filter(i => i !== found);
+    return Promise.resolve(found);
+  }
+
+  // ─── 消息写入 ──────────────────────────────────────────────────────────
+
+  appendMessage(message: NewConversationMessage): Promise<ConversationMessage> {
+    return Promise.resolve(this.insert(message, true));
+  }
+
+  appendAssistantStep(input: {
+    messageId: string;
+    runId: string;
+    sessionId: string;
+    parts: MessagePart[];
+    metadataPatch?: Record<string, unknown>;
+  }): Promise<void> {
+    const existing = this.byId.get(input.messageId);
+    if (existing) {
+      existing.parts = [...existing.parts, ...input.parts];
+      existing.metadata = {
+        ...(existing.metadata ?? {}),
+        ...input.metadataPatch,
+      };
+      this.state(input.sessionId).touchedAt = this.now();
+    } else {
+      this.insert(
+        {
+          id: input.messageId,
+          sessionId: input.sessionId,
+          role: 'assistant',
+          parts: input.parts,
+          metadata: { runId: input.runId, ...input.metadataPatch },
+        },
+        true
+      );
+    }
+    return Promise.resolve();
+  }
+
+  finalizeAssistantTurn(input: {
+    messageId: string;
+    runId: string;
+    metadata: Record<string, unknown>;
+    usage?: Record<string, number>;
+  }): Promise<void> {
+    const row = this.byId.get(input.messageId);
+    if (row) {
+      row.metadata = { runId: input.runId, ...input.metadata };
+      if (input.usage) row.tokenUsage = input.usage;
+    }
+    return Promise.resolve();
+  }
+
+  finalizeInterruptedTurn(runId: string): Promise<string[]> {
+    const touched: string[] = [];
+    for (const m of this.segmentsOf(runId)) {
+      if (m.metadata?.status != null) continue;
+      m.metadata = { ...m.metadata, status: 'aborted', stopReason: 'aborted' };
+      touched.push(m.id);
+    }
+    return Promise.resolve(touched);
+  }
+}
+
+function toContextRow(m: ConversationMessage): ContextRow {
+  const kind = m.metadata?.kind;
+  return {
+    seq: m.seq,
+    role: m.role,
+    parts: m.parts,
+    kind: typeof kind === 'string' ? kind : null,
+  };
+}

package/src/in-process/coordination.ts

@@ -0,0 +1,177 @@
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+
+import {
+  AWAIT_LEASE_TTL_MS,
+  LOCK_TTL_MS,
+  type SessionLock,
+  type SubagentAwaitLease,
+  type TreeBudget,
+  type WakeChannel,
+} from '../ports/coordination.js';
+
+/** 带过期时刻的一格。过期判定只在读时做，不起定时器。 */
+interface Expiring<T> {
+  value: T;
+  expiresAt: number;
+}
+
+export interface ClockOptions {
+  now?: () => number;
+}
+
+/** 进程内会话锁。**只在单进程内互斥。** */
+export class InProcessSessionLock implements SessionLock {
+  private readonly locks = new Map<string, Expiring<string>>();
+  private readonly now: () => number;
+  private readonly ttlMs: number;
+
+  constructor(options: ClockOptions & { ttlMs?: number } = {}) {
+    this.now = options.now ?? Date.now;
+    this.ttlMs = options.ttlMs ?? LOCK_TTL_MS;
+  }
+
+  private live(sessionId: string): Expiring<string> | undefined {
+    const cell = this.locks.get(sessionId);
+    if (cell && cell.expiresAt <= this.now()) {
+      this.locks.delete(sessionId);
+      return undefined;
+    }
+    return cell;
+  }
+
+  async acquire(sessionId: string): Promise<string | null> {
+    if (this.live(sessionId)) return null;
+    const token = randomUUID();
+    this.locks.set(sessionId, {
+      value: token,
+      expiresAt: this.now() + this.ttlMs,
+    });
+    return token;
+  }
+
+  async renew(sessionId: string, token: string): Promise<boolean> {
+    const cell = this.live(sessionId);
+    if (!cell || cell.value !== token) return false;
+    cell.expiresAt = this.now() + this.ttlMs;
+    return true;
+  }
+
+  async release(sessionId: string, token: string): Promise<void> {
+    if (this.live(sessionId)?.value === token) this.locks.delete(sessionId);
+  }
+
+  async isHeld(sessionId: string): Promise<boolean> {
+    return this.live(sessionId) !== undefined;
+  }
+}
+
+/**
+ * 进程内唤醒 / 空闲广播。投递放到下一个宏任务（与 pub/sub 一样异步），
+ * 免得投递方在 `wake()` 里同步重入 loop。
+ */
+export class InProcessWakeChannel implements WakeChannel {
+  private readonly emitter = new EventEmitter();
+
+  constructor() {
+    this.emitter.setMaxListeners(0);
+  }
+
+  private emit(channel: string, sessionId: string): Promise<void> {
+    setImmediate(() => this.emitter.emit(channel, sessionId));
+    return Promise.resolve();
+  }
+
+  private on(
+    channel: string,
+    handler: (sessionId: string) => void
+  ): () => void {
+    this.emitter.on(channel, handler);
+    return () => this.emitter.off(channel, handler);
+  }
+
+  wake(sessionId: string): Promise<void> {
+    return this.emit('wake', sessionId);
+  }
+
+  onWake(handler: (sessionId: string) => void): () => void {
+    return this.on('wake', handler);
+  }
+
+  idle(sessionId: string): Promise<void> {
+    return this.emit('idle', sessionId);
+  }
+
+  onIdle(handler: (sessionId: string) => void): () => void {
+    return this.on('idle', handler);
+  }
+}
+
+/** 进程内子 Agent 等待租约。 */
+export class InProcessSubagentAwaitLease implements SubagentAwaitLease {
+  private readonly leases = new Map<string, number>();
+  private readonly now: () => number;
+  private readonly ttlMs: number;
+
+  constructor(options: ClockOptions & { ttlMs?: number } = {}) {
+    this.now = options.now ?? Date.now;
+    this.ttlMs = options.ttlMs ?? AWAIT_LEASE_TTL_MS;
+  }
+
+  private live(childSessionId: string): boolean {
+    const expiresAt = this.leases.get(childSessionId);
+    if (expiresAt === undefined) return false;
+    if (expiresAt <= this.now()) {
+      this.leases.delete(childSessionId);
+      return false;
+    }
+    return true;
+  }
+
+  async begin(childSessionId: string): Promise<boolean> {
+    this.leases.set(childSessionId, this.now() + this.ttlMs);
+    return true;
+  }
+
+  async renew(childSessionId: string): Promise<void> {
+    if (this.live(childSessionId)) {
+      this.leases.set(childSessionId, this.now() + this.ttlMs);
+    }
+  }
+
+  async isAwaited(childSessionId: string): Promise<boolean> {
+    return this.live(childSessionId);
+  }
+
+  async claim(
+    childSessionId: string,
+    _by: 'parent' | 'finalizer'
+  ): Promise<boolean> {
+    const had = this.live(childSessionId);
+    this.leases.delete(childSessionId);
+    return had;
+  }
+}
+
+/** 进程内树级名额。单线程下「读比较写」天然原子。 */
+export class InProcessTreeBudget implements TreeBudget {
+  private readonly counts = new Map<string, number>();
+
+  async tryIncr(rootSessionId: string, limit: number): Promise<boolean> {
+    const v = this.counts.get(rootSessionId) ?? 0;
+    if (v >= limit) return false;
+    this.counts.set(rootSessionId, v + 1);
+    return true;
+  }
+
+  async decr(rootSessionId: string): Promise<void> {
+    const v = (this.counts.get(rootSessionId) ?? 0) - 1;
+    if (v <= 0) this.counts.delete(rootSessionId);
+    else this.counts.set(rootSessionId, v);
+  }
+
+  async set(rootSessionId: string, n: number): Promise<void> {
+    if (n <= 0) this.counts.delete(rootSessionId);
+    else this.counts.set(rootSessionId, n);
+  }
+}

package/src/in-process/image-source.ts

@@ -0,0 +1,29 @@
+import type { ImageBytes, ImageSource } from '../ports/image-source.js';
+
+/**
+ * `ImageSource` 的进程内实现：宿主（或单测）把字节 `put` 进来，按 `src` 取。
+ * 真实宿主一般接自己的存储；这个给零配置单进程与测试用。
+ */
+export class InMemoryImageSource implements ImageSource {
+  private readonly images = new Map<string, ImageBytes>();
+
+  constructor(private readonly publicUrlOf?: (src: string) => string | null) {}
+
+  put(src: string, data: Uint8Array, contentType: string): void {
+    this.images.set(src, { data, contentType });
+  }
+
+  delete(src: string): void {
+    this.images.delete(src);
+  }
+
+  read(src: string): Promise<ImageBytes> {
+    const hit = this.images.get(src);
+    if (!hit) return Promise.reject(new Error(`image ${src} not found`));
+    return Promise.resolve(hit);
+  }
+
+  publicUrl(src: string): string | null {
+    return this.publicUrlOf?.(src) ?? null;
+  }
+}

package/src/in-process/index.ts

@@ -0,0 +1,52 @@
+import { consoleLogger, type LoggerFactory } from '../ports/logger.js';
+import { InMemoryConversationStore } from './conversation-store.js';
+import {
+  InProcessSessionLock,
+  InProcessSubagentAwaitLease,
+  InProcessTreeBudget,
+  InProcessWakeChannel,
+} from './coordination.js';
+import { InMemoryQuestionStore } from './question-store.js';
+import { InMemoryRunStore } from './run-store.js';
+import { InMemorySessionStore } from './session-store.js';
+import { InProcessStreamBus } from './stream-bus.js';
+import { InMemoryVendorFileCache } from './vendor-file-cache.js';
+
+export { InMemoryConversationStore } from './conversation-store.js';
+export {
+  type ClockOptions,
+  InProcessSessionLock,
+  InProcessSubagentAwaitLease,
+  InProcessTreeBudget,
+  InProcessWakeChannel,
+} from './coordination.js';
+export { InMemoryImageSource } from './image-source.js';
+export { InMemoryQuestionStore } from './question-store.js';
+export { InMemoryRunStore, type StoredRun } from './run-store.js';
+export { InMemorySessionStore } from './session-store.js';
+export {
+  InProcessStreamBus,
+  type InProcessStreamBusOptions,
+} from './stream-bus.js';
+export { InMemoryVendorFileCache } from './vendor-file-cache.js';
+
+/**
+ * 一组进程内端口实现：零配置、单进程。宿主可以整组拿去用，也可以只替换其中几个
+ * （例如上了 Redis 就换掉总线与协调件，跑次记录换成自己的库）。
+ */
+export function createInProcessPorts(options: { logger?: LoggerFactory } = {}) {
+  const conversations = new InMemoryConversationStore();
+  return {
+    bus: new InProcessStreamBus(),
+    lock: new InProcessSessionLock(),
+    wake: new InProcessWakeChannel(),
+    awaitLease: new InProcessSubagentAwaitLease(),
+    treeBudget: new InProcessTreeBudget(),
+    runs: new InMemoryRunStore(),
+    conversations,
+    sessions: new InMemorySessionStore(conversations),
+    questions: new InMemoryQuestionStore(),
+    vendorFiles: new InMemoryVendorFileCache(),
+    logger: options.logger ?? consoleLogger,
+  };
+}