@cursor/july 0.1.95 → 0.1.97

package/src/internal/otel/collector.ts

@@ -284,6 +284,36 @@ export function createOtelCollector(
           );
         return;
       }
+      case "action.auth_requested": {
+        ensureTurn(event, session, startTime)
+          ?.tools.get(event.data.callId)
+          ?.addEvent("auth_requested", undefined, startTime);
+        emitLog(
+          "action.auth_requested",
+          SeverityNumber.INFO,
+          attrs({
+            ...baseLog(event, session),
+            "cursor.tool.name": event.data.toolName,
+            "agent_sdk.call_id": event.data.callId,
+            "agent_sdk.mcp_connection": event.data.connection,
+          })
+        );
+        return;
+      }
+      case "action.auth_resolved": {
+        ensureTurn(event, session, startTime)
+          ?.tools.get(event.data.callId)
+          ?.addEvent(
+            "auth_resolved",
+            attrs({
+              "agent_sdk.decision": event.data.decision,
+              "agent_sdk.decision_by": event.data.by,
+              "agent_sdk.mcp_connection": event.data.connection,
+            }),
+            startTime
+          );
+        return;
+      }
       case "action.result": {
         const turn = ensureTurn(event, session, startTime);
         const span = turn?.tools.get(event.data.callId);

package/src/internal/runtime-dispatch-runner.ts

@@ -13,6 +13,7 @@ import type {
   AgentRunner,
   PrewarmOutcome,
   RunnerPrewarmRequest,
+  SteerAckOutcome,
 } from "./sdk-runner.js";
 
 export interface RuntimeDispatchingRunnerOptions {
@@ -45,6 +46,15 @@ export class RuntimeDispatchingRunner implements AgentRunner {
     return this.options.sdkRunner.runTurn(request);
   }
 
+  async steer(request: {
+    sessionId: string;
+    text: string;
+  }): Promise<SteerAckOutcome> {
+    return (
+      (await this.options.sdkRunner.steer?.(request)) ?? "revert_to_followup"
+    );
+  }
+
   async prewarm(request: RunnerPrewarmRequest): Promise<PrewarmOutcome> {
     // Prewarming is a local-harness concern; the engine only calls it for
     // local-runtime agents.

package/src/internal/sdk-runner.ts

@@ -16,6 +16,7 @@ import {
   createAgentPlatform,
   type LocalAgentStore,
   type ModelSelection,
+  type Run,
   type RunResult,
   type SDKAgent,
 } from "@cursor/sdk";
@@ -31,10 +32,18 @@ import {
 import { mapSdkTokenUsage, usageTokenSum } from "./cloud-turn-cost.js";
 import type { ConversationMirror } from "./conversation-mirror.js";
 import { resolveApiKeySync } from "./cursor/credentials.js";
+import { describeError } from "./describe-error.js";
+
+/** Mirrors @cursor/sdk's SteerAckOutcome; the published dist may predate it. */
+export type SteerAckOutcome = "complete_delivered" | "revert_to_followup";
 
 /** Internal seam between the session engine and the Cursor SDK harness. */
 export interface AgentRunner {
   runTurn(request: RunnerTurnRequest): Promise<TurnOutcome>;
+  steer?(request: {
+    sessionId: string;
+    text: string;
+  }): Promise<SteerAckOutcome>;
   /**
    * Resolve a local workspace before any session needs it, so the first turn
    * is not the one that pays for it. Best effort, hence the reported outcome:
@@ -193,6 +202,7 @@ function retryReason(
 
 export class CursorSdkRunner implements AgentRunner {
   private readonly agents = new Map<string, CachedAgentHandle>();
+  private readonly activeRuns = new Map<string, Run>();
   private readonly stores = new Map<string, Promise<LocalAgentStore>>();
   private readonly prewarmReleases: Array<() => Promise<void>> = [];
 
@@ -322,15 +332,9 @@ export class CursorSdkRunner implements AgentRunner {
       ) {
         await request.onRequestId(run.requestId);
       }
+      this.activeRuns.set(request.sessionId, run);
       try {
         const result = await run.wait();
-        // Mirror the conversation before replying: on hosted v2 the pod can
-        // be parked as soon as the execution reply lands, so a
-        // fire-and-forget write would race VM teardown. Failed turns still
-        // checkpoint the user message, so they persist too.
-        if (request.runtime === "local") {
-          await this.persistConversation(request, agent.agentId);
-        }
         let outcome = toTurnOutcome(result);
         if (outcome.status === "error") {
           // An error result usually means the handle's transport is poisoned
@@ -353,7 +357,25 @@ export class CursorSdkRunner implements AgentRunner {
         }
         return outcome;
       } finally {
+        if (this.activeRuns.get(request.sessionId) === run) {
+          this.activeRuns.delete(request.sessionId);
+        }
         signal?.removeEventListener("abort", onAbort);
+        // Mirror the conversation before replying: on hosted v2 the pod can
+        // be parked as soon as the execution reply lands, so a
+        // fire-and-forget write would race VM teardown. In the `finally` so
+        // a `wait()` that THROWS (transport death mid-turn, an abort with
+        // no follow-up) still persists the checkpoints the turn already
+        // wrote — the store is local SQLite, safe to read on the throw
+        // path, and persistConversation swallows its own errors. Guarded
+        // here (not just inside the helper) so unmirrored turns keep their
+        // exact post-wait sequencing.
+        if (
+          request.runtime === "local" &&
+          this.options.conversationMirror !== undefined
+        ) {
+          await this.persistConversation(request, agent.agentId);
+        }
       }
     } catch (error) {
       // Drop the cached agent so a dead Connect/HTTP2 session cannot poison
@@ -363,6 +385,28 @@ export class CursorSdkRunner implements AgentRunner {
     }
   }
 
+  async steer(request: {
+    sessionId: string;
+    text: string;
+  }): Promise<SteerAckOutcome> {
+    const run = this.activeRuns.get(request.sessionId) as
+      | (Run & {
+          steer?: (text: string) => Promise<SteerAckOutcome>;
+        })
+      | undefined;
+    if (run?.steer === undefined) {
+      return "revert_to_followup";
+    }
+    try {
+      return await run.steer(request.text);
+    } catch (error) {
+      this.log(
+        `[agent-sdk] session ${request.sessionId}: steer failed: ${describeError(error)}`
+      );
+      return "revert_to_followup";
+    }
+  }
+
   /**
    * Build the local executor for a workspace before any session asks for it.
    * The warmed executor is reference counted, so the lease is held until
@@ -484,7 +528,11 @@ export class CursorSdkRunner implements AgentRunner {
   private async buildLocalOptions(
     request: RunnerPrewarmRequest
   ): Promise<AgentOptions> {
-    const store = await this.resolveStore(request);
+    // Not resolveStore: an injected store is used synchronously (no
+    // microtask, no thenable assimilation), exactly as before the mirror
+    // existed.
+    const store =
+      this.options.store ?? (await this.getStore(request.runnerStateDir));
     return {
       ...this.buildSharedOptions(request),
       // The built-in tool allowlist rides AgentOptions, not `local`, and is

package/src/internal/server.ts

@@ -130,6 +130,11 @@ import {
   MCP_ENDPOINT_PATH,
   TOOL_MCP_ENDPOINT_PATH,
 } from "./mcp-endpoint.js";
+import {
+  mcpOauthServeCallbackPath,
+  mcpOauthServeCallbackUrl,
+} from "./mcp-oauth-on-demand.js";
+import type { McpOauthSecretsTarget } from "./mcp-oauth-persist.js";
 import { isLoopbackAddress } from "./net.js";
 import { createOtelCollector, type OtelCollector } from "./otel/collector.js";
 import { pickAuthoredOtel, resolveOtelConfig } from "./otel/config.js";
@@ -240,6 +245,8 @@ function isV2Project(project: { agent: { architecture?: string } }): boolean {
 export interface StartServerInternalOptions {
   /** Test seam: replace the Cursor SDK runner (integration tests). */
   runner?: AgentRunner;
+  /** Test seam: bind the `--store` secrets client for on-demand MCP OAuth. */
+  mcpOauthSecrets?: McpOauthSecretsTarget;
 }
 
 /**
@@ -647,6 +654,12 @@ export async function startServer(
       otel: otelCollector,
       otelMeter: otelRuntime?.meter,
     });
+    engine.oauthCallbackHub.secrets = options.mcpOauthSecrets;
+    engine.oauthCallbackHub.secretsBind = {
+      slug: slug === "" ? undefined : slug,
+      cloudToolsUrl: options.cloudToolsUrl,
+    };
+    engine.oauthCallbackHub.logger = logger;
     // Rehydrate sessions from the authored storage sink before any
     // channel or route can address them (continuation tokens must resolve).
     await engine.restoreStoredSessions();
@@ -732,6 +745,7 @@ export async function startServer(
       multi,
       logger,
       logRing,
+      diagStateRoot: baseStateRoot,
       ...(options.authToken === undefined
         ? {}
         : { authToken: options.authToken }),
@@ -762,6 +776,8 @@ export async function startServer(
           },
           resolveApproval: (sessionId, callId, decision, auth) =>
             engine.resolveApproval(sessionId, callId, decision, auth),
+          resolveAuth: (sessionId, callId, decision, auth) =>
+            engine.resolveAuth(sessionId, callId, decision, auth),
           hasContinuationSession: (continuationToken) =>
             engine.hasContinuationSession(channel.id, continuationToken),
           isContinuationBusy: (continuationToken) =>
@@ -1013,6 +1029,7 @@ export async function startServer(
   const address = server.address() as AddressInfo;
   const displayHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
   const url = `http://${displayHost}:${boundPort}`;
+  const oauthOrigin = (options.publicUrl ?? url).replace(/\/$/, "");
 
   // Resolve peer + Cursor account MCP connections now that the listen port is
   // known (see resolved-connections.ts for the URL/runtime rules).
@@ -1039,6 +1056,20 @@ export async function startServer(
     if (resolved.length > 0) {
       runtime.engine.setResolvedConnections(resolved);
     }
+    const oauthBase = runtime.slug === "" ? "" : `/${runtime.slug}`;
+    runtime.engine.setMcpOauthCallbackUrl(
+      mcpOauthServeCallbackUrl(oauthOrigin, oauthBase)
+    );
+    if (accountBridge !== undefined && accountRefs !== undefined) {
+      const bridge = accountBridge;
+      runtime.engine.setCursorAccountAuthProbe(async (connection) => {
+        const ref = accountRefs.find((entry) => entry.name === connection);
+        if (ref === undefined) {
+          return undefined;
+        }
+        return await bridge.probeAuthUrl(ref);
+      });
+    }
     const hasServerTools = runtime.project.agent.tools.some(
       (tool) => tool.execution === "server"
     );
@@ -1227,6 +1258,11 @@ function mountAgentRoutes(
     /** Cursor account bridge + this mount's account MCP connections, when authored. */
     accountBridge?: CursorAccountMcpBridge;
     accountRefs?: CursorAccountConnectionRef[];
+    /**
+     * Serve `--state-root`. Hosted-execution writes `hosted-execution.json`
+     * here so the Temporal host can read a stable path after the POST.
+     */
+    diagStateRoot?: string;
   }
 ): void {
   const { slug, project, engine, scheduleRunner, reminderRunner } = runtime;
@@ -1286,6 +1322,11 @@ function mountAgentRoutes(
           channelId,
           hostedSessionId,
         }),
+      drainSessionDurability: (sessionId) =>
+        engine.drainSessionDurability(sessionId),
+      ...(args.diagStateRoot === undefined
+        ? {}
+        : { stateRoot: args.diagStateRoot }),
     });
   }
   // Playground lists/opens Slack (and other channel) sessions across
