@cursor/july 0.1.108 → 0.1.111

package/src/internal/otel/runtime.ts

@@ -150,7 +150,7 @@ export async function raceOtelForceFlush(
   timeoutMs: number = OTEL_FORCE_FLUSH_TIMEOUT_MS
 ): Promise<void> {
   let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<"timeout">((resolve) => {
+  const timeout = new Promise<"timeout">(resolve => {
     timer = setTimeout(() => resolve("timeout"), timeoutMs);
   });
   const result = await Promise.race([
@@ -175,11 +175,11 @@ function startOtelSdk(
 } {
   diag.setLogger(
     {
-      verbose: (m) => logger(`[agent-sdk:otel] ${m}`),
-      debug: (m) => logger(`[agent-sdk:otel] ${m}`),
-      info: (m) => logger(`[agent-sdk:otel] ${m}`),
-      warn: (m) => logger(`[agent-sdk:otel] warn: ${m}`),
-      error: (m) => logger(`[agent-sdk:otel] error: ${m}`),
+      verbose: m => logger(`[agent-sdk:otel] ${m}`),
+      debug: m => logger(`[agent-sdk:otel] ${m}`),
+      info: m => logger(`[agent-sdk:otel] ${m}`),
+      warn: m => logger(`[agent-sdk:otel] warn: ${m}`),
+      error: m => logger(`[agent-sdk:otel] error: ${m}`),
     },
     DiagLogLevel.ERROR
   );
@@ -232,7 +232,7 @@ function startOtelSdk(
       const provider = new MeterProvider({
         resource,
         readers: exporters.map(
-          (exporter) =>
+          exporter =>
             new PeriodicExportingMetricReader({
               exporter: createMetricExporter(
                 exporter,
@@ -259,7 +259,7 @@ function startOtelSdk(
       const provider = new LoggerProvider({
         resource,
         processors: exporters.map(
-          (exporter) =>
+          exporter =>
             new BatchLogRecordProcessor(
               createLogExporter(exporter, signalUrl(exporter.url, "logs"))
             )
@@ -363,22 +363,22 @@ async function exportQueuedSpans(
   logger: (line: string) => void,
   resource: Resource
 ): Promise<boolean> {
-  const payload = spans.map((span) => withExportResource(span, resource));
-  const exporters: SpanExporter[] = destinations.map((destination) =>
+  const payload = spans.map(span => withExportResource(span, resource));
+  const exporters: SpanExporter[] = destinations.map(destination =>
     createTraceExporter(destination, signalUrl(destination.url, "traces"))
   );
   try {
     const results = await Promise.all(
       exporters.map(
-        (exporter) =>
-          new Promise<boolean>((resolve) => {
+        exporter =>
+          new Promise<boolean>(resolve => {
             exporter.export(payload, (result: ExportResult) => {
               resolve(result.code === ExportResultCode.SUCCESS);
             });
           })
       )
     );
-    return results.every((ok) => ok);
+    return results.every(ok => ok);
   } catch (error) {
     logger(
       `[agent-sdk:otel] deferred export failed: ${
@@ -387,7 +387,7 @@ async function exportQueuedSpans(
     );
     return false;
   } finally {
-    await Promise.allSettled(exporters.map((exporter) => exporter.shutdown()));
+    await Promise.allSettled(exporters.map(exporter => exporter.shutdown()));
   }
 }
 

package/src/internal/peer-connections.ts

@@ -32,7 +32,7 @@ export function collectPeerConnections(
   mounts: Array<{ slug: string; project: AgentProject }>
 ): Map<string, PeerConnectionRef[]> {
   const knownSlugs = new Set(
-    mounts.map(({ slug }) => slug).filter((slug) => slug !== "")
+    mounts.map(({ slug }) => slug).filter(slug => slug !== "")
   );
   const bySlug = new Map<string, PeerConnectionRef[]>();
   for (const { slug, project } of mounts) {
@@ -88,7 +88,7 @@ export function resolvePeerConnections(args: {
     args.authToken === undefined
       ? undefined
       : { authorization: `Bearer ${args.authToken}` };
-  return args.refs.map((ref) => ({
+  return args.refs.map(ref => ({
     name: ref.name,
     localUrl: `${serverBase}/${ref.targetSlug}${MCP_ENDPOINT_PATH}`,
     ...(publicBase === undefined

package/src/internal/platform-schedule-sync.ts

@@ -19,7 +19,7 @@ export async function syncHostedPlatformSchedules(args: {
   logger: (line: string) => void;
 }): Promise<void> {
   const previous = await readScheduleCatalog(args.catalogPath);
-  const currentNames = args.schedules.map((schedule) => schedule.name);
+  const currentNames = args.schedules.map(schedule => schedule.name);
   const currentSet = new Set(currentNames);
 
   const failedDeletes: string[] = [];

package/src/internal/platform-timers.ts

@@ -193,7 +193,7 @@ const APPLY_REMINDER_OUTCOME_MAX_ATTEMPTS = 3;
 const APPLY_REMINDER_OUTCOME_RETRY_DELAY_MS = 50;
 
 async function sleepMs(ms: number): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, ms));
+  await new Promise(resolve => setTimeout(resolve, ms));
 }
 
 async function withBoundedApplyRetries<T>(run: () => Promise<T>): Promise<T> {

package/src/internal/playground/static.ts

@@ -126,7 +126,7 @@ export function renderAgentsIndexHtml(
   const docs = options.docs !== false;
   const multi = options.multi === true;
   const cards = agents
-    .map((agent) => {
+    .map(agent => {
       const playground =
         agent.slug === "" ? "/playground" : `/${agent.slug}/playground`;
       const slugLabel = agent.slug === "" ? "/" : `/${agent.slug}`;
@@ -143,7 +143,7 @@ export function renderAgentsIndexHtml(
 
   const routes = hostRouteRows(agents, docs, multi)
     .map(
-      (row) =>
+      row =>
         `        <tr><td><a href="${escapeHtml(row.href)}"><code>${escapeHtml(row.path)}</code></a></td><td>${escapeHtml(row.blurb)}</td></tr>`
     )
     .join("\n");

package/src/internal/playground/toolchain.ts

@@ -220,7 +220,7 @@ export function startPlaygroundDevServer(options: {
   });
 
   let stopped = false;
-  child.on("error", (err) => {
+  child.on("error", err => {
     if (stopped) {
       return;
     }
@@ -272,7 +272,7 @@ function spawnVite(
       stdio: "inherit",
     });
     child.on("error", reject);
-    child.on("exit", (code) => {
+    child.on("exit", code => {
       resolve(code ?? 1);
     });
   });

package/src/internal/playground-proxy.ts

@@ -199,7 +199,7 @@ export async function startPlaygroundProxy(
         // Drop keep-alive / streamed playground connections so Ctrl-C
         // does not hang waiting for active sockets.
         server.closeAllConnections();
-        server.close((error) => {
+        server.close(error => {
           if (error) {
             reject(error);
             return;
@@ -484,7 +484,7 @@ async function forwardOnce(args: {
   };
 
   return await new Promise<number>((resolve, reject) => {
-    const upstreamReq = requestFn(options, (upstreamRes) => {
+    const upstreamReq = requestFn(options, upstreamRes => {
       const status = upstreamRes.statusCode ?? 502;
       if (status === 401 && args.deferWriteOnUnauthorized) {
         // Drain so the socket can be reused; caller will refresh + retry.
@@ -511,7 +511,7 @@ async function forwardOnce(args: {
       });
     });
 
-    upstreamReq.on("error", (error) => {
+    upstreamReq.on("error", error => {
       reject(error);
     });
 

package/src/internal/process-memory-telemetry.ts

@@ -207,7 +207,7 @@ export function buildDatadogGaugeSeries(args: {
       value: args.eventLog.residentSessions,
     },
   ];
-  return points.map((point) => ({
+  return points.map(point => ({
     metric: point.name,
     type: "gauge",
     points: [[args.timestampSec, point.value]],

package/src/internal/reminder-runner.ts

@@ -287,9 +287,7 @@ export class ReminderRunner {
     if (this.platformTimers !== undefined) {
       return;
     }
-    const armed = [...this.records.values()].filter(
-      (r) => r.status === "armed"
-    );
+    const armed = [...this.records.values()].filter(r => r.status === "armed");
     let restored = 0;
     let disarmedOrphan = 0;
     for (const record of armed) {
@@ -544,7 +542,7 @@ export class ReminderRunner {
   }): Promise<ReminderInfo[]> {
     const all = await this.allRecords();
     return all
-      .filter((r) => {
+      .filter(r => {
         if (filter?.status !== undefined) {
           const publicStatus = r.status === "firing" ? "armed" : r.status;
           if (publicStatus !== filter.status) {
@@ -562,7 +560,7 @@ export class ReminderRunner {
         }
         return true;
       })
-      .map((r) => {
+      .map(r => {
         const live = this.handlers.get(r.id);
         const info = toInfo(r);
         if (live === undefined) return info;
@@ -614,7 +612,7 @@ export class ReminderRunner {
     continuationToken: string,
     reason: string
   ): Promise<number> {
-    const armed = (await this.allRecords()).filter((r) => r.status === "armed");
+    const armed = (await this.allRecords()).filter(r => r.status === "armed");
     let n = 0;
     for (const record of armed) {
       if (record.continuationToken === continuationToken) {
@@ -640,7 +638,7 @@ export class ReminderRunner {
       return this.controlPlane!.rekeyReminders(channelId, oldToken, newToken);
     }
     const armed = (await this.allRecords()).filter(
-      (r) => r.status === "armed" || r.status === "firing"
+      r => r.status === "armed" || r.status === "firing"
     );
     let n = 0;
     for (const record of armed) {
@@ -672,7 +670,7 @@ export class ReminderRunner {
   }> {
     const record = await this.getRecord(reminderId);
     if (record === undefined) {
-      const ids = (await this.allRecords()).map((r) => r.id);
+      const ids = (await this.allRecords()).map(r => r.id);
       throw new UnknownReminderError(reminderId, ids);
     }
     if (
@@ -815,7 +813,7 @@ export class ReminderRunner {
       Math.max(0, nextFireAtMs - Date.now())
     );
     const timer = setTimeout(() => {
-      void this.fire(record.id).catch(async (error) => {
+      void this.fire(record.id).catch(async error => {
         this.logger(
           `[agent-sdk] reminder "${record.id}" fire failed: ${
             error instanceof Error ? error.message : String(error)
@@ -1082,7 +1080,7 @@ export class ReminderRunner {
       channelId === HTTP_CHANNEL_ID
         ? httpContinuationIdentity(project.httpChannel)
         : channelContinuationIdentity(
-            project.channels.find((channel) => channel.id === channelId)
+            project.channels.find(channel => channel.id === channelId)
               ?.definition
           );
     return continuationSource(identity) === "control-plane";

package/src/internal/reminder-store.ts

@@ -140,7 +140,7 @@ export class ReminderStore {
   async listArmed(): Promise<ReminderRecord[]> {
     const all = await this.list();
     // Treat in-flight claims as still armed for restart / listing purposes.
-    return all.filter((r) => r.status === "armed" || r.status === "firing");
+    return all.filter(r => r.status === "armed" || r.status === "firing");
   }
 
   async get(id: string): Promise<ReminderRecord | undefined> {

package/src/internal/request-error-status.ts

@@ -1,3 +1,4 @@
+import { HttpSessionAdmitError } from "../types.js";
 import { InvalidAsOfError, VacuousTimeArgsError } from "./as-of.js";
 import { V2EngineError } from "./continuation-identity.js";
 import {
@@ -52,6 +53,14 @@ export function mapThrownRequestError(
       retry: HOSTED_GUEST_RETRY_TERMINAL,
     };
   }
+  if (error instanceof HttpSessionAdmitError) {
+    return {
+      status: 400,
+      code: "invalid_request",
+      message: error.message,
+      retry: HOSTED_GUEST_RETRY_TERMINAL,
+    };
+  }
   if (
     error instanceof InvalidAsOfError ||
     error instanceof VacuousTimeArgsError

package/src/internal/resolved-connections.ts

@@ -48,18 +48,18 @@ export function validateMountConnectionsConfig(args: {
   const label = args.slug === "" ? args.project.name : args.slug;
   const hostConnectionNames = new Set(
     (args.project.agent.hostConnections ?? []).map(
-      (connection) => connection.name
+      connection => connection.name
     )
   );
   const filteredRefs = args.accountRefs.filter(
-    (ref) => ref.servers !== undefined && !hostConnectionNames.has(ref.name)
+    ref => ref.servers !== undefined && !hostConnectionNames.has(ref.name)
   );
   if (filteredRefs.length === 0) {
     return;
   }
   throw new Error(
     `[agent-sdk] agent "${label}" has Cursor account MCP connections with \`servers\` filters (${filteredRefs
-      .map((ref) => ref.name)
+      .map(ref => ref.name)
       .join(
         ", "
       )}) but no --public-url; cloud-runtime turns cannot honor those filters without a public bridge URL. Set --public-url or remove the \`servers\` filter.`
@@ -81,7 +81,7 @@ export function assertCloudCanHonorAccountServersFilters(args: {
     return;
   }
   const blocked = args.resolvedConnections.filter(
-    (connection) =>
+    connection =>
       connection.accountServersFilter !== undefined &&
       connection.cloudUrl === undefined &&
       args.bridgedNames?.has(connection.name) !== true
@@ -91,7 +91,7 @@ export function assertCloudCanHonorAccountServersFilters(args: {
   }
   throw new Error(
     `[agent-sdk] cloud turn cannot honor Cursor account \`servers\` filters (${blocked
-      .map((connection) => connection.name)
+      .map(connection => connection.name)
       .join(
         ", "
       )}) without --public-url; set --public-url so cloud turns reach the filtered account bridge instead of falling back to native connectors.`
@@ -140,10 +140,10 @@ export function resolveMountConnections(args: {
 
   if (cloudCapable) {
     const hostOauthNames = agent.connections
-      .filter((connection) =>
+      .filter(connection =>
         isHostOauthConnectionTransport(connection.transport)
       )
-      .map((connection) => connection.name);
+      .map(connection => connection.name);
     if (hostOauthNames.length > 0) {
       args.logger(
         args.cloudToolsBridge === true
@@ -168,7 +168,7 @@ export function resolveMountConnections(args: {
     if (cloudCapable && args.publicUrl === undefined) {
       args.logger(
         `[agent-sdk] warning: agent "${label}" has peer MCP connections (${peers
-          .map((peer) => peer.name)
+          .map(peer => peer.name)
           .join(
             ", "
           )}) but no --public-url; cloud-runtime turns cannot reach this host's loopback address, so peers are omitted from cloud turns.`

package/src/internal/result-output.ts

@@ -2,30 +2,87 @@
  * Run the authored `defineResult` commit on the final assistant text.
  */
 
-import type { ResultContext, ResultDefinition } from "../types.js";
+import type { ResultContext, ResultDefinition, TurnUsage } from "../types.js";
+
+/** Same-turn `runTurn` retries after `ctx.reject` (initial commit + this many). */
+export const RESULT_REPAIR_BUDGET = 2;
+
+export class ResultRejectError extends Error {
+  override readonly name = "ResultRejectError";
+}
 
 export type ResultParse =
   | { ok: true; text: string }
-  | { ok: false; message: string };
+  | { ok: false; kind: "error"; message: string }
+  | { ok: false; kind: "reject"; message: string };
+
+export function resultRepairPrompt(message: string): string {
+  return [
+    "Your previous turn result was not applied.",
+    "",
+    message,
+    "",
+    "Revise the result and finish the turn again. The host will commit the new assistant text.",
+  ].join("\n");
+}
+
+export function addTurnUsage(
+  left: TurnUsage | undefined,
+  right: TurnUsage | undefined
+): TurnUsage | undefined {
+  if (left === undefined) {
+    return right;
+  }
+  if (right === undefined) {
+    return left;
+  }
+  return {
+    inputTokens: left.inputTokens + right.inputTokens,
+    outputTokens: left.outputTokens + right.outputTokens,
+    cacheReadTokens: left.cacheReadTokens + right.cacheReadTokens,
+    cacheWriteTokens: left.cacheWriteTokens + right.cacheWriteTokens,
+    ...(left.reasoningTokens !== undefined ||
+    right.reasoningTokens !== undefined
+      ? {
+          reasoningTokens:
+            (left.reasoningTokens ?? 0) + (right.reasoningTokens ?? 0),
+        }
+      : {}),
+  };
+}
 
 export async function applyAuthoredResult(args: {
   definition: ResultDefinition;
   text: string | undefined;
   dryRun: boolean;
-  ctx: Omit<ResultContext, "text">;
+  ctx: Omit<ResultContext, "text" | "reject">;
 }): Promise<ResultParse> {
   if (args.text === undefined || args.text.trim() === "") {
-    return { ok: false, message: "turn produced no assistant text" };
+    return {
+      ok: false,
+      kind: "error",
+      message: "turn produced no assistant text",
+    };
   }
   const text = args.text;
   if (args.dryRun) {
     return { ok: true, text };
   }
   try {
-    await args.definition.commit({ ...args.ctx, text });
+    await args.definition.commit({
+      ...args.ctx,
+      text,
+      reject(message: string): never {
+        throw new ResultRejectError(message);
+      },
+    });
   } catch (error) {
+    if (error instanceof ResultRejectError) {
+      return { ok: false, kind: "reject", message: error.message };
+    }
     return {
       ok: false,
+      kind: "error",
       message:
         error instanceof Error ? error.message : `on commit: ${String(error)}`,
     };

package/src/internal/router.ts

@@ -86,14 +86,14 @@ export class Router {
 }
 
 function compilePattern(pattern: string): Segment[] {
-  const segments: Segment[] = splitPath(pattern).map((part) =>
+  const segments: Segment[] = splitPath(pattern).map(part =>
     part.startsWith(":")
       ? { kind: "param", name: part.slice(1) }
       : part.startsWith("*")
         ? { kind: "rest", name: part.slice(1) }
         : { kind: "literal", value: part }
   );
-  const restIndex = segments.findIndex((segment) => segment.kind === "rest");
+  const restIndex = segments.findIndex(segment => segment.kind === "rest");
   if (restIndex !== -1 && restIndex !== segments.length - 1) {
     throw new Error(
       `Route pattern "${pattern}" may only use a catch-all (*name) as the last segment.`
@@ -103,7 +103,7 @@ function compilePattern(pattern: string): Segment[] {
 }
 
 function splitPath(path: string): string[] {
-  return path.split("/").filter((part) => part !== "");
+  return path.split("/").filter(part => part !== "");
 }
 
 function matchSegments(
@@ -138,7 +138,7 @@ function matchSegments(
   if (hasRest) {
     params[last.name] = pathSegments
       .slice(fixedCount)
-      .map((value) => decodeURIComponent(value))
+      .map(value => decodeURIComponent(value))
       .join("/");
   }
   return params;

package/src/internal/run-client.ts

@@ -34,7 +34,7 @@ export interface RunClientOptions extends RequestAuth {
   onEvent?: (event: SessionEvent) => void;
   /**
    * Create-time session purpose. Pass `"eval"` from the eval harness so
-   * live `defineAB` enrollment is skipped. Default `"live"`.
+   * the session is marked as regression traffic. Default `"live"`.
    */
   purpose?: SessionPurpose;
 }
@@ -228,8 +228,8 @@ async function runOneTurn(args: OneTurnArgs): Promise<OneTurnResult> {
     onEvent: args.onEvent,
   });
 
-  const turnFailed = events.some((e) => e.type === "turn.failed");
-  const sessionFailed = events.some((e) => e.type === "session.failed");
+  const turnFailed = events.some(e => e.type === "turn.failed");
+  const sessionFailed = events.some(e => e.type === "session.failed");
   return {
     sessionId,
     ...(continuationToken === undefined ? {} : { continuationToken }),

package/src/internal/schedule-runner.ts

@@ -49,7 +49,7 @@ export class ScheduleRunner {
     project: AgentProject,
     private readonly logger: (line: string) => void = () => {}
   ) {
-    this.schedules = project.schedules.map((schedule) => ({
+    this.schedules = project.schedules.map(schedule => ({
       name: schedule.name,
       cron: parseCron(schedule.cron),
       discovered: schedule,
@@ -57,7 +57,7 @@ export class ScheduleRunner {
   }
 
   get scheduleIds(): string[] {
-    return this.schedules.map((schedule) => schedule.name);
+    return this.schedules.map(schedule => schedule.name);
   }
 
   start(): void {
@@ -88,7 +88,7 @@ export class ScheduleRunner {
       this.lastFiredMinute = minute;
       for (const schedule of this.schedules) {
         if (schedule.cron.matches(now)) {
-          void this.dispatch(schedule.name).catch((error) => {
+          void this.dispatch(schedule.name).catch(error => {
             this.logger(
               `[agent-sdk] schedule "${schedule.name}" dispatch failed: ${
                 error instanceof Error ? error.message : String(error)
@@ -103,7 +103,7 @@ export class ScheduleRunner {
 
   /** Fire a schedule by name, exactly once. Returns the started sessions. */
   async dispatch(scheduleId: string): Promise<{ sessionIds: string[] }> {
-    const schedule = this.schedules.find((s) => s.name === scheduleId);
+    const schedule = this.schedules.find(s => s.name === scheduleId);
     if (schedule === undefined) {
       throw new UnknownScheduleError(scheduleId, this.scheduleIds);
     }
@@ -131,7 +131,7 @@ export class ScheduleRunner {
       channel: Parameters<SessionEngine["receive"]>[0],
       input: ReceiveInput
     ): Promise<ChannelSession> => {
-      const promise = this.engine.receive(channel, input).then((session) => {
+      const promise = this.engine.receive(channel, input).then(session => {
         sessionIds.push(session.id);
         return session;
       });
@@ -146,7 +146,7 @@ export class ScheduleRunner {
           auth: APP_AUTH,
           ...callOptions,
         }),
-      waitUntil: (promise) => {
+      waitUntil: promise => {
         this.engine.trackBackground(promise);
       },
       appAuth: APP_AUTH,

package/src/internal/scm/pr-url.ts

@@ -1,6 +1,8 @@
 /**
  * Provider-neutral PR URL parse. GitHub.com plus the Origin page shapes
- * humans paste: cursor.com/codebase, review.cursor.com/pr, origin.cursor.com.
+ * humans paste: cursor.com/codebase (canonical), origin.cursor.com, and the
+ * retired review-host shape that older links and stored PR records still
+ * carry.
  *
  * {@link parseScmPrUrl} is the wider parse the review seams use: it also
  * recognizes GitLab merge requests (`/-/merge_requests/<iid>` on any host),
@@ -47,6 +49,13 @@ export type ParsedScmPrUrl = {
 
 const ORIGIN_PAGE = /^origin(-[a-z0-9]+)?\.cursor\.com$/i;
 
+/**
+ * Retired Origin UI host. Accepted on input only, for links minted before
+ * the move to cursor.com/codebase; every canonical URL this module emits is
+ * the cursor.com shape.
+ */
+const LEGACY_REVIEW_CURSOR_HOSTS = new Set(["review.cursor.com"]);
+
 function positiveInt(raw: string | undefined): number | undefined {
   if (raw === undefined) {
     return undefined;
@@ -145,7 +154,7 @@ export function parseScmPrUrl(raw: string): ParsedScmPrUrl | undefined {
     return parsed("origin", host, parts[1], parts[2], positiveInt(parts[4]));
   }
 
-  if (host === "review.cursor.com" && parts[0] === "pr") {
+  if (LEGACY_REVIEW_CURSOR_HOSTS.has(host) && parts[0] === "pr") {
     if (parts.length >= 5 && parts[3] === "github") {
       return parsed("origin", host, parts[1], parts[2], positiveInt(parts[4]));
     }