@cursor/july 0.1.48 → 0.1.51

package/src/internal/slack-provision-client.ts

@@ -6,11 +6,11 @@
  *
  * Auth is the user API key sent directly as the bearer (the routes are
  * `wrapUserApiRoute` on the backend); there is no token exchange here.
- * The endpoints are gated on the `agent_serve_slack_provisioning` Statsig
- * gate and 404 when it is off — the error mapping says so instead of
- * "not found". Expected provisioning failures carry a stable JSON `code`
+ * The endpoints ride `requireAgentServeAccess` and 404 `{ error: "Not found" }`
+ * when Agent Serve is off — same mapping as other agent-sdk deploy 404s.
+ * Expected provisioning failures carry a stable JSON `code`
  * (`not_connected`, `insufficient_scopes`, `manager_reauth_required`,
- * `app_conflict`, `app_cap_reached`, `ratelimited`, `invalid_app_id`, …)
+ * `app_conflict`, `ratelimited`, `invalid_app_id`, …)
  * which flows through on {@link SlackProvisionApiError.code} so the CLI
  * can branch.
  */
@@ -55,8 +55,8 @@ export type SlackAppIconInput =
  * Outcome of `POST /apps`. Credentials are returned exactly once and never
  * persisted server-side — the caller owns storing them. `appToken` can be
  * absent when Slack's install response omitted the app-level token.
- * `oauthAuthorizeUrl` is only minted on a fresh app create, so an update
- * that lands in admin approval omits it.
+ * `oauthAuthorizeUrl` is Slack's request-approval / reminder page. Fresh
+ * creates mint it; updates return it when Slack (or a persisted row) has one.
  */
 export type SlackAppProvisionResult =
   | {
@@ -176,6 +176,66 @@ const setIconResponseSchema = z
   })
   .passthrough();
 
+const mintWizardResponseSchema = z
+  .object({
+    wizardId: z.string().min(1),
+    url: z.string().min(1),
+  })
+  .passthrough();
+
+const wizardPollResponseSchema = z
+  .object({
+    wizardId: z.string(),
+    teamId: z.number(),
+    slug: z.string(),
+    env: z.string(),
+    status: z.string(),
+    appId: z.string().optional(),
+    oauthAuthorizeUrl: z.string().optional(),
+    error: z.string().optional(),
+    localEnv: z
+      .object({
+        botToken: z.string().min(1),
+        appToken: z.string().optional(),
+      })
+      .optional(),
+    localEnvClaimed: z.boolean().optional(),
+  })
+  .passthrough();
+
+export interface SlackWizardMintResult {
+  wizardId: string;
+  url: string;
+}
+
+export interface SlackWizardPollResult {
+  wizardId: string;
+  teamId: number;
+  slug: string;
+  env: string;
+  status: string;
+  appId?: string;
+  oauthAuthorizeUrl?: string;
+  error?: string;
+  localEnv?: { botToken: string; appToken?: string };
+  localEnvClaimed?: boolean;
+}
+
+export interface SlackWizardMintInput {
+  teamId: number;
+  slug: string;
+  env: SlackAppEnv;
+  envPrefix?: string;
+  name?: string;
+  gitRepoUrl?: string;
+  gitRef?: string;
+  agentPath?: string;
+  channelPosts?: boolean;
+  slackTeamId?: string;
+  iconUrl?: string;
+  force?: boolean;
+}
+
 // ============================================================================
 // Client
 // ============================================================================
@@ -224,6 +284,27 @@ export class AgentServeSlackClient {
     return connectResponseSchema.parse(raw).url;
   }
 