@@ -1301,6 +1342,13 @@ function mountAgentRoutes(
   // tools (Slack principals never match local/anonymous HTTP auth).
   const relaxSessionApprovalAuth = relaxSessionReadAuth;
 
+  router.add({
+    method: "GET",
+    pattern: `${base}${mcpOauthServeCallbackPath()}`,
+    auth: "none",
+    handler: (request) => engine.oauthCallbackHub.handleCallback(request),
+  });
+
   router.add({
     method: "GET",
     pattern: `${base}/v1/health`,
@@ -1389,7 +1437,7 @@ function mountAgentRoutes(
     method: "GET",
     pattern: `${base}/v1/sessions`,
     auth: httpAuth,
-    handler: async (_request, ctx) => {
+    handler: async (request, ctx) => {
       // Same gate as requireSessionOwner / relaxSessionReadAuth: never with
       // bearer or custom channel auth (strict per-principal isolation).
       // `--allow-anonymous` alone is a shared-principal trust boundary (corp
@@ -1399,9 +1447,14 @@ function mountAgentRoutes(
         (relaxSessionReadAuthBeyondLoopback ||
           (typeof ctx.requestIp === "string" &&
             isLoopbackAddress(ctx.requestIp)));
-      const listed = await engine.listSessionsWithSource(ctx.auth, {
-        includeAll,
-      });
+      // `?latest=1` — only the newest visible session. Clients binding a
+      // default session (agsh) do not need the whole list, and on hosted
+      // storage the whole list is a database scan.
+      const latest = new URL(request.url).searchParams.get("latest");
+      const listed =
+        latest === "1" || latest === "true"
+          ? await engine.latestSessionWithSource(ctx.auth, { includeAll })
+          : await engine.listSessionsWithSource(ctx.auth, { includeAll });
       return jsonResponse({
         sessions: listed.sessions,
         source: listed.source,
@@ -1611,23 +1664,22 @@ function mountAgentRoutes(
         return binding.errorResponse;
       }
       try {
-        const catalog = await engine.listCatalogTools({
+        const described = await engine.describeCatalogTool(toolName, {
           auth: ctx.auth,
           ...binding,
         });
-        const tool = catalog.tools.find((t) => t.name === toolName);
-        if (tool === undefined) {
+        if (described.tool === undefined) {
           return jsonResponse(
             {
               ok: false,
               error: "unknown_tool",
               message: `Unknown tool "${toolName}".`,
-              availableTools: catalog.tools.map((t) => t.name),
+              availableTools: described.availableTools,
             },
             { status: 404 }
           );
         }
-        return jsonResponse(catalogDetailEntry(tool));
+        return jsonResponse(catalogDetailEntry(described.tool));
       } catch (error) {
         if (error instanceof InvalidContinuationTokenError) {
           return errorResponse(