@app-vitals/agent-admin 0.2.1 → 0.3.0

package/src/cron-run-transcripts.smoke.test.ts

@@ -0,0 +1,286 @@
+/**
+ * admin/src/cron-run-transcripts.smoke.test.ts
+ *
+ * PUT/GET /agents/{id}/crons/{cronId}/runs/{runId}/transcript (COS-43.1) over
+ * the real admin route table and auth middleware with an in-memory store.
+ * Uses app.request() — no real server, no real DB.
+ */
+
+import { describe, expect, it, spyOn } from "bun:test";
+import {
+  type AdminDeps,
+  createAdminApp,
+  parseAdminApiKeys,
+} from "./agents-api.ts";
+import {
+  MAX_TRANSCRIPT_BODY_BYTES,
+  type TranscriptReadRow,
+  type TranscriptRow,
+  type TranscriptStore,
+} from "./cron-run-transcripts.ts";
+import { NotFoundError } from "./errors.ts";
+import { parseTranscriptConfig } from "./transcript-config.ts";
+
+const AGENT = "agent-1";
+const CRON = "cron-1";
+const RUN = "run-1";
+const ADMIN = "admin-key";
+const READ = "platform-read-token";
+const OPS = "platform-ops-token";
+const AGENT_KEY = "agent-1-key";
+const OTHER_KEY = "agent-2-key";
+const SECRET_BODY = "TRANSCRIPT-BODY-MUST-NOT-BE-LOGGED";
+
+function memoryStore() {
+  const rows = new Map<string, TranscriptRow>();
+  const reads: TranscriptReadRow[] = [];
+  const order: string[] = [];
+  const store: TranscriptStore = {
+    async upsert(input) {
+      if (
+        input.agentId !== AGENT ||
+        input.cronId !== CRON ||
+        input.runId !== RUN
+      ) {
+        throw new NotFoundError(`cron run ${input.runId} not found`);
+      }
+      const row: TranscriptRow = { ...input, createdAt: new Date(0) };
+      rows.set(input.runId, row);
+      order.push("upsert");
+      return row;
+    },
+    async get(agentId, cronId, runId) {
+      const row = rows.get(runId);
+      return row && row.agentId === agentId && row.cronId === cronId
+        ? row
+        : null;
+    },
+    async recordRead(row) {
+      order.push("recordRead");
+      reads.push({ ...row, at: new Date(0) });
+    },
+  };
+  return { store, rows, reads, order };
+}
+
+function makeApp(enabled = true, mem = memoryStore()) {
+  const deps = {
+    agentService: { exists: async () => true },
+    agentTokenService: { validate: async () => null },
+    agentMemberService: { listByEmail: async () => [] },
+    adminApiKeys: parseAdminApiKeys(
+      `root:${ADMIN}:*,reader:${READ}:platform.read,operator:${OPS}:platform.ops,a1:${AGENT_KEY}:${AGENT},a2:${OTHER_KEY}:agent-2`,
+    ),
+    sessionSecret: "s".repeat(32),
+    transcripts: {
+      config: parseTranscriptConfig({
+        SHIPWRIGHT_TRANSCRIPT_API_ENABLED: enabled ? "enabled" : undefined,
+      }),
+      store: mem.store,
+    },
+  } as unknown as AdminDeps;
+  return { app: createAdminApp(deps), ...mem };
+}
+
+const path = (agent = AGENT, cron = CRON, run = RUN) =>
+  `/agents/${agent}/crons/${cron}/runs/${run}/transcript`;
+
+function put(
+  app: ReturnType<typeof createAdminApp>,
+  token: string | null,
+  body: Record<string, unknown> = {},
+  p = path(),
+) {
+  return app.request(p, {
+    method: "PUT",
+    body: JSON.stringify({
+      sessionId: "sess-1",
+      body: SECRET_BODY,
+      truncated: false,
+      redactions: 2,
+      ...body,
+    }),
+    headers: {
+      "Content-Type": "application/json",
+      ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    },
+  });
+}
+
+function get(
+  app: ReturnType<typeof createAdminApp>,
+  token: string | null,
+  p = path(),
+) {
+  return app.request(p, {
+    headers: token ? { Authorization: `Bearer ${token}` } : {},
+  });
+}
+
+describe("transcript routes — flag", () => {
+  it("404s PUT and GET when the flag is off, for every caller", async () => {
+    const { app } = makeApp(false);
+    expect((await put(app, ADMIN)).status).toBe(404);
+    expect((await put(app, AGENT_KEY)).status).toBe(404);
+    expect((await get(app, ADMIN)).status).toBe(404);
+    expect((await get(app, READ)).status).toBe(404);
+  });
+
+  it("404s when no transcript deps are wired at all", async () => {
+    const deps = {
+      agentService: { exists: async () => true },
+      agentTokenService: { validate: async () => null },
+      adminApiKeys: parseAdminApiKeys(`root:${ADMIN}:*`),
+      sessionSecret: "s".repeat(32),
+    } as unknown as AdminDeps;
+    const app = createAdminApp(deps);
+    expect((await get(app, ADMIN)).status).toBe(404);
+  });
+});
+
+describe("PUT transcript — auth matrix", () => {
+  it("accepts the agent's own key and the admin key", async () => {
+    const { app, rows } = makeApp();
+    expect((await put(app, AGENT_KEY)).status).toBe(200);
+    expect((await put(app, ADMIN)).status).toBe(200);
+    expect(rows.get(RUN)?.redactions).toBe(2);
+  });
+
+  it("rejects another agent's key, platform keys and anonymous callers", async () => {
+    const { app } = makeApp();
+    expect((await put(app, OTHER_KEY)).status).toBe(403);
+    expect((await put(app, READ)).status).toBe(403);
+    expect((await put(app, OPS)).status).toBe(403);
+    expect((await put(app, null)).status).toBe(401);
+  });
+
+  it("404s when the run is not owned by the cron/agent", async () => {
+    const { app } = makeApp();
+    expect((await put(app, ADMIN, {}, path(AGENT, "other-cron"))).status).toBe(
+      404,
+    );
+  });
+
+  it("returns the stored size and flags", async () => {
+    const { app } = makeApp();
+    const res = await put(app, AGENT_KEY, { truncated: true });
+    expect(await res.json()).toEqual({
+      runId: RUN,
+      bytes: Buffer.byteLength(SECRET_BODY),
+      truncated: true,
+      redactions: 2,
+    });
+  });
+});
+
+describe("PUT transcript — size cap", () => {
+  it("accepts exactly 1 MiB and 413s one byte over", async () => {
+    const { app } = makeApp();
+    const ok = await put(app, AGENT_KEY, {
+      body: "a".repeat(MAX_TRANSCRIPT_BODY_BYTES),
+    });
+    expect(ok.status).toBe(200);
+    const big = await put(app, AGENT_KEY, {
+      body: "a".repeat(MAX_TRANSCRIPT_BODY_BYTES + 1),
+    });
+    expect(big.status).toBe(413);
+  });
+
+  it("counts bytes, not characters", async () => {
+    const { app } = makeApp();
+    const res = await put(app, AGENT_KEY, {
+      body: "é".repeat(MAX_TRANSCRIPT_BODY_BYTES / 2 + 1),
+    });
+    expect(res.status).toBe(413);
+  });
+
+  it("400s a malformed body", async () => {
+    const { app } = makeApp();
+    expect((await put(app, AGENT_KEY, { body: 5 })).status).toBe(400);
+  });
+});
+
+describe("GET transcript — auth matrix and audit", () => {
+  it("403s every agent key, even for its own run", async () => {
+    const mem = memoryStore();
+    const { app, reads } = makeApp(true, mem);
+    await put(app, ADMIN);
+    expect((await get(app, AGENT_KEY)).status).toBe(403);
+    expect((await get(app, OTHER_KEY)).status).toBe(403);
+    expect(reads).toHaveLength(0);
+  });
+
+  it("401s anonymous callers", async () => {
+    const { app } = makeApp();
+    expect((await get(app, null)).status).toBe(401);
+  });
+
+  it("serves admin, platform.read and platform.ops and audits each read first", async () => {
+    const mem = memoryStore();
+    const { app, reads, order } = makeApp(true, mem);
+    await put(app, AGENT_KEY);
+    order.length = 0;
+    for (const [token, kind, reader] of [
+      [ADMIN, "admin", "root"],
+      [READ, "platform-read", "reader"],
+      [OPS, "platform-ops", "operator"],
+    ] as const) {
+      const res = await get(app, token);
+      expect(res.status).toBe(200);
+      expect(await res.json()).toEqual({
+        runId: RUN,
+        cronId: CRON,
+        sessionId: "sess-1",
+        bytes: Buffer.byteLength(SECRET_BODY),
+        truncated: false,
+        redactions: 2,
+        createdAt: new Date(0).toISOString(),
+        body: SECRET_BODY,
+      });
+      expect(reads.at(-1)).toMatchObject({
+        runId: RUN,
+        agentId: AGENT,
+        scopeKind: kind,
+        reader,
+      });
+    }
+    expect(order).toEqual(["recordRead", "recordRead", "recordRead"]);
+    expect(reads).toHaveLength(3);
+  });
+
+  it("404s an absent transcript and writes no audit row", async () => {
+    const { app, reads } = makeApp();
+    expect((await get(app, ADMIN)).status).toBe(404);
+    expect(reads).toHaveLength(0);
+  });
+
+  it("does not respond when the audit write fails", async () => {
+    const mem = memoryStore();
+    const { app } = makeApp(true, mem);
+    await put(app, ADMIN);
+    mem.store.recordRead = async () => {
+      throw new Error("db down");
+    };
+    const errSpy = spyOn(console, "error").mockImplementation(() => {});
+    const res = await get(app, ADMIN);
+    errSpy.mockRestore();
+    expect(res.status).toBe(500);
+    expect(await res.text()).not.toContain(SECRET_BODY);
+  });
+});
+
+describe("transcript routes — logging", () => {
+  it("never logs the transcript body", async () => {
+    const lines: string[] = [];
+    const sinks = (["log", "warn", "error", "info"] as const).map((m) =>
+      spyOn(console, m).mockImplementation((...a: unknown[]) => {
+        lines.push(a.map(String).join(" "));
+      }),
+    );
+    const { app } = makeApp();
+    await put(app, AGENT_KEY);
+    await get(app, ADMIN);
+    for (const s of sinks) s.mockRestore();
+    expect(lines.join("\n")).not.toContain(SECRET_BODY);
+  });
+});

