@cursor/july 0.1.107 → 0.1.109

package/src/internal/discovery/extension-overlay.ts

@@ -6,7 +6,6 @@
 import { join } from "node:path";
 import type {
   ArtifactsDefinition,
-  DiscoveredAB,
   DiscoveredChannel,
   DiscoveredHook,
   DiscoveredSchedule,
@@ -14,7 +13,6 @@ import type {
   ResolvedAgent,
 } from "../../types.js";
 import { getDefinitionKind } from "../brand.js";
-import { loadABs } from "./ab.js";
 import { loadChannels } from "./channels.js";
 import { type DiscoveryContext, displayPath, errorMessage } from "./context.js";
 import {
@@ -202,22 +200,6 @@ export async function overlayInstructionsFragment(
   return loadInstructions(ctx, overlayDir, undefined, false);
 }
 
-export async function overlayAbs(
-  ctx: DiscoveryContext,
-  site: OverlaySite,
-  contributed: Map<string, DiscoveredAB>,
-  overlayDir: string
-): Promise<void> {
-  const loaded = await loadABs(ctx, overlayDir, (source, path) => {
-    if (!contributed.delete(source)) {
-      unknownContribution(ctx, path, "disableAB", source, site.ns);
-    }
-  });
-  for (const experiment of loaded) {
-    contributed.set(experiment.source ?? experiment.name, experiment);
-  }
-}
-
 export async function overlayArtifacts(
   ctx: DiscoveryContext,
   overlayDir: string,

package/src/internal/discovery/extensions.ts

@@ -8,7 +8,6 @@ import { join, resolve } from "node:path";
 import type {
   ArtifactsDefinition,
   ConnectionDefinition,
-  DiscoveredAB,
   DiscoveredChannel,
   DiscoveredConnection,
   DiscoveredExtension,
@@ -22,7 +21,6 @@ import type {
   ToolDefinition,
 } from "../../types.js";
 import { buildIdentityPreamble, withIdentityPreamble } from "../workspace.js";
-import { loadABs } from "./ab.js";
 import { loadChannels } from "./channels.js";
 import {
   compileConnection,
@@ -33,7 +31,6 @@ import {
 import { type DiscoveryContext, displayPath } from "./context.js";
 import { type CursorPluginAgent, readCursorPlugin } from "./cursor-plugin.js";
 import {
-  overlayAbs,
   overlayArtifacts,
   overlayChannels,
   overlayHooks,
@@ -74,7 +71,6 @@ export interface ExtensionContributions {
   schedules: DiscoveredSchedule[];
   instructionParts: string[];
   seedFiles: SeedFile[];
-  abs: DiscoveredAB[];
   artifacts: ArtifactsDefinition | undefined;
 }
 
@@ -171,7 +167,6 @@ interface ExtensionTree {
   schedules: DiscoveredSchedule[];
   instructions?: string;
   seedFiles: SeedFile[];
-  abs: DiscoveredAB[];
   artifacts?: ArtifactsDefinition;
 }
 
@@ -192,7 +187,6 @@ function emptyDiscovered(
     schedules: [],
     instructions: false,
     seedFiles: [],
-    abs: [],
     artifactKinds: [],
   };
 }
@@ -242,7 +236,6 @@ async function mountExtension(
   const seedFiles = new Map(
     tree.seedFiles.map((seed) => [seed.relativePath, seed])
   );
-  const abs = byAbSource(tree.abs);
   let artifacts = tree.artifacts;
   let instructions = tree.instructions;
 
@@ -333,7 +326,6 @@ async function mountExtension(
     for (const seed of await loadSeedFiles(ctx, site.overlayDir)) {
       seedFiles.set(seed.relativePath, seed);
     }
-    await overlayAbs(ctx, site, abs, site.overlayDir);
     artifacts = await overlayArtifacts(ctx, site.overlayDir, artifacts);
   }
 
@@ -407,14 +399,6 @@ async function mountExtension(
     into.seedFiles.push(seed);
     mounted.seedFiles.push(seed.relativePath);
   }
-  for (const experiment of abs.values()) {
-    const composed = `${site.ns}__${experiment.name}`;
-    into.abs.push({
-      name: composed,
-      definition: experiment.definition,
-    });
-    mounted.abs.push(composed);
-  }
   if (artifacts !== undefined) {
     const kinds: NonNullable<ArtifactsDefinition["kinds"]> = {};
     for (const [kind, config] of Object.entries(artifacts.kinds ?? {})) {
@@ -464,7 +448,6 @@ async function readExtensionTree(
       channels: [],
       schedules: [],
       seedFiles: [],
-      abs: [],
     };
   }
   return readNativeTree(ctx, root);
@@ -490,7 +473,6 @@ async function readNativeTree(
     schedules: await loadSchedules(ctx, join(root, "schedules")),
     instructions: await loadInstructions(ctx, root, undefined, false),
     seedFiles: await loadSeedFiles(ctx, root),
-    abs: await loadABs(ctx, root),
     artifacts: await loadArtifacts(ctx, root),
   };
 }
@@ -519,19 +501,14 @@ function byName<T extends { name: string }>(items: T[]): Map<string, T> {
   return new Map(items.map((item) => [item.name, item]));
 }
 
-function byAbSource(items: DiscoveredAB[]): Map<string, DiscoveredAB> {
-  return new Map(items.map((item) => [item.source ?? item.name, item]));
-}
-
 function byId<T extends { id: string }>(items: T[]): Map<string, T> {
   return new Map(items.map((item) => [item.id, item]));
 }
 
 /**
  * Agent-singleton slots: one runtime (`agent.ts`), one storage backend,
- * one OTLP exporter, one A/B platform config. Playground chips are a
- * Vite glob of the agent tree, not a discovery walk. Nested
- * `extensions/` are not mounted.
+ * one OTLP exporter. Playground chips are a Vite glob of the agent tree,
+ * not a discovery walk. Nested `extensions/` are not mounted.
  */
 async function warnAgentRootOnlySlots(
   ctx: DiscoveryContext,
@@ -541,7 +518,6 @@ async function warnAgentRootOnlySlots(
     ["agent.ts", "agent.ts"],
     ["storage.ts", "storage"],
     ["otel.ts", "otel"],
-    ["ab.config.ts", "A/B config"],
   ] as const;
   for (const [file, label] of files) {
     const path = join(root, file);

package/src/internal/discovery/info.ts

@@ -2,7 +2,6 @@
  * The `info` / `GET /v1/info` projection of an {@link AgentProject}.
  */
 
-import { resolveABMaxPlaygroundSessions } from "../../ab.js";
 import { resolveArtifactsMax } from "../../artifacts.js";
 import {
   type AgentProject,
@@ -140,6 +139,9 @@ export function projectInfo(project: AgentProject): AgentProjectInfo {
         if (meta?.factoryEventTypes !== undefined) {
           info.factoryEventTypes = meta.factoryEventTypes;
         }
+        if (meta?.slackEventTypes !== undefined) {
+          info.slackEventTypes = meta.slackEventTypes;
+        }
         if (meta?.slackChannelPosts !== undefined) {
           info.slackChannelPosts = meta.slackChannelPosts;
         }
@@ -158,18 +160,6 @@ export function projectInfo(project: AgentProject): AgentProjectInfo {
             name: reminder.name,
           })),
     hooks: project.hooks.map((hook) => hook.name),
-    abs: project.abs.map((experiment) => experiment.name),
-    ...(project.abConfig === undefined && project.abs.length === 0
-      ? {}
-      : {
-          abConfig: {
-            maxPlaygroundSessions: resolveABMaxPlaygroundSessions(
-              project.abConfig?.maxPlaygroundSessions
-            ),
-            durableSamples: project.storage?.abs !== undefined,
-            durableSnapshots: project.storage?.abs?.putSnapshot !== undefined,
-          },
-        }),
     storage:
       project.storage === undefined
         ? undefined

package/src/internal/discovery/modules.ts

@@ -103,7 +103,6 @@ const DEFINE_HELPER_NAME: Record<ImportableKind, string> = {
   schedule: "defineSchedule",
   reminder: "defineReminder",
   hook: "defineHook",
-  ab: "defineAB",
   storage: "defineStorage",
   artifacts: "defineArtifacts",
   otel: "defineOtel",

package/src/internal/discovery/project.ts

@@ -14,7 +14,6 @@ import {
   applyAgentContinuationDefaults,
   warnOmittedContinuationDowngrades,
 } from "../continuation-channel.js";
-import { loadABConfig, loadABs } from "./ab.js";
 import { loadAgent, warnUnknownSlots } from "./agent.js";
 import { loadChannels } from "./channels.js";
 import {
@@ -240,19 +239,6 @@ export async function loadAgentProject(
   const reminders = await loadReminders(ctx, join(agentDir, "reminders"));
   const hooks = await loadHooks(ctx, join(agentDir, "hooks"));
   hooks.push(...projectSlots.hooks);
-  const abs = await loadABs(ctx, agentDir);
-  for (const experiment of projectSlots.abs) {
-    if (abs.some((existing) => existing.name === experiment.name)) {
-      ctx.diagnostics.push({
-        severity: "error",
-        path: displayPath(ctx, join(agentDir, "extensions")),
-        message: `Extension A/B experiment "${experiment.name}" collides with an agent experiment.`,
-      });
-      continue;
-    }
-    abs.push(experiment);
-  }
-  const abConfig = await loadABConfig(ctx, agentDir);
   const storage = await loadStorage(ctx, agentDir, agent.architecture);
   const artifacts = await mergeProjectArtifacts(
     ctx,
@@ -295,8 +281,6 @@ export async function loadAgentProject(
     schedules,
     reminders,
     hooks,
-    abs,
-    abConfig,
     storage,
     artifacts,
     result,

package/src/internal/eval-runner.ts

@@ -633,7 +633,6 @@ async function runOneEval(
         sessionId,
         continuationToken,
         startIndex: nextEventIndex,
-        // Keep defineEval traffic out of live defineAB enrollment/metrics.
         purpose: "eval",
         bearerToken: opts.bearerToken,
         headers: opts.headers,

package/src/internal/framework-file-storage.ts

@@ -21,9 +21,8 @@
  * `continuation` go to the framework file store (file-shaped; the store
  * accepts values up to 64 MiB per
  * object without chunking, versus the KV proxy's 1 MiB row cap), while
- * author `kv`, eval runs, A/B samples, and conditional writes stay on the
- * control-plane KV proxy (the dashboard reads them there, and CAS needs a
- * database).
+ * author `kv`, eval runs, and conditional writes stay on the control-plane
+ * KV proxy (the dashboard reads them there, and CAS needs a database).
  *
  * v2 only, by construction: the composite is selected in
  * framework-storage-selection.ts, which v1 never reaches with a
@@ -202,8 +201,8 @@ function decodeDocument(key: string, bytes: Uint8Array): JsonValue {
 /**
  * Split one storage core by key kind: framework session state to `files`,
  * everything else to `kv`. Spread over the KV backend when building the
- * full definition so its `evals` / `abs` groups (and the cursor-hosted
- * marker) ride along untouched; wrap the KV `cas` group with
+ * full definition so its `evals` group (and the cursor-hosted marker)
+ * rides along untouched; wrap the KV `cas` group with
  * {@link frameworkGuardedCas} rather than spreading it as-is.
  */
 export function composeFrameworkStorage(input: {

package/src/internal/framework-storage-selection.ts

@@ -24,8 +24,8 @@
  *   (`AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID`, bound at task time) holds
  *   session records, event transcripts, and the continuation index —
  *   file-shaped state on file storage, apart from the author-facing user
- *   store. Author `host.kv`, eval runs, A/B samples, and conditional writes
- *   ride the AgentSDK v2 KV proxy (cursor-hosted-v2.ts), which resolves the
+ *   store. Author `host.kv`, eval runs, and conditional writes ride the
+ *   AgentSDK v2 KV proxy (cursor-hosted-v2.ts), which resolves the
  *   pod service account to the factorydb deployment row (the v1 Bugbot
  *   proxy cannot resolve v2 pods at all). Framework session state never
  *   routes to the KV proxy — the composite splits by key kind — so

package/src/internal/guest-network.ts

@@ -12,11 +12,9 @@
  * so leftover races still return 503 `guest_network_unavailable` instead of
  * a redacted 500.
  *
- * Quiet guest Connect (`TypeError: fetch failed` with no errno, Connect
- * `[unknown]`/`[canceled]`/`[unavailable]`, headers/body timeout) is a
- * stall, not a dead NIC. Those become `guest_connect_stalled` so TAS
- * retries the same pod — including when `waitForCompletion` resolves
- * with that message instead of throwing.
+ * Quiet guest Connect failures with a typed Connect/undici code are stalls,
+ * not dead NICs. Those become `guest_connect_stalled` so TAS retries the same
+ * pod. Untyped errors stay unknown rather than being classified from prose.
  */
 
 import { HOSTED_GUEST_RETRY_TRANSIENT } from "./hosted-delivery-protocol.js";
@@ -71,11 +69,16 @@ export class GuestNetworkUnavailableError extends Error {
   }
 }
 
+class GuestNetworkProbeFailedError extends Error {
+  constructor(cause: unknown) {
+    super("Guest network probe failed", { cause });
+    this.name = "GuestNetworkProbeFailedError";
+  }
+}
+
 /**
  * True when the error (or anything on its `cause` chain, or inside an
- * `AggregateError`) is a network-level fetch failure. Connect-web wraps
- * undici's `TypeError: fetch failed` as `ConnectError` and keeps the
- * original on `cause`.
+ * `AggregateError`) carries a known network-level code.
  */
 export function isTransientGuestNetworkError(error: unknown): boolean {
   return isTransientAtDepth(error, 0);
@@ -91,9 +94,8 @@ const QUIET_CONNECT_ERROR_CODES: ReadonlySet<string> = new Set([
   "UND_ERR_BODY_TIMEOUT",
   "UND_ERR_HEADERS_TIMEOUT",
 ]);
-
-const QUIET_CONNECT_MESSAGE =
-  /^(?:\[(?:unknown|canceled|unavailable)\])|connection stalled|this operation was aborted/i;
+// gRPC Canceled, Unknown, and Unavailable.
+const QUIET_CONNECT_CODES: ReadonlySet<number> = new Set([1, 2, 14]);
 
 export function hasGuestNetworkErrno(error: unknown): boolean {
   return hasCodeAtDepth(error, 0, TRANSIENT_NETWORK_ERROR_CODES);
@@ -115,16 +117,16 @@ export function isQuietGuestConnectStall(error: unknown): boolean {
   return isQuietSignatureAtDepth(error, 0);
 }
 
-/** Message-only form for `waitForCompletion` outcomes that do not throw. */
-export function isQuietGuestConnectStallMessage(message: string): boolean {
-  return QUIET_CONNECT_MESSAGE.test(message);
-}
-
 function errorCode(error: Error): string | undefined {
   const code = (error as NodeJS.ErrnoException).code;
   return typeof code === "string" && code.length > 0 ? code : undefined;
 }
 
+function numericErrorCode(error: Error): number | undefined {
+  const code = (error as { code?: unknown }).code;
+  return typeof code === "number" ? code : undefined;
+}
+
 function hasCodeAtDepth(
   error: unknown,
   depth: number,
@@ -150,14 +152,15 @@ function isQuietSignatureAtDepth(error: unknown, depth: number): boolean {
   if (depth >= MAX_CAUSE_DEPTH || !(error instanceof Error)) {
     return false;
   }
-  if (error instanceof TypeError && error.message === "fetch failed") {
+  if (error.name === "AbortError") {
     return true;
   }
-  const code = errorCode(error);
-  if (code !== undefined && QUIET_CONNECT_ERROR_CODES.has(code)) {
+  const numericCode = numericErrorCode(error);
+  if (numericCode !== undefined && QUIET_CONNECT_CODES.has(numericCode)) {
     return true;
   }
-  if (QUIET_CONNECT_MESSAGE.test(error.message)) {
+  const code = errorCode(error);
+  if (code !== undefined && QUIET_CONNECT_ERROR_CODES.has(code)) {
     return true;
   }
   if (
@@ -173,10 +176,17 @@ function isTransientAtDepth(error: unknown, depth: number): boolean {
   if (depth >= MAX_CAUSE_DEPTH || !(error instanceof Error)) {
     return false;
   }
-  if (error instanceof TypeError && error.message === "fetch failed") {
+  if (error instanceof GuestNetworkUnavailableError) {
     return true;
   }
-  if (error instanceof GuestNetworkUnavailableError) {
+  if (error instanceof GuestNetworkProbeFailedError) {
+    return true;
+  }
+  if (error.name === "AbortError") {
+    return true;
+  }
+  const numericCode = numericErrorCode(error);
+  if (numericCode !== undefined && QUIET_CONNECT_CODES.has(numericCode)) {
     return true;
   }
   const code = errorCode(error);
@@ -249,13 +259,17 @@ async function defaultProbe(
   probeUrl: string,
   probeTimeoutMs: number
 ): Promise<void> {
-  // Any HTTP response means egress and DNS work. 401/404 are ready.
-  const response = await fetch(probeUrl, {
-    method: "GET",
-    redirect: "manual",
-    signal: AbortSignal.timeout(probeTimeoutMs),
-  });
-  void response.body?.cancel();
+  try {
+    // Any HTTP response means egress and DNS work. 401/404 are ready.
+    const response = await fetch(probeUrl, {
+      method: "GET",
+      redirect: "manual",
+      signal: AbortSignal.timeout(probeTimeoutMs),
+    });
+    void response.body?.cancel();
+  } catch (error) {
+    throw new GuestNetworkProbeFailedError(error);
+  }
 }
 
 export type GuestNetworkWaitOutcome = "ready" | "skipped" | "unavailable";

package/src/internal/hosted-admission-adapter.ts

@@ -19,6 +19,8 @@ export type HostedAdmissionAdapter = {
    */
   prepareArgs?(args: ChannelHandlerArgs): ChannelHandlerArgs;
   dispatch(input: {
+    /** Mounted channel id the delivery addressed (always set by hosted delivery). */
+    channelId?: string;
     eventType: string;
     payload: unknown;
     deliveryId: string;

package/src/internal/hosted-catch-protocol.ts

@@ -0,0 +1,130 @@
+/**
+ * Catch ingress wire contract, July copy. The control plane keeps a
+ * byte-identical copy of these constants in
+ * `backend/packages/server-shared/src/agentServe/agentSdkCatch.ts`; a
+ * backend drift test compares the two as text. Neither package imports the
+ * other.
+ *
+ * A caught request is one hosted admission whose `eventType` is
+ * {@link AGENT_SDK_CATCH_EVENT_TYPE} and whose `payload` is a
+ * {@link CatchRequestEnvelope}: the HTTP request the control plane
+ * accepted on a manifest-declared route after verifying the deployment's
+ * secret. July replays it into the authored route handler; the control
+ * plane never runs channel code.
+ */
+
+export const AGENT_SDK_CATCH_ENVELOPE_VERSION = 1;
+export const AGENT_SDK_CATCH_EVENT_TYPE = "http.request";
+export const AGENT_SDK_CUSTOM_CHANNEL_KIND = "custom";
+export const AGENT_SDK_SESSION_EVENT_TYPE = "agentsdk.session";
+export const AGENT_SDK_HTTP_CHANNEL_ID = "http";
+export const AGENT_SDK_HTTP_CHANNEL_KIND = "http";
+export const AGENT_SDK_SESSION_RESUME_KEY_PREFIX = "cont:session:";
+export const AGENT_SDK_CATCH_MAX_BODY_BYTES: number = 256 * 1024;
+
+export const AGENT_SDK_CATCH_ROUTE_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+] as const;
+export type CatchRouteMethod = (typeof AGENT_SDK_CATCH_ROUTE_METHODS)[number];
+
+export type CatchRequestEnvelope = {
+  v: 1;
+  method: CatchRouteMethod;
+  /** Channel-relative path, e.g. `/webhook`. */
+  path: string;
+  /** Raw query string without the leading `?`; empty when absent. */
+  query: string;
+  /** Lowercased header names. */
+  headers: Record<string, string>;
+  body: { encoding: "utf8" | "base64"; data: string } | null;
+  receivedAt: string;
+};
+
+/**
+ * Mailbox key the control plane stamps on an explicit `ses_…` resume. The
+ * suffix is the CP session id the hosted execution also names, so the
+ * engine can recognise the key as "this existing session" rather than a
+ * new continuation identity.
+ */
+export function hostedSessionResumeKey(sessionPublicId: string): string {
+  return `${AGENT_SDK_SESSION_RESUME_KEY_PREFIX}${sessionPublicId}`;
+}
+
+const ENVELOPE_KEYS = new Set([
+  "v",
+  "method",
+  "path",
+  "query",
+  "headers",
+  "body",
+  "receivedAt",
+]);
+const METHODS = new Set<string>(AGENT_SDK_CATCH_ROUTE_METHODS);
+const MAX_PATH_CHARS = 1024;
+const MAX_QUERY_CHARS = 4096;
+const MAX_HEADER_COUNT = 64;
+const MAX_HEADER_BYTES = 16 * 1024;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Strict parse of a claim-checked catch envelope; anything else is undefined. */
+export function parseCatchRequestEnvelope(
+  value: unknown
+): CatchRequestEnvelope | undefined {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+  if (
+    Object.keys(value).some((key) => !ENVELOPE_KEYS.has(key)) ||
+    value.v !== AGENT_SDK_CATCH_ENVELOPE_VERSION ||
+    typeof value.method !== "string" ||
+    !METHODS.has(value.method) ||
+    typeof value.path !== "string" ||
+    !value.path.startsWith("/") ||
+    value.path.length > MAX_PATH_CHARS ||
+    typeof value.query !== "string" ||
+    value.query.length > MAX_QUERY_CHARS ||
+    typeof value.receivedAt !== "string" ||
+    !isRecord(value.headers)
+  ) {
+    return undefined;
+  }
+  const entries = Object.entries(value.headers);
+  if (entries.length > MAX_HEADER_COUNT) {
+    return undefined;
+  }
+  let headerBytes = 0;
+  for (const [name, headerValue] of entries) {
+    if (typeof headerValue !== "string" || name !== name.toLowerCase()) {
+      return undefined;
+    }
+    headerBytes += name.length + headerValue.length;
+  }
+  if (headerBytes > MAX_HEADER_BYTES) {
+    return undefined;
+  }
+  if (value.body !== null) {
+    if (
+      !isRecord(value.body) ||
+      (value.body.encoding !== "utf8" && value.body.encoding !== "base64") ||
+      typeof value.body.data !== "string"
+    ) {
+      return undefined;
+    }
+  }
+  return value as CatchRequestEnvelope;
+}
+
+/** Raw request bytes from an envelope body; empty for a null body. */
+export function decodeCatchBody(body: CatchRequestEnvelope["body"]): Buffer {
+  if (body === null) {
+    return Buffer.alloc(0);
+  }
+  return Buffer.from(body.data, body.encoding);
+}