@cursor/july 0.1.8 → 0.1.9

package/src/internal/deploy-source.ts

@@ -39,17 +39,35 @@ const defaultGitRunner: GitRunner = async (args, cwd) => {
  * Normalize a git remote URL to the https form the control plane accepts
  * (`https://host/owner/repo`, no `.git` suffix). Returns undefined for
  * unrecognized shapes.
+ *
+ * Accepts HTTPS, `git@host:path`, GitHub org-scoped SSH
+ * (`org-123@github.com:owner/repo.git`), and `ssh://user@host[:port]/path`.
  */
 export function httpsGitRepoUrlFromRemote(remote: string): string | undefined {
   let url = remote.trim();
   if (url === "") {
     return undefined;
   }
-  if (url.startsWith("git@")) {
-    // git@host:owner/repo.git → https://host/owner/repo.git
-    url = `https://${url.slice("git@".length).replace(":", "/")}`;
-  } else if (url.startsWith("ssh://git@")) {
-    url = `https://${url.slice("ssh://git@".length)}`;
+
+  // SCP-like SSH: user@host:owner/repo(.git) — includes git@ and GitHub
+  // org deploy keys (org-NNNN@github.com:…).
+  const scpMatch = /^([^@/\s]+)@([^:/\s]+):(.+)$/.exec(url);
+  if (scpMatch !== null) {
+    const host = scpMatch[2]!;
+    const path = scpMatch[3]!;
+    url = `https://${host}/${path}`;
+  } else if (/^ssh:\/\//i.test(url)) {
+    // ssh://user@host[:port]/owner/repo → https://host/owner/repo
+    try {
+      const ssh = new URL(url);
+      const path = ssh.pathname.replace(/^\/+/, "");
+      if (ssh.hostname === "" || path === "") {
+        return undefined;
+      }
+      url = `https://${ssh.hostname}/${path}`;
+    } catch {
+      return undefined;
+    }
   } else if (!/^https?:\/\//i.test(url)) {
     return undefined;
   }
@@ -67,7 +85,7 @@ export function httpsGitRepoUrlFromRemote(remote: string): string | undefined {
   if (path === "" || !path.includes("/")) {
     return undefined;
   }
-  // Use hostname (not host) so ssh://git@github.com:22/… does not keep :22.
+  // Use hostname (not host) so ssh://…@github.com:22/… does not keep :22.
   return `https://${parsed.hostname}/${path}`;
 }
 

package/src/internal/discovery.ts

@@ -454,7 +454,7 @@ function resolveHosting(
       warn(`hosting.secretNames: ${nameError}`);
     } else if (isReservedSecretName(name)) {
       warn(
-        `hosting.secretNames: ${JSON.stringify(name)} is platform-reserved (CURSOR_*) and injected automatically; it cannot be set with \`secrets set\`.`
+        `hosting.secretNames: ${JSON.stringify(name)} is platform-managed (CURSOR_* / Cursor-hosted storage) and injected automatically; omit it from secretNames.`
       );
     }
   }

package/src/internal/distribution.ts

@@ -105,4 +105,5 @@ export const AUTHORING_ENTRY_FILES: ReadonlyArray<
   ["storage", "storage.js"],
   ["storage/file-kv", "storage-backends/file-kv.js"],
   ["storage/postgres-kv", "storage-backends/postgres-kv.js"],
+  ["storage/cursor-hosted", "storage-backends/cursor-hosted.js"],
 ];

package/src/internal/hosting.ts

@@ -18,6 +18,17 @@ export const MAX_SECRET_NAME_LENGTH = 64;
 /** Secret names the platform injects; user writes are rejected. */
 export const RESERVED_SECRET_NAME_PREFIX = "CURSOR_";
 
+/**
+ * Additional platform-managed env names for Cursor-hosted durable storage
+ * (Bugbot `agent_serve_*`). Mirrored from
+ * `@cursor/july/storage/cursor-hosted` so validate/secrets CLI stay in sync
+ * without importing the storage backend into the CLI graph.
+ */
+export const PLATFORM_HOSTED_STORAGE_SECRET_NAMES = [
+  "BUGBOTDB_URL",
+  "AGENT_SERVE_DEPLOYMENT_ID",
+] as const;
+
 const SECRET_NAME_PATTERN = /^[A-Z][A-Z0-9_]*$/;
 
 // Lowercase hostname with >=2 labels, an alphabetic TLD, and at most one
@@ -49,14 +60,23 @@ export function validateSecretName(name: string): string | undefined {
   return undefined;
 }
 
-/** True when the platform reserves this name (`CURSOR_*`); writes are rejected. */
+/**
+ * True when the platform manages this name (`CURSOR_*` or hosted-storage
+ * env vars); user writes / deletes are rejected.
+ */
 export function isReservedSecretName(name: string): boolean {
-  return name.startsWith(RESERVED_SECRET_NAME_PREFIX);
+  if (name.startsWith(RESERVED_SECRET_NAME_PREFIX)) {
+    return true;
+  }
+  const upper = name.toUpperCase();
+  return (PLATFORM_HOSTED_STORAGE_SECRET_NAMES as readonly string[]).some(
+    (managed) => managed === upper
+  );
 }
 
 /**
  * Human error for a secret name a user is trying to write or delete:
- * grammar plus the reserved `CURSOR_*` prefix.
+ * grammar plus platform-managed names (`CURSOR_*`, hosted storage).
  */
 export function validateSettableSecretName(name: string): string | undefined {
   const nameError = validateSecretName(name);
@@ -64,7 +84,7 @@ export function validateSettableSecretName(name: string): string | undefined {
     return nameError;
   }
   if (isReservedSecretName(name)) {
-    return `Secret name ${JSON.stringify(name)} is platform-reserved (CURSOR_*); the platform injects those values automatically.`;
+    return `Secret name ${JSON.stringify(name)} is platform-managed; the platform injects CURSOR_* and Cursor-hosted storage values automatically.`;
   }
   return undefined;
 }

package/src/internal/logs-client.ts

@@ -35,7 +35,9 @@ export type LogsProgress =
   | DeploymentProgress
   | "queued"
   | "preparing"
+  | "creating"
   | "building"
+  | "starting"
   | "finalizing"
   | "running"
   | "failed"
@@ -46,7 +48,9 @@ export type LogsProgress =
 const PROGRESS_MESSAGES: Readonly<Record<LogsProgress, string>> = {
   queued: "Waiting to start…",
   preparing: "Preparing runtime…",
-  building: "Building and starting agent…",
+  creating: "Creating runtime…",
+  building: "Checking out source and installing dependencies…",
+  starting: "Starting agent and waiting for health…",
   finalizing: "Finishing deployment…",
   running: "Deployment running",
   failed: "Deploy failed",
@@ -55,9 +59,15 @@ const PROGRESS_MESSAGES: Readonly<Record<LogsProgress, string>> = {
   degraded: "Deployment degraded",
 };
 
+/**
+ * Customer-facing line for the current deploy step. Prefer the live
+ * `statusMessage` from the API when present; otherwise the progress
+ * vocabulary. Failed/degraded always append sanitized `lastError`.
+ */
 export function progressMessage(
   progress: LogsProgress,
-  lastError?: string | null
+  lastError?: string | null,
+  statusMessage?: string | null
 ): string {
   if (progress === "failed") {
     const detail =
@@ -73,6 +83,13 @@ export function progressMessage(
         : `: ${sanitizeCustomerError(lastError)}`;
     return `Deployment degraded${detail}`;
   }
+  if (
+    statusMessage !== null &&
+    statusMessage !== undefined &&
+    statusMessage.trim() !== ""
+  ) {
+    return statusMessage.trim();
+  }
   return PROGRESS_MESSAGES[progress];
 }
 
@@ -85,7 +102,38 @@ export function sanitizeCustomerError(message: string): string {
     .replace(/\bcursorvm\.com\b/gi, "host")
     .replace(/\bx-anyrun-[a-z0-9-]+\b/gi, "header")
     .replace(/\bPROVISIONING\b/g, "building")
-    .replace(/\bPLANNED\b/g, "preparing");
+    .replace(/\bPLANNED\b/g, "preparing")
+    .replace(/\bgitCloneCheckout\b/gi, "git clone")
+    .replace(/\bgitFetchCheckout\b/gi, "git fetch")
+    .replace(/\bgitCheckout:clone\b/gi, "checkout")
+    .replace(/\bgitCheckout:fetch\b/gi, "checkout");
+}
+
+/**
+ * One-line label for `agentkit deploy` polling (TTY spinner / non-TTY
+ * transitions). Uses statusMessage → progress → raw status.
+ */
+export function deployProgressLabel(detail: {
+  status: string;
+  progress?: DeploymentProgress;
+  statusMessage?: string | null;
+}): string {
+  if (
+    detail.statusMessage !== null &&
+    detail.statusMessage !== undefined &&
+    detail.statusMessage.trim() !== ""
+  ) {
+    return detail.statusMessage
+      .trim()
+      .replace(/…$/, "")
+      .replace(/\.\.\.$/, "");
+  }
+  if (detail.progress !== undefined) {
+    return PROGRESS_MESSAGES[detail.progress]
+      .replace(/…$/, "")
+      .replace(/\.\.\.$/, "");
+  }
+  return detail.status;
 }
 
 export async function fetchLogs(args: {
@@ -241,7 +289,7 @@ async function followProdLogs(args: {
       );
     });
 
-  let lastProgress: string | undefined;
+  let lastEmittedKey: string | undefined;
   const slugHint = args.slug !== undefined && args.slug !== "" ? args.slug : "";
   if (args.once !== true) {
     const label = slugHint !== "" ? slugHint : "deployment";
@@ -260,33 +308,32 @@ async function followProdLogs(args: {
     }
 
     const progress = resolveProgress(detail);
+    const message = progressMessage(
+      progress,
+      detail.lastError,
+      detail.statusMessage
+    );
+    const emitKey = `${progress}\0${message}`;
 
     if (progress === "failed") {
-      const message = progressMessage(progress, detail.lastError);
-      if (progress !== lastProgress) {
-        lastProgress = progress;
+      if (emitKey !== lastEmittedKey) {
+        lastEmittedKey = emitKey;
         emitProgress(args.write, args.json === true, progress, message);
       }
       throw new Error(`Deployment "${detail.slug}" failed.`);
     }
     if (progress === "stopped") {
-      const message = progressMessage(progress, detail.lastError);
-      if (progress !== lastProgress) {
-        lastProgress = progress;
+      if (emitKey !== lastEmittedKey) {
+        lastEmittedKey = emitKey;
         emitProgress(args.write, args.json === true, progress, message);
       }
       throw new Error(`Deployment "${detail.slug}" is stopped.`);
     }
     if (progress === "running" || progress === "degraded") {
       // Hand off to runtime logs. Print degraded once; skip a "running" line.
-      if (progress === "degraded" && progress !== lastProgress) {
-        lastProgress = progress;
-        emitProgress(
-          args.write,
-          args.json === true,
-          progress,
-          progressMessage(progress, detail.lastError)
-        );
+      if (progress === "degraded" && emitKey !== lastEmittedKey) {
+        lastEmittedKey = emitKey;
+        emitProgress(args.write, args.json === true, progress, message);
       }
       const runtime = await resolveRuntime();
       await followRuntimeLogs({
@@ -306,9 +353,8 @@ async function followProdLogs(args: {
       return;
     }
 
-    const message = progressMessage(progress, detail.lastError);
-    if (progress !== lastProgress) {
-      lastProgress = progress;
+    if (emitKey !== lastEmittedKey) {
+      lastEmittedKey = emitKey;
       emitProgress(args.write, args.json === true, progress, message);
     }
 

package/src/internal/session-engine.ts

@@ -73,7 +73,6 @@ import {
 import { validateToolInput } from "./json-schema.js";
 import { McpHost } from "./mcp-host.js";
 import {
-  buildIdentitySection,
   buildSessionContextBlock,
   SCHEDULE_CHANNEL_PREFIX,
 } from "./prompt-context.js";
@@ -83,7 +82,8 @@ import { SessionStore } from "./session-store.js";
 import { StorageCoordinator } from "./storage-coordinator.js";
 import { normalizeToolResult, toolCallErrorMessage } from "./tool-result.js";
 import {
-  buildAgentToolsCatalog,
+  buildAgentsMdContent,
+  isNestedInGitRepo,
   materializeWorkspace,
   writeWorkspaceFiles,
 } from "./workspace.js";
@@ -1019,12 +1019,22 @@ export class SessionEngine {
           return rest;
         });
       }
+      // The harness only loads the scaffolded AGENTS.md when the session
+      // workspace is its own project root. With a per-session cwd override
+      // (PR worktree) the scaffold lands elsewhere, and a workspace nested
+      // inside a git repo re-roots harness rules at that repo — in both
+      // cases deliver instructions inline on the first turn instead.
+      const instructionsInvisibleToHarness =
+        isFirstTurn &&
+        (record.workspaceOverride !== undefined ||
+          (await isNestedInGitRepo(harnessCwd)));
       const request = this.buildTurnRequest(
         record,
         agent,
         turnId,
         message,
         isFirstTurn,
+        instructionsInvisibleToHarness,
         emit,
         async (update) => {
           mapper.handleUpdate(update);
@@ -1120,6 +1130,7 @@ export class SessionEngine {
     turnId: string,
     prompt: string,
     isFirstTurn: boolean,
+    instructionsInvisibleToHarness: boolean,
     emit: (payload: SessionEventPayload) => void,
     onUpdate: RunnerTurnRequest["onUpdate"],
     signal: AbortSignal
@@ -1147,15 +1158,21 @@ export class SessionEngine {
       });
       turnPrompt = `${contextBlock}\n\n${prompt}`;
     }
-    if (runtime === "cloud" && isFirstTurn) {
-      const preamble = [
-        agent.instructions?.trim() ?? "",
-        buildIdentitySection(agent),
-        buildAgentToolsCatalog(agent.tools, { includeScripts: true }),
-      ]
-        .filter((part) => part !== "")
-        .join("\n\n");
-      turnPrompt = `${preamble}\n\n${turnPrompt}`;
+    if (isFirstTurn) {
+      if (runtime === "cloud") {
+        // Cloud VMs have no materialized workspace: ship the full context,
+        // including agent tool script bodies.
+        const preamble = buildAgentsMdContent(agent, { includeScripts: true });
+        turnPrompt = `${preamble}\n\n${turnPrompt}`;
+      } else if (instructionsInvisibleToHarness) {
+        // Local workspace whose AGENTS.md the harness will not load. With a
+        // per-session harness cwd override, agent tool scripts live only in
+        // the durable scaffold dir — embed bodies like cloud. Otherwise the
+        // catalog can reference on-disk paths under the harness cwd.
+        const includeScripts = record.workspaceOverride !== undefined;
+        const preamble = buildAgentsMdContent(agent, { includeScripts });
+        turnPrompt = `${preamble}\n\n${turnPrompt}`;
+      }
     }
     return {
       sessionId: record.sessionId,

package/src/internal/workspace.ts

@@ -8,7 +8,7 @@
  */
 
 import { chmod, copyFile, mkdir, stat, writeFile } from "node:fs/promises";
-import { dirname, join, relative, resolve } from "node:path";
+import { dirname, join, parse, relative, resolve } from "node:path";
 import type {
   DiscoveredSkill,
   DiscoveredTool,
@@ -123,22 +123,59 @@ export function buildAgentToolsCatalog(
   return `${parts.join("\n").trimEnd()}\n`;
 }
 
+/**
+ * The full AGENTS.md-equivalent context for an agent: instructions, identity
+ * section, and the agent-side tool catalog. Written to the session workspace
+ * as `AGENTS.md`, and inlined into the first turn's prompt when the harness
+ * cannot discover that file (cloud runtime, or a local workspace the harness
+ * will not treat as the project root — see {@link isNestedInGitRepo}).
+ */
+export function buildAgentsMdContent(
+  agent: ResolvedAgent,
+  options: { includeScripts: boolean }
+): string {
+  return [
+    agent.instructions?.trim() ?? "",
+    buildIdentitySection(agent),
+    buildAgentToolsCatalog(agent.tools, {
+      includeScripts: options.includeScripts,
+    }),
+  ]
+    .filter((part) => part !== "")
+    .join("\n\n");
+}
+
+/**
+ * True when `dir` sits strictly inside a git repository (a `.git` exists in
+ * an ancestor directory but not in `dir` itself). The Cursor harness resolves
+ * its project root by walking up to the nearest git root, so a nested session
+ * workspace loses its own `AGENTS.md` / `.cursor` scaffold: the enclosing
+ * repo's rules load instead, and the (necessarily gitignored) workspace files
+ * are skipped by nested rule discovery.
+ */
+export async function isNestedInGitRepo(dir: string): Promise<boolean> {
+  let current = resolve(dir);
+  if (await exists(join(current, ".git"))) {
+    // The workspace is itself a repo root; the harness roots rules here.
+    return false;
+  }
+  const { root } = parse(current);
+  while (current !== root) {
+    current = dirname(current);
+    if (await exists(join(current, ".git"))) {
+      return true;
+    }
+  }
+  return false;
+}
+
 export async function materializeWorkspace(
   options: MaterializeWorkspaceOptions
 ): Promise<void> {
   const { agent, workspaceDir, seed } = options;
   await mkdir(workspaceDir, { recursive: true });
 
-  const agentToolsSection = buildAgentToolsCatalog(agent.tools, {
-    includeScripts: false,
-  });
-  const agentsMd = [
-    agent.instructions?.trim() ?? "",
-    buildIdentitySection(agent),
-    agentToolsSection,
-  ]
-    .filter((part) => part !== "")
-    .join("\n\n");
+  const agentsMd = buildAgentsMdContent(agent, { includeScripts: false });
   await writeFile(join(workspaceDir, "AGENTS.md"), agentsMd, "utf8");
 
   for (const tool of agent.tools) {

package/src/storage-backends/cursor-hosted.ts

@@ -0,0 +1,246 @@
+/**
+ * Cursor-managed durable storage for hosted agents.
+ *
+ * Talks to the control-plane storage proxy
+ * (`POST /internal/agent-serve/storage/*`) using the engine's pod
+ * `CURSOR_API_KEY`. The server resolves `deployment_id` from that service
+ * account — engines never receive a Bugbot DSN and cannot address another
+ * deployment's rows.
+ *
+ * On Cursor-managed hosting the start script pins `CURSOR_API_BASE_URL` to
+ * `https://api.cursor.com` (where the proxy is mounted). Locally, point
+ * `CURSOR_API_BASE_URL` at a backend that mounts Agent Serve routes and use
+ * a deployment SA key, or use `@cursor/july/storage/postgres-kv` /
+ * `file-kv` instead.
+ *
+ * ```ts
+ * import { defineStorage } from "@cursor/july/storage";
+ * import { cursorHostedStorage } from "@cursor/july/storage/cursor-hosted";
+ *
+ * export default defineStorage({
+ *   ...cursorHostedStorage(),
+ * });
+ * ```
+ */
+
+import type { ABSnapshot } from "../ab.js";
+import type { EvalRunSnapshot } from "../evals.js";
+import type {
+  StorageABTable,
+  StorageConfig,
+  StorageEntry,
+  StorageEvalsTable,
+} from "../storage.js";
+import type { JsonValue } from "../types.js";
+
+/**
+ * Same default as {@link cursorExternalApiUrl} in the CLI credentials module,
+ * inlined here so this storage entrypoint does not import CLI/zod code.
+ * Hosted monorepo examples load this file from `packages/agent-serve/src`
+ * while `npm install` runs in the example package — a credentials import
+ * would resolve `zod` from the wrong `node_modules` tree and crash serve.
+ */
+const DEFAULT_CURSOR_EXTERNAL_API_URL = "https://api.cursor.com";
+
+/**
+ * Reserved so user `secrets set` cannot smuggle a Bugbot DSN into the pod.
+ * Not injected by Cursor hosting (storage is HTTP-proxied).
+ */
+export const AGENT_SERVE_HOSTED_STORAGE_DATABASE_URL_ENV_VAR =
+  "BUGBOTDB_URL" as const;
+
+/**
+ * Diagnostic / self-host deployment id. Not the hosted-storage authz
+ * boundary — the proxy scopes rows from the authenticated service account.
+ */
+export const AGENT_SERVE_DEPLOYMENT_ID_ENV_VAR =
+  "AGENT_SERVE_DEPLOYMENT_ID" as const;
+
+/**
+ * Platform-managed secret / env names. User `secrets set` / DELETE cannot
+ * claim these.
+ */
+export const CURSOR_HOSTED_STORAGE_ENV_VARS: readonly [
+  typeof AGENT_SERVE_HOSTED_STORAGE_DATABASE_URL_ENV_VAR,
+  typeof AGENT_SERVE_DEPLOYMENT_ID_ENV_VAR,
+] = [
+  AGENT_SERVE_HOSTED_STORAGE_DATABASE_URL_ENV_VAR,
+  AGENT_SERVE_DEPLOYMENT_ID_ENV_VAR,
+];
+
+export interface CursorHostedStorageOptions {
+  /**
+   * Control-plane base URL (default: `CURSOR_API_BASE_URL`, else
+   * `https://api.cursor.com`).
+   */
+  baseUrl?: string;
+  /** Bearer credential (default: `CURSOR_API_KEY`). */
+  apiKey?: string;
+  /** Injected for tests. */
+  fetch?: typeof fetch;
+}
+
+type CursorHostedStorageMethods = Required<
+  Pick<StorageConfig, "put" | "get" | "delete" | "list">
+> & {
+  evals: StorageEvalsTable;
+  abs: StorageABTable;
+};
+
+function resolveApiKey(options: CursorHostedStorageOptions): string {
+  const key = (options.apiKey ?? process.env.CURSOR_API_KEY)?.trim();
+  if (key === undefined || key === "") {
+    throw new Error(
+      "cursorHostedStorage requires CURSOR_API_KEY (deployment pod credential on Cursor hosting)"
+    );
+  }
+  return key;
+}
+
+function resolveBaseUrl(options: CursorHostedStorageOptions): string {
+  const raw = (
+    options.baseUrl ??
+    process.env.CURSOR_API_BASE_URL ??
+    DEFAULT_CURSOR_EXTERNAL_API_URL
+  ).trim();
+  return raw.endsWith("/") ? raw.slice(0, -1) : raw;
+}
+
+async function storageRpc<T>(
+  options: CursorHostedStorageOptions,
+  path: string,
+  body: Record<string, unknown>
+): Promise<T> {
+  const baseUrl = resolveBaseUrl(options);
+  const apiKey = resolveApiKey(options);
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error("cursorHostedStorage requires fetch");
+  }
+  const response = await fetchImpl(`${baseUrl}${path}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  let parsed: unknown;
+  try {
+    parsed = text.length === 0 ? {} : JSON.parse(text);
+  } catch {
+    throw new Error(
+      `cursorHostedStorage ${path} returned non-JSON (${response.status})`
+    );
+  }
+  if (!response.ok) {
+    const error =
+      parsed !== null &&
+      typeof parsed === "object" &&
+      "error" in parsed &&
+      typeof (parsed as { error: unknown }).error === "string"
+        ? (parsed as { error: string }).error
+        : `HTTP ${response.status}`;
+    throw new Error(`cursorHostedStorage ${path}: ${error}`);
+  }
+  return parsed as T;
+}
+
+/**
+ * Cursor-hosted `defineStorage` methods (control-plane storage proxy →
+ * Bugbot `agent_serve_*` tables). Spread into `defineStorage({...})`.
+ */
+export function cursorHostedStorage(
+  options: CursorHostedStorageOptions = {}
+): CursorHostedStorageMethods {
+  return {
+    async put(key, value): Promise<void> {
+      await storageRpc(options, "/internal/agent-serve/storage/kv/put", {
+        key,
+        value,
+      });
+    },
+    async get(key): Promise<JsonValue | undefined> {
+      const result = await storageRpc<{
+        found: boolean;
+        value: JsonValue | null;
+      }>(options, "/internal/agent-serve/storage/kv/get", { key });
+      if (!result.found) {
+        return undefined;
+      }
+      return result.value ?? undefined;
+    },
+    async delete(key): Promise<void> {
+      await storageRpc(options, "/internal/agent-serve/storage/kv/delete", {
+        key,
+      });
+    },
+    async list(prefix): Promise<StorageEntry[]> {
+      const result = await storageRpc<{
+        entries: Array<{ key: string; value: JsonValue }>;
+      }>(options, "/internal/agent-serve/storage/kv/list", { prefix });
+      return result.entries;
+    },
+    evals: {
+      async put(run, ctx): Promise<void> {
+        await storageRpc(options, "/internal/agent-serve/storage/evals/put", {
+          agentName: ctx.agentName,
+          run,
+        });
+      },
+      async delete(runId, ctx): Promise<void> {
+        await storageRpc(
+          options,
+          "/internal/agent-serve/storage/evals/delete",
+          {
+            agentName: ctx.agentName,
+            runId,
+          }
+        );
+      },
+      async list(ctx): Promise<EvalRunSnapshot[]> {
+        const result = await storageRpc<{ runs: EvalRunSnapshot[] }>(
+          options,
+          "/internal/agent-serve/storage/evals/list",
+          { agentName: ctx.agentName }
+        );
+        return result.runs;
+      },
+    },
+    abs: {
+      async putSample(sample, ctx): Promise<void> {
+        await storageRpc(
+          options,
+          "/internal/agent-serve/storage/abs/put-sample",
+          {
+            agentName: ctx.agentName,
+            sample,
+          }
+        );
+      },
+      async putSnapshot(snapshot, ctx): Promise<void> {
+        await storageRpc(
+          options,
+          "/internal/agent-serve/storage/abs/put-snapshot",
+          {
+            agentName: ctx.agentName,
+            snapshot,
+          }
+        );
+      },
+      async getSnapshot(ctx): Promise<ABSnapshot | undefined> {
+        const result = await storageRpc<{
+          found: boolean;
+          snapshot: ABSnapshot | null;
+        }>(options, "/internal/agent-serve/storage/abs/get-snapshot", {
+          agentName: ctx.agentName,
+        });
+        if (!result.found) {
+          return undefined;
+        }
+        return result.snapshot ?? undefined;
+      },
+    },
+  };
+}