@springbrand/agent-runtime 0.1.3-alpha.7 → 0.2.0-alpha.13

package/src/adapter/cloudflare/workspace/version-control.ts

@@ -0,0 +1,374 @@
+import * as git from "isomorphic-git";
+import type { WorkspacePort } from "../../../kernel/bindings";
+import {
+  WorkspaceRevisionNotFoundError,
+  type WorkspaceRevision,
+  type WorkspaceRevisionManifest,
+  type WorkspaceVersionPort,
+} from "../../../workspace-versioning";
+import { createWorkspaceGitFs } from "./git-fs";
+
+const PAGE_SIZE = 256;
+const MAX_LIST_LIMIT = 100;
+const REVISION_PATTERN = /^[0-9a-f]{40}$/u;
+const AUTHOR = Object.freeze({
+  name: "Workspace",
+  email: "workspace@springbrand.local",
+});
+
+type VersionControlOptions = {
+  workspace: WorkspacePort;
+  dir: string;
+  gitdir: string;
+};
+
+type TreeFile = {
+  path: string;
+  oid: string;
+  bytes: Uint8Array;
+};
+
+function coordinate(value: string): string {
+  if (!value.startsWith("/") || value.includes("\\")) {
+    throw new Error("Workspace revision coordinates must be absolute POSIX paths");
+  }
+  const parts = value.split("/").filter(Boolean);
+  if (parts.some((part) => part === "." || part === "..")) {
+    throw new Error("Workspace revision coordinates cannot traverse");
+  }
+  return `/${parts.join("/")}`;
+}
+
+function relativePath(value: string): string {
+  if (!value || value.startsWith("/") || value.includes("\\")) {
+    throw new WorkspaceRevisionNotFoundError();
+  }
+  const parts = value.split("/");
+  if (parts.some((part) => !part || part === "." || part === ".." || part === ".git")) {
+    throw new WorkspaceRevisionNotFoundError();
+  }
+  return parts.join("/");
+}
+
+function pathIn(root: string, relative: string): string {
+  return `${root}/${relative}`;
+}
+
+function isMissing(error: unknown) {
+  return error instanceof Error && (
+    "code" in error && String((error as { code: unknown }).code).includes("NotFound") ||
+    error.message.includes("Could not find") ||
+    error.message.includes("ENOENT")
+  );
+}
+
+/** A linear Git history for one Host-selected Workspace subtree. */
+export class WorkspaceVersionControl implements WorkspaceVersionPort {
+  private readonly workspace: WorkspacePort;
+  private readonly dir: string;
+  private readonly gitdir: string;
+  private readonly fs: git.FsClient;
+
+  constructor(options: VersionControlOptions) {
+    this.workspace = options.workspace;
+    this.dir = coordinate(options.dir);
+    this.gitdir = coordinate(options.gitdir);
+    if (
+      this.dir === this.gitdir ||
+      this.dir.startsWith(`${this.gitdir}/`) ||
+      this.gitdir.startsWith(`${this.dir}/`)
+    ) throw new Error("Workspace revision gitdir must be separate from its worktree");
+    this.fs = createWorkspaceGitFs(this.workspace);
+  }
+
+  async current(): Promise<WorkspaceRevision | null> {
+    await this.ensure();
+    try {
+      const entries = await git.log({
+        fs: this.fs,
+        dir: this.dir,
+        gitdir: this.gitdir,
+        depth: 1,
+      });
+      return entries[0] ? this.revision(entries[0]) : null;
+    } catch (error) {
+      if (isMissing(error)) return null;
+      throw error;
+    }
+  }
+
+  async checkpoint(input: { reason: string }) {
+    await this.ensure();
+    const reason = input.reason.trim();
+    if (!reason) throw new Error("Workspace revision reason is required");
+    const currentFiles = await this.worktreeFiles();
+    const before = await this.current();
+    if (currentFiles.size === 0 && !before) {
+      return { revision: null, treeHash: null, changed: false };
+    }
+    if (
+      before &&
+      sameFiles(currentFiles, (await this.readRevision(before.revision)).files)
+    ) {
+      return {
+        revision: before.revision,
+        treeHash: before.treeHash,
+        changed: false,
+      };
+    }
+
+    await this.stageWorktree(currentFiles);
+    const revision = await git.commit({
+      fs: this.fs,
+      dir: this.dir,
+      gitdir: this.gitdir,
+      message: reason,
+      author: AUTHOR,
+      committer: AUTHOR,
+    });
+    const treeHash = (await git.readTree({
+      fs: this.fs,
+      dir: this.dir,
+      gitdir: this.gitdir,
+      oid: revision,
+    })).oid;
+    return { revision, treeHash, changed: true };
+  }
+
+  async list(input?: { limit?: number }) {
+    await this.ensure();
+    const limit = Math.min(Math.max(input?.limit ?? 20, 1), MAX_LIST_LIMIT);
+    try {
+      return Promise.all((await git.log({
+        fs: this.fs,
+        dir: this.dir,
+        gitdir: this.gitdir,
+        depth: limit,
+      })).map((entry) => this.revision(entry)));
+    } catch (error) {
+      if (isMissing(error)) return [];
+      throw error;
+    }
+  }
+
+  async manifest(revision: string): Promise<WorkspaceRevisionManifest> {
+    const { treeHash, files } = await this.readRevision(revision);
+    return {
+      revision,
+      treeHash,
+      files: files.map(({ path, bytes }) => ({ path, size: bytes.byteLength })),
+    };
+  }
+
+  async readFile(revision: string, path: string): Promise<Uint8Array> {
+    const normalized = relativePath(path);
+    const { files } = await this.readRevision(revision);
+    const file = files.find((candidate) => candidate.path === normalized);
+    if (!file) throw new WorkspaceRevisionNotFoundError();
+    return file.bytes.slice();
+  }
+
+  async restore(input: { revision: string; reason: string }) {
+    const target = await this.readRevision(input.revision);
+    const preserved = await this.checkpoint({ reason: "Before restore" });
+    if (preserved.treeHash === target.treeHash) {
+      return {
+        revision: preserved.revision!,
+        treeHash: preserved.treeHash!,
+      };
+    }
+    const before = preserved.revision
+      ? await this.readRevision(preserved.revision)
+      : { treeHash: "", files: [] };
+    try {
+      await this.replaceWorktree(target.files);
+      const restored = await this.checkpoint({ reason: input.reason });
+      return { revision: restored.revision!, treeHash: restored.treeHash! };
+    } catch (error) {
+      try {
+        await this.replaceWorktree(before.files);
+        await this.stageWorktree();
+      } catch (compensationError) {
+        throw new AggregateError(
+          [error, compensationError],
+          "workspace_revision_restore_compensation_failed",
+        );
+      }
+      throw error;
+    }
+  }
+
+  private async ensure() {
+    await this.workspace.mkdir(this.dir, { recursive: true });
+    await this.workspace.mkdir(this.gitdir, { recursive: true });
+    await git.init({
+      fs: this.fs,
+      dir: this.dir,
+      gitdir: this.gitdir,
+      defaultBranch: "main",
+    });
+  }
+
+  private async revision(entry: Awaited<ReturnType<typeof git.log>>[number]) {
+    const treeHash = (await git.readTree({
+      fs: this.fs,
+      dir: this.dir,
+      gitdir: this.gitdir,
+      oid: entry.oid,
+    })).oid;
+    return {
+      revision: entry.oid,
+      treeHash,
+      reason: entry.commit.message.trim(),
+      createdAt: entry.commit.author.timestamp * 1_000,
+    } satisfies WorkspaceRevision;
+  }
+
+  private async readRevision(revision: string): Promise<{
+    treeHash: string;
+    files: TreeFile[];
+  }> {
+    await this.ensure();
+    if (!REVISION_PATTERN.test(revision)) throw new WorkspaceRevisionNotFoundError();
+    try {
+      await git.readCommit({
+        fs: this.fs,
+        dir: this.dir,
+        gitdir: this.gitdir,
+        oid: revision,
+      });
+      const root = await git.readTree({
+        fs: this.fs,
+        dir: this.dir,
+        gitdir: this.gitdir,
+        oid: revision,
+      });
+      const files: TreeFile[] = [];
+      await this.readTreeFiles(root.oid, "", files);
+      files.sort((left, right) => left.path.localeCompare(right.path));
+      return { treeHash: root.oid, files };
+    } catch (error) {
+      if (error instanceof WorkspaceRevisionNotFoundError || isMissing(error)) {
+        throw new WorkspaceRevisionNotFoundError();
+      }
+      throw error;
+    }
+  }
+
+  private async readTreeFiles(oid: string, prefix: string, files: TreeFile[]) {
+    const { tree } = await git.readTree({
+      fs: this.fs,
+      dir: this.dir,
+      gitdir: this.gitdir,
+      oid,
+    });
+    for (const entry of tree) {
+      const path = prefix ? `${prefix}/${entry.path}` : entry.path;
+      relativePath(path);
+      if (entry.type === "tree") {
+        await this.readTreeFiles(entry.oid, path, files);
+      } else if (entry.type === "blob" && entry.mode !== "120000") {
+        files.push({
+          path,
+          oid: entry.oid,
+          bytes: (await git.readBlob({
+            fs: this.fs,
+            dir: this.dir,
+            gitdir: this.gitdir,
+            oid: entry.oid,
+          })).blob,
+        });
+      } else {
+        throw new WorkspaceRevisionNotFoundError();
+      }
+    }
+  }
+
+  private async worktreeFiles() {
+    const files = new Map<string, Uint8Array>();
+    const pending = [this.dir];
+    while (pending.length > 0) {
+      const directory = pending.pop()!;
+      for (const entry of await this.readDir(directory)) {
+        const path = entry.path.slice(this.dir.length + 1);
+        relativePath(path);
+        if (entry.type === "directory") pending.push(entry.path);
+        else if (entry.type === "file") {
+          const bytes = await this.workspace.readFileBytes(entry.path);
+          if (!bytes) throw new Error("Workspace file disappeared during checkpoint");
+          files.set(path, bytes);
+        } else {
+          throw new Error("Workspace revisions do not support symbolic links");
+        }
+      }
+    }
+    return files;
+  }
+
+  private async readDir(path: string) {
+    const entries = [];
+    let offset = 0;
+    while (true) {
+      const page = await this.workspace.readDir(path, {
+        limit: PAGE_SIZE,
+        offset,
+      });
+      if (page.length === 0) return entries;
+      entries.push(...page);
+      offset += page.length;
+    }
+  }
+
+  private async replaceWorktree(files: readonly TreeFile[]) {
+    const target = new Set(files.map(({ path }) => path));
+    const current = await this.worktreeFiles();
+    for (const path of current.keys()) {
+      if (!target.has(path)) {
+        await this.workspace.rm(pathIn(this.dir, path), { force: true });
+      }
+    }
+    for (const file of files) {
+      await this.workspace.writeFileBytes(pathIn(this.dir, file.path), file.bytes);
+    }
+  }
+
+  private async stageWorktree(files?: ReadonlyMap<string, Uint8Array>) {
+    files ??= await this.worktreeFiles();
+    const tracked = new Set(await git.listFiles({
+      fs: this.fs,
+      dir: this.dir,
+      gitdir: this.gitdir,
+    }));
+    for (const path of files.keys()) {
+      await git.add({
+        fs: this.fs,
+        dir: this.dir,
+        gitdir: this.gitdir,
+        filepath: path,
+        force: true,
+      });
+      tracked.delete(path);
+    }
+    for (const path of tracked) {
+      await git.remove({
+        fs: this.fs,
+        dir: this.dir,
+        gitdir: this.gitdir,
+        filepath: path,
+      });
+    }
+  }
+
+}
+
+function sameFiles(
+  current: ReadonlyMap<string, Uint8Array>,
+  revision: readonly TreeFile[],
+) {
+  if (current.size !== revision.length) return false;
+  return revision.every(({ path, bytes }) => {
+    const candidate = current.get(path);
+    return candidate?.byteLength === bytes.byteLength &&
+      candidate.every((byte, index) => byte === bytes[index]);
+  });
+}