package/src/cron-run-transcripts.ts

@@ -0,0 +1,314 @@
+/**
+ * admin/src/cron-run-transcripts.ts
+ *
+ * Redacted cron-run transcripts (COS-43.1):
+ *   PUT /agents/{id}/crons/{cronId}/runs/{runId}/transcript   (agent key or admin)
+ *   GET /agents/{id}/crons/{cronId}/runs/{runId}/transcript   (admin / platform only)
+ *
+ * The runtime redacts and tail-truncates before uploading; admin only caps the
+ * size (1 MiB, 413) and stores. Gates: flag (SHIPWRIGHT_TRANSCRIPT_API_ENABLED,
+ * 404 when off) -> caller. GET is closed to agent keys, even for their own
+ * runs, and writes an AgentTranscriptRead audit row BEFORE responding. The
+ * body is never logged. Retention: PUT keeps the newest 200 transcripts per
+ * agent.
+ */
+
+import { createRoute, type OpenAPIHono } from "@hono/zod-openapi";
+import type { PrismaClient } from "../prisma/client/client.ts";
+import type { AdminAuthEnv, AdminScope } from "./api-auth.ts";
+import {
+  ForbiddenError,
+  NotFoundError,
+  PayloadTooLargeError,
+} from "./errors.ts";
+import {
+  CronRunIdParamSchema,
+  CronRunTranscriptSchema,
+  CronRunTranscriptUploadResultSchema,
+  ErrorSchema,
+  UploadCronRunTranscriptBodySchema,
+} from "./openapi-schemas.ts";
+import type { TranscriptConfig } from "./transcript-config.ts";
+
+/** Largest accepted transcript body, in UTF-8 bytes. */
+export const MAX_TRANSCRIPT_BODY_BYTES = 1024 * 1024;
+
+/** Transcripts kept per agent; older ones are deleted on each upload. */
+export const TRANSCRIPT_RETENTION_PER_AGENT = 200;
+
+export interface TranscriptRow {
+  runId: string;
+  agentId: string;
+  cronId: string;
+  sessionId: string | null;
+  bytes: number;
+  truncated: boolean;
+  redactions: number;
+  body: string;
+  createdAt: Date;
+}
+
+export interface TranscriptReadRow {
+  runId: string;
+  agentId: string;
+  reader: string;
+  scopeKind: string;
+  at: Date;
+}
+
+export type TranscriptUpsertInput = Omit<TranscriptRow, "createdAt">;
+
+export interface TranscriptStore {
+  /**
+   * Validates run -> cron -> agent ownership (NotFoundError otherwise), upserts
+   * by runId, then sweeps the agent down to the newest 200 transcripts.
+   */
+  upsert(input: TranscriptUpsertInput): Promise<TranscriptRow>;
+  get(
+    agentId: string,
+    cronId: string,
+    runId: string,
+  ): Promise<TranscriptRow | null>;
+  recordRead(row: Omit<TranscriptReadRow, "at">): Promise<void>;
+}
+
+/** Prisma-backed transcript store. */
+export class CronRunTranscriptService implements TranscriptStore {
+  constructor(
+    private prisma: Pick<
+      PrismaClient,
+      "agentCronRun" | "agentCronRunTranscript" | "agentTranscriptRead"
+    >,
+  ) {}
+
+  async upsert(input: TranscriptUpsertInput): Promise<TranscriptRow> {
+    // Same ownership rule as AgentCronRunService.patch.
+    const run = await this.prisma.agentCronRun.findUnique({
+      where: { id: input.runId },
+    });
+    if (!run || run.agentId !== input.agentId || run.cronId !== input.cronId) {
+      throw new NotFoundError(`cron run ${input.runId} not found`);
+    }
+    const fields = {
+      agentId: input.agentId,
+      cronId: input.cronId,
+      sessionId: input.sessionId,
+      bytes: input.bytes,
+      truncated: input.truncated,
+      redactions: input.redactions,
+      body: input.body,
+    };
+    const row = await this.prisma.agentCronRunTranscript.upsert({
+      where: { runId: input.runId },
+      create: { runId: input.runId, ...fields },
+      update: { ...fields, createdAt: new Date() },
+    });
+    await this.sweep(input.agentId);
+    return row;
+  }
+
+  /** Deletes every transcript of the agent beyond the newest 200. */
+  private async sweep(agentId: string): Promise<void> {
+    const stale = await this.prisma.agentCronRunTranscript.findMany({
+      where: { agentId },
+      orderBy: [{ createdAt: "desc" }, { id: "desc" }],
+      skip: TRANSCRIPT_RETENTION_PER_AGENT,
+      select: { id: true },
+    });
+    if (stale.length === 0) return;
+    await this.prisma.agentCronRunTranscript.deleteMany({
+      where: { id: { in: stale.map((r) => r.id) } },
+    });
+  }
+
+  async get(
+    agentId: string,
+    cronId: string,
+    runId: string,
+  ): Promise<TranscriptRow | null> {
+    const row = await this.prisma.agentCronRunTranscript.findUnique({
+      where: { runId },
+    });
+    if (!row || row.agentId !== agentId || row.cronId !== cronId) return null;
+    return row;
+  }
+
+  async recordRead(row: Omit<TranscriptReadRow, "at">): Promise<void> {
+    await this.prisma.agentTranscriptRead.create({ data: row });
+  }
+}
+
+// ─── Deps ─────────────────────────────────────────────────────────────────────
+
+export interface CronRunTranscriptDeps {
+  config: TranscriptConfig;
+  store: TranscriptStore;
+}
+
+// ─── Routes ───────────────────────────────────────────────────────────────────
+
+const jsonError = {
+  content: { "application/json": { schema: ErrorSchema } },
+};
+
+const putTranscriptRoute = createRoute({
+  method: "put",
+  path: "/agents/{id}/crons/{cronId}/runs/{runId}/transcript",
+  summary: "Upload a cron run transcript",
+  description:
+    "Stores (upserts) the runtime's already-redacted session transcript for a cron run, then keeps only the agent's newest 200 transcripts. Callers: the agent's own key, or `*`. `body` over 1 MiB (UTF-8 bytes) is a 413. 404 unless SHIPWRIGHT_TRANSCRIPT_API_ENABLED is `enabled`, or when the run is not owned by the cron/agent.",
+  request: {
+    params: CronRunIdParamSchema,
+    body: {
+      content: {
+        "application/json": { schema: UploadCronRunTranscriptBodySchema },
+      },
+    },
+  },
+  responses: {
+    200: {
+      description: "Transcript stored",
+      content: {
+        "application/json": { schema: CronRunTranscriptUploadResultSchema },
+      },
+    },
+    400: { description: "Bad request", ...jsonError },
+    403: { description: "Caller not allowed", ...jsonError },
+    404: {
+      description: "Run not found, or transcript API disabled",
+      ...jsonError,
+    },
+    413: { description: "Transcript body over 1 MiB", ...jsonError },
+  },
+});
+
+const getTranscriptRoute = createRoute({
+  method: "get",
+  path: "/agents/{id}/crons/{cronId}/runs/{runId}/transcript",
+  summary: "Get a cron run transcript",
+  description:
+    "Returns the stored redacted transcript. `*`, `platform.read` and `platform.ops` callers only: an agent key is 403 even for its own runs. Every read writes an AgentTranscriptRead audit row before the response. 404 when SHIPWRIGHT_TRANSCRIPT_API_ENABLED is not `enabled` or no transcript exists.",
+  request: { params: CronRunIdParamSchema },
+  responses: {
+    200: {
+      description: "The transcript",
+      content: { "application/json": { schema: CronRunTranscriptSchema } },
+    },
+    403: { description: "Forbidden", ...jsonError },
+    404: {
+      description: "No transcript, or transcript API disabled",
+      ...jsonError,
+    },
+  },
+});
+
+/**
+ * Register the transcript routes on the admin app. Must run after the
+ * /agents/* auth middleware is mounted.
+ */
+export function registerCronRunTranscriptRoutes(
+  app: OpenAPIHono<AdminAuthEnv>,
+  deps: { transcripts?: CronRunTranscriptDeps },
+): void {
+  const { transcripts } = deps;
+  const enabled = transcripts?.config.enabled === true;
+
+  // Flag gate ahead of body validation: a disabled route is a plain 404.
+  app.use(
+    "/agents/:id/crons/:cronId/runs/:runId/transcript",
+    async (c, next) => {
+      if (!enabled) return c.json({ error: "Not found" }, 404);
+      await next();
+    },
+  );
+
+  app.openapi(putTranscriptRoute, async (c) => {
+    if (!transcripts) throw new NotFoundError();
+    const { id: agentId, cronId, runId } = c.req.valid("param");
+    const scope = c.get("scope") as AdminScope | undefined;
+    const allowed =
+      c.get("isAdmin") === true ||
+      (scope?.kind === "agent" && scope.agentId === agentId);
+    if (!allowed) {
+      throw new ForbiddenError(
+        "Only * or the agent's own key can upload a transcript",
+      );
+    }
+    const body = c.req.valid("json");
+    const bytes = Buffer.byteLength(body.body, "utf8");
+    if (bytes > MAX_TRANSCRIPT_BODY_BYTES) {
+      throw new PayloadTooLargeError(
+        `transcript body exceeds ${MAX_TRANSCRIPT_BODY_BYTES} bytes`,
+      );
+    }
+    const row = await transcripts.store.upsert({
+      runId,
+      agentId,
+      cronId,
+      sessionId: body.sessionId ?? null,
+      bytes,
+      truncated: body.truncated,
+      redactions: body.redactions,
+      body: body.body,
+    });
+    // Metadata only; the body is never logged.
+    console.log(
+      JSON.stringify({
+        event: "transcript.upload",
+        agentId,
+        cronId,
+        runId,
+        bytes,
+        truncated: row.truncated,
+        redactions: row.redactions,
+      }),
+    );
+    return c.json(
+      {
+        runId,
+        bytes: row.bytes,
+        truncated: row.truncated,
+        redactions: row.redactions,
+      },
+      200,
+    );
+  });
+
+  app.openapi(getTranscriptRoute, async (c) => {
+    if (!transcripts) throw new NotFoundError();
+    const scope = c.get("scope") as AdminScope | undefined;
+    const kind = scope?.kind;
+    const allowed =
+      c.get("isAdmin") === true ||
+      kind === "platform-read" ||
+      kind === "platform-ops";
+    if (!allowed) {
+      throw new ForbiddenError(
+        "Only *, platform.read and platform.ops callers can read transcripts",
+      );
+    }
+    const { id: agentId, cronId, runId } = c.req.valid("param");
+    const row = await transcripts.store.get(agentId, cronId, runId);
+    if (!row) throw new NotFoundError("transcript not found");
+    // Audit first: if the write fails, the body is not served.
+    await transcripts.store.recordRead({
+      runId,
+      agentId,
+      reader: c.get("caller")?.name ?? "anonymous",
+      scopeKind: kind ?? (c.get("isAdmin") === true ? "admin" : "session"),
+    });
+    return c.json(
+      {
+        runId: row.runId,
+        cronId: row.cronId,
+        sessionId: row.sessionId,
+        bytes: row.bytes,
+        truncated: row.truncated,
+        redactions: row.redactions,
+        createdAt: row.createdAt.toISOString(),
+        body: row.body,
+      },
+      200,
+    );
+  });
+}

