feat: add v0.1 runtime skeleton

2026-05-29 10:52:41 +08:00
parent 4b33e67484
commit 5deb9fa7fd
20 changed files with 1238 additions and 0 deletions
@@ -0,0 +1,138 @@
+import type { BackendProfile, BackendTurnResult, CommandRecord, CreateCommandInput, CreateRunInput, FailureKind, JsonRecord, RunEvent, RunnerRecord, RunRecord, TerminalStatus } from "../common/types.js";
+import { AgentRunError } from "../common/errors.js";
+import { newId, nowIso, stableHash } from "../common/validation.js";
+import { redactJson } from "../common/redaction.js";
+
+export interface AgentRunStore {
+  createRun(input: CreateRunInput): RunRecord;
+  getRun(runId: string): RunRecord;
+  listEvents(runId: string, afterSeq: number, limit: number): RunEvent[];
+  createCommand(runId: string, input: CreateCommandInput): CommandRecord;
+  getCommand(commandId: string): CommandRecord;
+  listCommands(runId: string, afterSeq: number, limit: number): CommandRecord[];
+  registerRunner(input: Partial<RunnerRecord>): RunnerRecord;
+  claimRun(runId: string, runnerId: string, leaseMs: number): RunRecord;
+  heartbeat(runId: string, runnerId: string, leaseMs: number): RunRecord;
+  ackCommand(commandId: string): CommandRecord;
+  appendEvent(runId: string, type: RunEvent["type"], payload: JsonRecord): RunEvent;
+  finishRun(runId: string, result: Pick<BackendTurnResult, "terminalStatus" | "failureKind" | "failureMessage">): RunRecord;
+  backends(): JsonRecord[];
+}
+
+export class MemoryAgentRunStore implements AgentRunStore {
+  private readonly runs = new Map<string, RunRecord>();
+  private readonly commands = new Map<string, CommandRecord>();
+  private readonly eventsByRun = new Map<string, RunEvent[]>();
+  private readonly runners = new Map<string, RunnerRecord>();
+
+  createRun(input: CreateRunInput): RunRecord {
+    const at = nowIso();
+    const run: RunRecord = { ...input, id: newId("run"), status: "pending", terminalStatus: null, failureKind: null, failureMessage: null, createdAt: at, updatedAt: at, claimedBy: null, leaseExpiresAt: null };
+    this.runs.set(run.id, run);
+    this.eventsByRun.set(run.id, []);
+    this.appendEvent(run.id, "backend_status", { phase: "run-created", backendProfile: run.backendProfile });
+    return run;
+  }
+
+  getRun(runId: string): RunRecord {
+    const run = this.runs.get(runId);
+    if (!run) throw new AgentRunError("schema-invalid", `run ${runId} was not found`, { httpStatus: 404 });
+    return run;
+  }
+
+  listEvents(runId: string, afterSeq: number, limit: number): RunEvent[] {
+    this.getRun(runId);
+    return (this.eventsByRun.get(runId) ?? []).filter((event) => event.seq > afterSeq).slice(0, Math.max(1, Math.min(limit, 500)));
+  }
+
+  createCommand(runId: string, input: CreateCommandInput): CommandRecord {
+    this.getRun(runId);
+    const payloadHash = stableHash(input.payload);
+    if (input.idempotencyKey) {
+      const existing = Array.from(this.commands.values()).find((command) => command.runId === runId && command.idempotencyKey === input.idempotencyKey);
+      if (existing) {
+        if (existing.payloadHash !== payloadHash) throw new AgentRunError("schema-invalid", "idempotency key reused with different payload", { httpStatus: 409 });
+        return existing;
+      }
+    }
+    const at = nowIso();
+    const seq = Array.from(this.commands.values()).filter((command) => command.runId === runId).length + 1;
+    const command: CommandRecord = { ...input, id: newId("cmd"), runId, seq, state: "pending", payloadHash, createdAt: at, updatedAt: at, acknowledgedAt: null };
+    this.commands.set(command.id, command);
+    this.appendEvent(runId, "backend_status", { phase: "command-created", commandId: command.id, commandType: command.type });
+    return command;
+  }
+
+  getCommand(commandId: string): CommandRecord {
+    const command = this.commands.get(commandId);
+    if (!command) throw new AgentRunError("schema-invalid", `command ${commandId} was not found`, { httpStatus: 404 });
+    return command;
+  }
+
+  listCommands(runId: string, afterSeq: number, limit: number): CommandRecord[] {
+    this.getRun(runId);
+    return Array.from(this.commands.values()).filter((command) => command.runId === runId && command.seq > afterSeq).slice(0, Math.max(1, Math.min(limit, 100)));
+  }
+
+  registerRunner(input: Partial<RunnerRecord>): RunnerRecord {
+    const at = nowIso();
+    const runner: RunnerRecord = { id: input.id ?? newId("runner"), registeredAt: at, heartbeatAt: at, ...input };
+    this.runners.set(runner.id, runner);
+    return runner;
+  }
+
+  claimRun(runId: string, runnerId: string, leaseMs: number): RunRecord {
+    const run = this.getRun(runId);
+    if (run.claimedBy && run.claimedBy !== runnerId && run.status !== "completed" && run.status !== "failed" && run.status !== "cancelled") throw new AgentRunError("runner-lease-conflict", `run ${runId} is already claimed`, { httpStatus: 409 });
+    const next = this.updateRun(runId, { status: "claimed", claimedBy: runnerId, leaseExpiresAt: new Date(Date.now() + leaseMs).toISOString() });
+    this.appendEvent(runId, "backend_status", { phase: "run-claimed", runnerId });
+    return next;
+  }
+
+  heartbeat(runId: string, runnerId: string, leaseMs: number): RunRecord {
+    const run = this.getRun(runId);
+    if (run.claimedBy !== runnerId) throw new AgentRunError("runner-lease-conflict", `run ${runId} is not claimed by ${runnerId}`, { httpStatus: 409 });
+    return this.updateRun(runId, { leaseExpiresAt: new Date(Date.now() + leaseMs).toISOString() });
+  }
+
+  ackCommand(commandId: string): CommandRecord {
+    const command = this.getCommand(commandId);
+    const next = { ...command, state: "acknowledged" as const, acknowledgedAt: nowIso(), updatedAt: nowIso() };
+    this.commands.set(commandId, next);
+    return next;
+  }
+
+  appendEvent(runId: string, type: RunEvent["type"], payload: JsonRecord): RunEvent {
+    this.getRun(runId);
+    const events = this.eventsByRun.get(runId) ?? [];
+    const event: RunEvent = { id: newId("evt"), runId, seq: events.length + 1, type, payload: redactJson(payload), createdAt: nowIso() };
+    events.push(event);
+    this.eventsByRun.set(runId, events);
+    return event;
+  }
+
+  finishRun(runId: string, result: Pick<BackendTurnResult, "terminalStatus" | "failureKind" | "failureMessage">): RunRecord {
+    const status = statusFromTerminal(result.terminalStatus);
+    const next = this.updateRun(runId, { status, terminalStatus: result.terminalStatus, failureKind: result.failureKind, failureMessage: result.failureMessage });
+    this.appendEvent(runId, "terminal_status", { terminalStatus: result.terminalStatus, failureKind: result.failureKind, message: result.failureMessage });
+    return next;
+  }
+
+  backends(): JsonRecord[] {
+    return [{ profile: "codex" satisfies BackendProfile, protocol: "codex-app-server-jsonrpc-stdio", transport: "stdio", command: "codex app-server --listen stdio://", status: "registered" }];
+  }
+
+  private updateRun(runId: string, patch: Partial<RunRecord>): RunRecord {
+    const run = this.getRun(runId);
+    const next = { ...run, ...patch, updatedAt: nowIso() };
+    this.runs.set(runId, next);
+    return next;
+  }
+}
+
+function statusFromTerminal(terminalStatus: TerminalStatus): RunRecord["status"] {
+  if (terminalStatus === "completed") return "completed";
+  if (terminalStatus === "cancelled") return "cancelled";
+  if (terminalStatus === "blocked") return "blocked";
+  return "failed";
+}