@cursor/july 0.1.109 → 0.1.111

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

@@ -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]));
     }

package/src/internal/sdk-runner.ts

@@ -79,18 +79,6 @@ export type PrewarmOutcome =
   | { readonly warmed: true }
   | { readonly warmed: false; readonly reason: string };
 
-/**
- * `CursorAgentPlatform.prewarmLocalWorkspace` as of `@cursor/sdk` 1.0.26.
- * Declared structurally so this keeps building — and reports that it skipped
- * warming — against the pinned older SDK. Delete once the pin passes that
- * version.
- */
-type MaybePrewarmingPlatform = {
-  prewarmLocalWorkspace?: (
-    options: AgentOptions
-  ) => Promise<() => Promise<void>>;
-};
-
 /**
  * How long a non-`--dev` serve holds workspace scans (rules, skills,
  * `AGENTS.md`, ignore files). The SDK default is 20s for an editor whose
@@ -233,7 +221,7 @@ export class CursorSdkRunner implements AgentRunner {
     let sawUpdate = false;
     const tracked: RunnerTurnRequest = {
       ...request,
-      onUpdate: (update) => {
+      onUpdate: update => {
         sawUpdate = true;
         return request.onUpdate(update);
       },
@@ -272,7 +260,7 @@ export class CursorSdkRunner implements AgentRunner {
         request.images !== undefined && request.images.length > 0
           ? {
               text: request.prompt,
-              images: request.images.map((image) => ({
+              images: request.images.map(image => ({
                 data: image.data,
                 mimeType: image.mimeType,
               })),
@@ -416,15 +404,7 @@ export class CursorSdkRunner implements AgentRunner {
    * {@link dispose}; dropping it early would tear the workspace back down.
    */
   async prewarm(request: RunnerPrewarmRequest): Promise<PrewarmOutcome> {
-    const platform = (await createAgentPlatform()) as MaybePrewarmingPlatform;
-    if (typeof platform.prewarmLocalWorkspace !== "function") {
-      // Older @cursor/sdk. Turns still work; they just pay on the first one.
-      return {
-        warmed: false,
-        reason:
-          "the installed @cursor/sdk has no prewarmLocalWorkspace; upgrade it to warm the workspace before the first turn",
-      };
-    }
+    const platform = await createAgentPlatform();
     const release = await platform.prewarmLocalWorkspace(
       await this.buildLocalOptions(request)
     );
@@ -453,9 +433,9 @@ export class CursorSdkRunner implements AgentRunner {
 
   async dispose(): Promise<void> {
     const releases = this.prewarmReleases.splice(0);
-    await Promise.allSettled(releases.map((release) => release()));
+    await Promise.allSettled(releases.map(release => release()));
     const agents = await Promise.allSettled(
-      [...this.agents.values()].map((handle) => handle.agent)
+      [...this.agents.values()].map(handle => handle.agent)
     );
     this.agents.clear();
     for (const settled of agents) {
@@ -479,7 +459,7 @@ export class CursorSdkRunner implements AgentRunner {
       );
       this.evictAgent(request.sessionId, cached.agent);
     }
-    const agentPromise = this.openAgent(request).catch((error) => {
+    const agentPromise = this.openAgent(request).catch(error => {
       // Nothing opened, so there is no handle to close — just free the slot.
       this.agents.delete(request.sessionId);
       throw error;
@@ -502,7 +482,7 @@ export class CursorSdkRunner implements AgentRunner {
       return;
     }
     this.agents.delete(sessionId);
-    void cached.agent.then((sdkAgent) => sdkAgent.close()).catch(() => {});
+    void cached.agent.then(sdkAgent => sdkAgent.close()).catch(() => {});
   }
 
   private log(line: string): void {
@@ -548,7 +528,7 @@ export class CursorSdkRunner implements AgentRunner {
    * goes through here too, so a warmed workspace is the one turns land on.
    */
   private async buildLocalOptions(
-    request: RunnerPrewarmRequest
+    request: RunnerPrewarmRequest & Pick<RunnerTurnRequest, "instructions">
   ): Promise<AgentOptions> {
     // Not resolveStore: an injected store is used synchronously (no
     // microtask, no thenable assimilation), exactly as before the mirror
@@ -565,6 +545,12 @@ export class CursorSdkRunner implements AgentRunner {
       ...(request.disallowedTools === undefined
         ? {}
         : { disallowedTools: request.disallowedTools }),
+      // Same shape: local-only (the SDK rejects it with `cloud`), not
+      // persisted, so it rides every create/resume. Replaces Cursor's
+      // built-in system prompt with the agent's composed instructions.
+      // Prewarm requests carry none, and the SDK's workspace cache key
+      // ignores it, so a warmed executor is still the one turns land on.
+      systemPrompt: request.instructions,
       local: {
         cwd: request.workspaceDir,
         settingSources: ["project"],

package/src/internal/serve-restart.ts

@@ -103,7 +103,7 @@ export async function runEnterRestartSupervisor(options: {
 function waitForExit(
   child: ServeRestartWorkerChild
 ): Promise<{ code: number | null; signal: NodeJS.Signals | null }> {
-  return new Promise((resolve) => {
+  return new Promise(resolve => {
     child.once("exit", (code, signal) => {
       resolve({ code, signal });
     });