+  async mintWizard(
+    input: SlackWizardMintInput
+  ): Promise<SlackWizardMintResult> {
+    const raw = await this.request({
+      method: "POST",
+      path: "/internal/agent-serve/slack/wizard",
+      body: input,
+      context: { verb: "start Slack setup" },
+    });
+    return mintWizardResponseSchema.parse(raw);
+  }
+
+  async pollWizard(wizardId: string): Promise<SlackWizardPollResult> {
+    const raw = await this.request({
+      method: "GET",
+      path: `/internal/agent-serve/slack/wizard/${encodeURIComponent(wizardId)}`,
+      context: { verb: "poll Slack setup" },
+    });
+    return wizardPollResponseSchema.parse(raw);
+  }
+
   /**
    * Provision (create or update) and install one managed Slack app for
    * (slackTeamId, slug, env). Expected failures throw
@@ -398,8 +479,8 @@ function mapErrorResponse(
           { status: 404 }
         );
       }
-      // The gate-off body is exactly {error: "Not found"}; anything else
-      // (e.g. "App not found" on delete) is a real not-found to surface.
+      // `{ error: "Not found" }` is Agent Serve off (`requireAgentServeAccess`),
+      // not a Slack-only enrollment bar.
       if (serverError !== undefined && serverError !== "Not found") {
         return new SlackProvisionApiError(serverError, {
           status: 404,
@@ -407,7 +488,7 @@ function mapErrorResponse(
         });
       }
       return new SlackProvisionApiError(
-        `Not found — Cursor's "Add to Slack" provisioning (the agent_serve_slack_provisioning feature gate) is not enabled for this account yet.`,
+        `Not found — the agent_serve_mvp feature gate may not be enabled for your team.`,
         { status: 404 }
       );
     }

package/src/storage.ts

@@ -9,9 +9,12 @@
  * The sink is a plain key-value store — put/get/delete/list, no schema —
  * plus a conditional-write group ({@link StorageConfig.cas}, the substrate
  * for framework coordination; optional for plain storage, required by
- * coordination features) and two optional dedicated tables
- * ({@link StorageConfig.evals} and {@link StorageConfig.abs}) for
- * eval-run and A/B history:
+ * coordination features). Implementing that small KV core is enough for
+ * FULL functionality: eval-run and A/B history are derived over the core
+ * when the optional dedicated tables ({@link StorageConfig.evals} and
+ * {@link StorageConfig.abs}) are not authored — those groups exist as
+ * backend-native optimizations (a real table, an analytics pipeline),
+ * not as required-or-lose-history hooks:
  *
  * ```ts
  * import { defineStorage } from "@anysphere/agent-serve/storage";
@@ -207,13 +210,20 @@ export interface StorageConfig {
   /** Timing knobs; see {@link StoragePolicy}. */
   policy?: StoragePolicy;
   /**
-   * Dedicated eval-runs table. Omit it and playground eval history stays
-   * in process memory (lost on restart).
+   * Dedicated eval-runs table — a backend-native optimization, not a
+   * requirement. When omitted, `defineStorage` derives the table over the
+   * KV core (one key per run under `agentkit/v1/{agent}/eval-runs/`),
+   * which needs core `put`, `delete`, and `list`; only when the core
+   * lacks `delete` or `list` does playground eval history stay in process
+   * memory (lost on restart).
    */
   evals?: StorageEvalsTable;
   /**
-   * Dedicated A/B table. Omit it and metric samples are not exported
-   * (session event logs remain the assignment/fold source of truth).
+   * Dedicated A/B table — a backend-native optimization, not a
+   * requirement. When omitted, `defineStorage` derives it over the KV
+   * core: `putSample` and `putSnapshot` need only core `put` (always
+   * present), `getSnapshot` additionally needs core `get`. Session event
+   * logs remain the assignment/fold source of truth either way.
    */
   abs?: StorageABTable;
   /**
@@ -249,7 +259,8 @@ export interface StorageConfig {
   /**
    * All entries under a key prefix, in ascending key order. Optional —
    * required for the **startup bulk restore** (sessions + event streams)
-   * and playground eval history.
+   * and, together with `delete`, for the derived eval-runs table
+   * (playground eval history).
    */
   list?(
     prefix: string,
@@ -326,7 +337,91 @@ export function defineStorage(config: StorageConfig): StorageDefinition {
   }
   // Validate eagerly so a bad policy fails at discovery, not first flush.
   resolveStoragePolicy(config.policy);
-  return brandDefinition("storage", config);
+  // A backend that implements only the KV core gets full functionality:
+  // the dedicated tables are backend-native optimizations, derived over
+  // the core when absent. Authored groups always win.
+  const derivedEvals =
+    config.evals === undefined ? deriveEvalsTable(config) : undefined;
+  const derivedAbs =
+    config.abs === undefined ? deriveAbsTable(config) : undefined;
+  return brandDefinition("storage", {
+    ...config,
+    ...(derivedEvals === undefined ? {} : { evals: derivedEvals }),
+    ...(derivedAbs === undefined ? {} : { abs: derivedAbs }),
+  });
+}
+
+/**
+ * Eval-runs table over the KV core: one key per run under
+ * {@link storageKeys.evalRun}, hydrate via prefix `list`, prune via
+ * `delete`. Requires core `put` + `delete` + `list`; without `delete` or
+ * `list` there is no derivation (pruning or hydration would silently not
+ * work) and eval history stays in process memory.
+ */
+function deriveEvalsTable(
+  config: StorageConfig
+): StorageEvalsTable | undefined {
+  if (config.delete === undefined || config.list === undefined) {
+    return undefined;
+  }
+  return {
+    put: (run, ctx) =>
+      config.put(
+        storageKeys.evalRun(ctx.agentName, run.runId),
+        run as unknown as JsonValue,
+        ctx
+      ),
+    delete: (runId, ctx) =>
+      config.delete?.(storageKeys.evalRun(ctx.agentName, runId), ctx),
+    list: async (ctx) => {
+      const entries =
+        (await config.list?.(storageKeys.evalRunsPrefix(ctx.agentName), ctx)) ??
+        [];
+      return entries.map((entry) => entry.value as unknown as EvalRunSnapshot);
+    },
+  };
+}
+
+/**
+ * A/B table over the KV core. Each sample lands as its own key (identity
+ * = experiment + sessionId + at, matching the dedicated table's row
+ * uniqueness): appending to one array value would need read-modify-write
+ * — lost updates under concurrent writers without CAS, and unbounded
+ * value growth — while a key per sample keeps `putSample` a blind put
+ * with real append-only semantics. The aggregate snapshot lives at one
+ * fixed key via plain `put` (last-write-wins is correct for "latest").
+ * Requires only core `put`; `getSnapshot` is included when core `get`
+ * exists.
+ */
+function deriveAbsTable(config: StorageConfig): StorageABTable {
+  const get = config.get;
+  return {
+    putSample: (sample, ctx) =>
+      config.put(
+        storageKeys.abSample(
+          ctx.agentName,
+          sample.experiment,
+          sample.sessionId,
+          sample.at
+        ),
+        sample as unknown as JsonValue,
+        ctx
+      ),
+    putSnapshot: (snapshot, ctx) =>
+      config.put(
+        storageKeys.abSnapshot(ctx.agentName),
+        snapshot as unknown as JsonValue,
+        ctx
+      ),
+    ...(get === undefined
+      ? {}
+      : {
+          getSnapshot: async (ctx: StorageContext) => {
+            const value = await get(storageKeys.abSnapshot(ctx.agentName), ctx);
+            return (value ?? undefined) as ABSnapshot | undefined;
+          },
+        }),
+  };
 }
 
 // ============================================================================