package/src/db/index.ts

@@ -11,6 +11,7 @@ import { MessageUiRepository } from "./message-ui.repo";
 import { SteerRepository } from "./steer.repo";
 import { RuntimeEventOutboxRepository } from "./runtime-event-outbox.repo";
 import { AgentToolRepository } from "./agent-tool.repo";
+import { SubmissionAdmissionRepository } from "./submission-admission.repo";
 
 // 数据库术语以这里为准。
 // Submission 是一次可持久化的用户提交，从排队到终态都用同一个 submissionId 跟踪。
@@ -37,6 +38,7 @@ export * from "./message-ui.repo";
 export * from "./steer.repo";
 export * from "./runtime-event-outbox.repo";
 export * from "./agent-tool.repo";
+export * from "./submission-admission.repo";
 
 export class RuntimeDatabase {
   readonly submissions: SubmissionRepository;
@@ -49,6 +51,7 @@ export class RuntimeDatabase {
   readonly steers: SteerRepository;
   readonly runtimeEvents: RuntimeEventOutboxRepository;
   readonly agentTools: AgentToolRepository;
+  readonly submissionAdmissions: SubmissionAdmissionRepository;
 
   // 给各个 Repository 分配同一个 Agent SQLite 入口和事务入口。
   // AgentRuntimeKernel 构造时只创建一次，业务代码随后通过对应属性访问仓储。
@@ -67,6 +70,7 @@ export class RuntimeDatabase {
     this.steers = new SteerRepository(sql);
     this.runtimeEvents = new RuntimeEventOutboxRepository(sql);
     this.agentTools = new AgentToolRepository(sql);
+    this.submissionAdmissions = new SubmissionAdmissionRepository(sql);
   }
 
   /**

package/src/db/runtime-event-outbox.repo.ts

@@ -55,7 +55,7 @@ export class RuntimeEventOutboxRepository {
       SELECT event_id, body, created_at, delivered_at
       FROM pi_turn_event_outbox
       WHERE delivered_at IS NULL
-      ORDER BY created_at, event_id
+      ORDER BY created_at, rowid
     `.map(mapRow);
   }
 
@@ -70,6 +70,39 @@ export class RuntimeEventOutboxRepository {
     );
   }
 
+  hasNonZeroModelUsage(submissionId: string): boolean {
+    return Boolean(
+      this.sql<{ found: number }>`
+        SELECT 1 AS found
+        FROM pi_turn_event_outbox
+        WHERE json_extract(body, '$.type') = 'model-usage'
+          AND json_extract(body, '$.event.submissionId') = ${submissionId}
+          AND (
+            COALESCE(json_extract(body, '$.event.usage.totalTokens'), 0) > 0
+            OR COALESCE(json_extract(body, '$.event.usage.cost.total'), 0) > 0
+          )
+        LIMIT 1
+      `[0],
+    );
+  }
+
+  has(eventId: string): boolean {
+    return this.find(eventId) !== null;
+  }
+
+  hasSubagentUsage(submissionId: string, subagentRunId: string): boolean {
+    return Boolean(
+      this.sql<{ found: number }>`
+        SELECT 1 AS found
+        FROM pi_turn_event_outbox
+        WHERE json_extract(body, '$.type') = 'subagent-usage'
+          AND json_extract(body, '$.event.submissionId') = ${submissionId}
+          AND json_extract(body, '$.event.subagentRunId') = ${subagentRunId}
+        LIMIT 1
+      `[0],
+    );
+  }
+
   markDelivered(eventId: string, deliveredAt: number): void {
     this.sql`
       UPDATE pi_turn_event_outbox

package/src/db/schema.ts

@@ -31,6 +31,23 @@ export function initializeSchema(sql: SqlTaggedTemplate): void {
     sql<{ name: string }>`PRAGMA table_info(pi_submissions)`
       .map((column) => column.name),
   );
+  if (!submissionColumns.has("run_id")) {
+    sql`ALTER TABLE pi_submissions ADD COLUMN run_id TEXT`;
+  }
+  if (!submissionColumns.has("account_id")) {
+    sql`ALTER TABLE pi_submissions ADD COLUMN account_id TEXT`;
+  }
+  if (!submissionColumns.has("rate_version")) {
+    sql`ALTER TABLE pi_submissions ADD COLUMN rate_version INTEGER`;
+  }
+  if (!submissionColumns.has("slot_identity")) {
+    sql`ALTER TABLE pi_submissions ADD COLUMN slot_identity TEXT`;
+  }
+  if (!submissionColumns.has("admission_retryable")) {
+    sql`ALTER TABLE pi_submissions ADD COLUMN admission_retryable INTEGER`;
+  }
+  sql`CREATE UNIQUE INDEX IF NOT EXISTS pi_submissions_run_id
+      ON pi_submissions(run_id) WHERE run_id IS NOT NULL`;
   if (!submissionColumns.has("queued_input_json")) {
     sql`ALTER TABLE pi_submissions ADD COLUMN queued_input_json TEXT`;
   }
@@ -77,6 +94,31 @@ export function initializeSchema(sql: SqlTaggedTemplate): void {
     created_at INTEGER NOT NULL,
     delivered_at INTEGER
   )`;
+  sql`CREATE TABLE IF NOT EXISTS pi_submission_admissions (
+    request_id TEXT PRIMARY KEY,
+    idempotency_key TEXT UNIQUE,
+    run_id TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('pending', 'accepted', 'rejected')),
+    account_id TEXT,
+    rate_version INTEGER,
+    slot_identity TEXT,
+    code TEXT,
+    retryable INTEGER,
+    attempted_at INTEGER NOT NULL DEFAULT 0
+  )`;
+  const admissionColumns = new Set(
+    sql<{ name: string }>`PRAGMA table_info(pi_submission_admissions)`
+      .map((column) => column.name),
+  );
+  if (!admissionColumns.has("retryable")) {
+    sql`ALTER TABLE pi_submission_admissions ADD COLUMN retryable INTEGER`;
+  }
+  // 早于本列的 pending 行没有可信的尝试时间，默认 0 让它们不再占用在途名额，
+  // 但仍作为身份记录保留同一个 runId。
+  if (!admissionColumns.has("attempted_at")) {
+    sql`ALTER TABLE pi_submission_admissions
+        ADD COLUMN attempted_at INTEGER NOT NULL DEFAULT 0`;
+  }
   sql`CREATE TABLE IF NOT EXISTS pi_approvals (
     execution_id TEXT PRIMARY KEY,
     submission_id TEXT NOT NULL,

package/src/db/submission-admission.repo.ts

@@ -0,0 +1,127 @@
+import type { SqlTaggedTemplate } from "agents/chat";
+
+export type StoredSubmissionAdmission = {
+  requestId: string;
+  idempotencyKey: string | null;
+  runId: string;
+  status: "pending" | "accepted" | "rejected";
+  accountId: string | null;
+  rateVersion: number | null;
+  slotIdentity: string | null;
+  code: string | null;
+  retryable: boolean | null;
+  attemptedAt: number;
+};
+
+type Row = {
+  request_id: string;
+  idempotency_key: string | null;
+  run_id: string;
+  status: StoredSubmissionAdmission["status"];
+  account_id: string | null;
+  rate_version: number | null;
+  slot_identity: string | null;
+  code: string | null;
+  retryable: number | null;
+  attempted_at: number;
+};
+
+const mapRow = (row: Row): StoredSubmissionAdmission => ({
+  requestId: row.request_id,
+  idempotencyKey: row.idempotency_key,
+  runId: row.run_id,
+  status: row.status,
+  accountId: row.account_id,
+  rateVersion: row.rate_version,
+  slotIdentity: row.slot_identity,
+  code: row.code,
+  retryable: row.retryable === null ? null : row.retryable === 1,
+  attemptedAt: row.attempted_at,
+});
+
+export class SubmissionAdmissionRepository {
+  constructor(private readonly sql: SqlTaggedTemplate) {}
+
+  find(requestId: string, idempotencyKey?: string): StoredSubmissionAdmission | null {
+    const byRequest = this.sql<Row>`SELECT request_id, idempotency_key, run_id, status,
+      account_id, rate_version, slot_identity, code, retryable, attempted_at
+      FROM pi_submission_admissions WHERE request_id = ${requestId}`[0];
+    if (!idempotencyKey) return byRequest ? mapRow(byRequest) : null;
+    const byKey = this.sql<Row>`SELECT request_id, idempotency_key, run_id, status,
+      account_id, rate_version, slot_identity, code, retryable, attempted_at
+      FROM pi_submission_admissions WHERE idempotency_key = ${idempotencyKey}`[0];
+    if (byRequest && byKey && byRequest.run_id !== byKey.run_id) {
+      throw new Error("Conflicting Submission admission identity");
+    }
+    const row = byKey ?? byRequest;
+    return row ? mapRow(row) : null;
+  }
+
+  begin(
+    requestId: string,
+    idempotencyKey: string | null,
+    runId: string,
+    attemptedAt: number,
+  ): StoredSubmissionAdmission {
+    const existing = this.find(requestId, idempotencyKey ?? undefined);
+    if (existing) return existing;
+    this.sql`INSERT INTO pi_submission_admissions
+      (request_id, idempotency_key, run_id, status, account_id,
+       rate_version, slot_identity, code, retryable, attempted_at)
+      VALUES (${requestId}, ${idempotencyKey}, ${runId}, 'pending', NULL, NULL,
+              NULL, NULL, NULL, ${attemptedAt})`;
+    return this.find(requestId, idempotencyKey ?? undefined)!;
+  }
+
+  /**
+   * 记录一次针对已有 pending 行的新尝试。
+   *
+   * 只有仍在 pending 的行需要它：`attempted_at` 是在途名额的凭据，重投必须把
+   * 名额重新占住，否则并发重投可以突破 pending 上限。
+   */
+  recordAttempt(requestId: string, attemptedAt: number): void {
+    this.sql`UPDATE pi_submission_admissions
+      SET attempted_at = ${attemptedAt}
+      WHERE request_id = ${requestId} AND status = 'pending'`;
+  }
+
+  saveAccepted(
+    requestId: string,
+    runId: string,
+    accountId: string,
+    rateVersion: number,
+    slotIdentity: string,
+  ): void {
+    this.sql`UPDATE pi_submission_admissions
+      SET run_id = ${runId}, status = 'accepted', account_id = ${accountId},
+          rate_version = ${rateVersion}, slot_identity = ${slotIdentity}, code = NULL,
+          retryable = NULL
+      WHERE request_id = ${requestId} AND run_id = ${runId} AND status = 'pending'`;
+  }
+
+  saveRejected(
+    requestId: string,
+    runId: string,
+    code: string,
+    retryable: boolean,
+  ): void {
+    this.sql`UPDATE pi_submission_admissions
+      SET run_id = ${runId}, status = 'rejected', code = ${code},
+          retryable = ${retryable ? 1 : 0}
+      WHERE request_id = ${requestId} AND run_id = ${runId} AND status = 'pending'`;
+  }
+
+  /**
+   * 统计仍在等待 Host 结论、且最后一次尝试发生在 `attemptedSince` 之后的准入。
+   *
+   * 这些行代表在途的名额预留。停在 pending 的行不会被删除 —— 它固定了同一
+   * identity 重投时必须复用的 runId —— 但一次失败或崩溃留下的行不能永久占用
+   * 容量，所以计数按最后一次尝试时间截断，过期的行只作为身份记录留存。
+   */
+  countPending(attemptedSince = 0): number {
+    return this.sql<{ count: number }>`
+      SELECT COUNT(*) AS count FROM pi_submission_admissions
+      WHERE status = 'pending' AND attempted_at >= ${attemptedSince}
+    `[0]?.count ?? 0;
+  }
+}