package/src/errors.ts

@@ -62,6 +62,13 @@ export class ForbiddenError extends ApiError {
   }
 }
 
+export class PayloadTooLargeError extends ApiError {
+  constructor(message = "Payload too large") {
+    super(413, message);
+    this.name = "PayloadTooLargeError";
+  }
+}
+
 export class UnprocessableEntityError extends ApiError {
   constructor(message = "Unprocessable entity") {
     super(422, message);

package/src/openapi-schemas.ts

@@ -698,6 +698,51 @@ export const ChatCredentialsWrapperSchema = z
   .object({ credentials: z.array(ChatCredentialSchema) })
   .openapi("ChatCredentialsWrapper");
 
+// ─── Cron-run transcripts (COS-43.1) ─────────────────────────────────────────
+
+export const UploadCronRunTranscriptBodySchema = z
+  .object({
+    sessionId: z.string().min(1).optional().openapi({
+      description: "Claude session id the transcript was read from.",
+      example: "7c1c8d1e-0000-4000-8000-000000000000",
+    }),
+    body: z.string().openapi({
+      description:
+        "The already-redacted transcript (JSONL text). Over 1 MiB (UTF-8 bytes) is a 413. Never logged.",
+    }),
+    truncated: z.boolean().openapi({
+      description: "True when the runtime dropped earlier lines to fit.",
+      example: false,
+    }),
+    redactions: z.number().int().min(0).openapi({
+      description: "How many secrets the runtime redacted.",
+      example: 0,
+    }),
+  })
+  .openapi("UploadCronRunTranscriptBody");
+
+export const CronRunTranscriptUploadResultSchema = z
+  .object({
+    runId: z.string().openapi({ example: "clx1111111111" }),
+    bytes: z.number().int().openapi({ example: 2048 }),
+    truncated: z.boolean().openapi({ example: false }),
+    redactions: z.number().int().openapi({ example: 0 }),
+  })
+  .openapi("CronRunTranscriptUploadResult");
+
+export const CronRunTranscriptSchema = z
+  .object({
+    runId: z.string().openapi({ example: "clx1111111111" }),
+    cronId: z.string().openapi({ example: "clx0987654321" }),
+    sessionId: z.string().nullable().openapi({ example: null }),
+    bytes: z.number().int().openapi({ example: 2048 }),
+    truncated: z.boolean().openapi({ example: false }),
+    redactions: z.number().int().openapi({ example: 0 }),
+    createdAt: z.string().openapi({ example: "2026-10-26T12:00:00.000Z" }),
+    body: z.string().openapi({ description: "Redacted JSONL transcript." }),
+  })
+  .openapi("CronRunTranscript");
+
 // ─── Agent ask (COS-31.1) ─────────────────────────────────────────────────────
 
 export const AgentAskBodySchema = z
@@ -1249,6 +1294,25 @@ export const AgentConfigResponseSchema = z
         "dev-task": null,
       },
     }),
+    /**
+     * COS-43.1: feature flags the runtime acts on. Optional (additive) so an
+     * older runtime or fixture that omits it keeps working; the handler
+     * always populates it.
+     */
+    features: z
+      .object({
+        transcriptUpload: z.boolean().openapi({
+          description:
+            "True when SHIPWRIGHT_TRANSCRIPT_API_ENABLED is on: the runtime uploads a redacted transcript after each cron run.",
+          example: false,
+        }),
+        repoAccessCheck: z.boolean().openapi({
+          description: "Reserved for the repo-access check (COS-44.1).",
+          example: false,
+        }),
+      })
+      .optional()
+      .openapi("AgentConfigFeatures"),
   })
   .openapi("AgentConfigResponse");