@@ -357,9 +452,14 @@ export const STORAGE_KEY_ROOT = "agentkit/v1" as const;
  * | `agentkit/v1/{agent}/session-events/{sessionId}/{index}` | `SessionEvent[]` chunk (index = first event's index, zero-padded) |
  * | `agentkit/v1/{agent}/continuation/{channelId}/{token}` | `{ sessionId }` |
  * | `agentkit/v1/{agent}/kv/{key}` | Author JSON via {@link HostContext.kv} |
+ * | `agentkit/v1/{agent}/eval-runs/{runId}` | `EvalRunSnapshot` (derived `evals` table) |
+ * | `agentkit/v1/{agent}/ab-samples/{experiment}/{sessionId}/{at}` | `ABMetricSample` (derived `abs` table, append-only) |
+ * | `agentkit/v1/{agent}/ab-snapshot` | `ABSnapshot` (derived `abs` table, LWW) |
  *
- * Eval-run and A/B history do not flow through this KV scheme — they have
- * dedicated tables ({@link StorageConfig.evals} / {@link StorageConfig.abs}).
+ * The `eval-runs` / `ab-samples` / `ab-snapshot` families are minted only
+ * by the tables `defineStorage` derives over the KV core; a backend that
+ * authors dedicated {@link StorageConfig.evals} / {@link StorageConfig.abs}
+ * groups never sees them.
  */
 export const storageKeys = {
   session: (agent: string, sessionId: string): string =>
@@ -387,6 +487,25 @@ export const storageKeys = {
   kv: (agent: string, key: string): string =>
     `${STORAGE_KEY_ROOT}/${agent}/kv/${keySegment(key)}`,
   kvPrefix: (agent: string): string => `${STORAGE_KEY_ROOT}/${agent}/kv/`,
+  /** One playground eval-run snapshot (derived `evals` table). */
+  evalRun: (agent: string, runId: string): string =>
+    `${STORAGE_KEY_ROOT}/${agent}/eval-runs/${keySegment(runId)}`,
+  evalRunsPrefix: (agent: string): string =>
+    `${STORAGE_KEY_ROOT}/${agent}/eval-runs/`,
+  /**
+   * One A/B metric sample (derived `abs` table); the segments mirror the
+   * dedicated table's row identity (experiment + sessionId + at).
+   */
+  abSample: (
+    agent: string,
+    experiment: string,
+    sessionId: string,
+    at: string
+  ): string =>
+    `${STORAGE_KEY_ROOT}/${agent}/ab-samples/${keySegment(experiment)}/${keySegment(sessionId)}/${keySegment(at)}`,
+  /** Latest aggregate A/B snapshot (derived `abs` table, LWW). */
+  abSnapshot: (agent: string): string =>
+    `${STORAGE_KEY_ROOT}/${agent}/ab-snapshot`,
 } as const;
 
 /**