@cursor/july 0.1.112 → 0.1.113

package/src/internal/hosted-execution-diag.ts

@@ -43,7 +43,8 @@ export type HostedExecutionDiagAbortReason =
 /**
  * Bounded guest-side record of one hosted-execution attempt. No prompt,
  * tool content, or API key — the host copies known keys onto the Temporal
- * activity span for Datadog.
+ * activity span for Datadog. `errorCode` and `message` are logged ungated;
+ * `stack` stays behind the internal-diag gate.
  */
 export type HostedExecutionDiag = {
   v: typeof HOSTED_EXECUTION_DIAG_VERSION;
@@ -62,6 +63,8 @@ export type HostedExecutionDiag = {
   requestId?: string;
   abortReason?: HostedExecutionDiagAbortReason;
   failureCode?: string;
+  /** Runner/SDK code for the unfinished turn. Distinct from {@link failureCode}. */
+  errorCode?: string;
   classification?: HostedFailureClassification;
 };
 
@@ -82,6 +85,7 @@ const DIAG_KEYS = new Set([
   "requestId",
   "abortReason",
   "failureCode",
+  "errorCode",
   "classification",
 ]);
 
@@ -108,9 +112,9 @@ export const HOSTED_ERROR_STACK_LINE_COUNT = 5;
 export const HOSTED_ERROR_SNIPPET_MAX_CHARS = 700;
 
 /**
- * Bounded throw text for the hosted 500 body and the on-disk diag `stack`.
- * Prefers `Error.stack` (message line + `at` frames) so `last_error` is not
- * the generic "Internal server error." when the throw has a stack.
+ * Bounded throw text for on-disk diag `stack` (and non-hosted 500 bodies).
+ * Prefers `Error.stack` (message line + `at` frames). Hosted HTTP `message`
+ * uses {@link hostedErrorMessageOnly} so customer Datadog stays frame-free.
  */
 export function hostedErrorStackSnippet(error: unknown): string {
   if (error instanceof Error) {
@@ -139,6 +143,29 @@ export function hostedErrorStackSnippet(error: unknown): string {
     : text;
 }
 
+/**
+ * Guest throw text without `at` frames. Hosted 500 `message` is ungated on
+ * TAS (`hostedGuestMessage` / `last_error`); stack frames stay on `stack`.
+ */
+export function hostedErrorMessageOnly(error: unknown): string {
+  const text =
+    error instanceof Error && error.message.trim().length > 0
+      ? error.message.trim()
+      : String(error).trim();
+  if (text.length === 0) {
+    return "Internal server error.";
+  }
+  const firstFrame = text.search(/\n\s+at\s/);
+  const message =
+    firstFrame === -1 ? text : text.slice(0, firstFrame).trimEnd();
+  if (message.length === 0) {
+    return "Internal server error.";
+  }
+  return message.length > HOSTED_ERROR_SNIPPET_MAX_CHARS
+    ? `${message.slice(0, HOSTED_ERROR_SNIPPET_MAX_CHARS)}…`
+    : message;
+}
+
 export function hostedExecutionDiagPath(stateRoot: string): string {
   return join(stateRoot, HOSTED_EXECUTION_DIAG_FILENAME);
 }
@@ -206,6 +233,7 @@ export function parseHostedExecutionDiag(
   );
   const requestId = boundedOptionalString(body.requestId, 128);
   const failureCode = boundedOptionalString(body.failureCode, 64);
+  const errorCode = boundedOptionalString(body.errorCode, 64);
   const classification =
     body.classification === undefined
       ? undefined
@@ -243,6 +271,7 @@ export function parseHostedExecutionDiag(
     ...(requestId === undefined ? {} : { requestId }),
     ...(abortReason === undefined ? {} : { abortReason }),
     ...(failureCode === undefined ? {} : { failureCode }),
+    ...(errorCode === undefined ? {} : { errorCode }),
     ...(classification === undefined ? {} : { classification }),
   };
 }

package/src/internal/hosted-execution-flush.ts

@@ -48,6 +48,7 @@ export type HostedExecutionFlushFields = {
   message?: string;
   abortReason?: HostedExecutionDiagAbortReason;
   failureCode?: string;
+  errorCode?: string;
   classification?: HostedFailureClassification;
   error?: unknown;
 };
@@ -83,6 +84,9 @@ export async function flushHostedExecutionRecord(
         ? {}
         : { abortReason: fields.abortReason }),
       failureCode: fields.failureCode,
+      ...(fields.errorCode === undefined
+        ? {}
+        : { errorCode: fields.errorCode }),
       classification: fields.classification,
     });
   }

package/src/internal/server.ts

@@ -137,7 +137,10 @@ import {
   HOSTED_GUEST_RETRY_TERMINAL,
   hostedGuestErrorResponse,
 } from "./hosted-delivery-protocol.js";
-import { hostedErrorStackSnippet } from "./hosted-execution-diag.js";
+import {
+  hostedErrorMessageOnly,
+  hostedErrorStackSnippet,
+} from "./hosted-execution-diag.js";
 import { flushHostedExecutionProcessDeath } from "./hosted-execution-flush.js";
 import {
   buildHttpChannelRoutes,
@@ -1321,11 +1324,18 @@ export async function startServer(
           );
         }
       } else {
+        const resolveCloudToolsHeaders =
+          options.cloudToolsUrl === undefined
+            ? undefined
+            : (): Record<string, string> | undefined => {
+                const apiKey = liveCursorApiKey();
+                return apiKey === undefined
+                  ? undefined
+                  : { authorization: `Bearer ${apiKey}` };
+              };
         const headers =
           options.cloudToolsUrl !== undefined
-            ? accountKey === undefined
-              ? undefined
-              : { authorization: `Bearer ${accountKey.apiKey}` }
+            ? resolveCloudToolsHeaders?.()
             : options.authToken === undefined
               ? undefined
               : { authorization: `Bearer ${options.authToken}` };
@@ -1336,14 +1346,17 @@ export async function startServer(
             );
           }
           logger(
-            `[agent-sdk] --cloud-tools-url: listening unsigned; Bearer is taken from the key present at start`
+            `[agent-sdk] --cloud-tools-url: listening unsigned; Bearer resolves after task-time credential binding`
           );
         }
-        runtime.engine.setCloudServerToolsConnection({
-          type: "http",
-          url: publicToolsUrl,
-          ...(headers === undefined ? {} : { headers }),
-        });
+        runtime.engine.setCloudServerToolsConnection(
+          {
+            type: "http",
+            url: publicToolsUrl,
+            ...(headers === undefined ? {} : { headers }),
+          },
+          resolveCloudToolsHeaders
+        );
       }
     }
   }
@@ -3150,8 +3163,9 @@ async function handleRequest(
         }`
       );
       const snippet = hostedErrorStackSnippet(error);
-      const message =
-        snippet.length > 0
+      const message = hostedDeliveryRequest
+        ? hostedErrorMessageOnly(error)
+        : snippet.length > 0
           ? `Internal server error: ${snippet}`
           : "Internal server error.";
       response = hostedDeliveryRequest

package/src/internal/session-engine.ts

@@ -591,6 +591,10 @@ export class SessionEngine {
   private resolvedConnections: EngineResolvedConnection[] = [];
   /** Direct server-tool HTTP MCP transport exposed only to cloud turns. */
   private cloudServerToolsConnection: ConnectionTransport | undefined;
+  /** Re-resolved after hosted v2 task binding writes the Cursor credential. */
+  private cloudServerToolsHeaders:
+    | (() => Record<string, string> | undefined)
+    | undefined;
   private readonly getCloudUsage: (
     sdkAgentId: string
   ) => Promise<CloudAgentUsage | undefined>;
@@ -756,8 +760,30 @@ export class SessionEngine {
     );
   }
 
-  setCloudServerToolsConnection(connection: ConnectionTransport): void {
+  setCloudServerToolsConnection(
+    connection: ConnectionTransport,
+    resolveHeaders?: () => Record<string, string> | undefined
+  ): void {
     this.cloudServerToolsConnection = connection;
+    this.cloudServerToolsHeaders = resolveHeaders;
+  }
+
+  private currentCloudServerToolsConnection(): ConnectionTransport | undefined {
+    const connection = this.cloudServerToolsConnection;
+    const resolveHeaders = this.cloudServerToolsHeaders;
+    if (
+      connection === undefined ||
+      !("url" in connection) ||
+      resolveHeaders === undefined
+    ) {
+      return connection;
+    }
+    const { headers: _headers, ...withoutHeaders } = connection;
+    const headers = resolveHeaders();
+    return {
+      ...withoutHeaders,
+      ...(headers === undefined ? {} : { headers }),
+    };
   }
 
   setMcpOauthCallbackUrl(url: string): void {
@@ -3196,7 +3222,7 @@ export class SessionEngine {
     sessionId: string,
     connectionName: string
   ): ConnectionTransport | undefined {
-    const connection = this.cloudServerToolsConnection;
+    const connection = this.currentCloudServerToolsConnection();
     if (connection === undefined || !("url" in connection)) {
       return undefined;
     }
@@ -3350,8 +3376,8 @@ export class SessionEngine {
           `MCP connection name "${SERVER_TOOLS_MCP_SERVER_NAME}" is reserved for authored server tools on cloud turns.`
         );
       }
-      const connection = this.cloudServerToolsConnection;
-      if ("url" in connection) {
+      const connection = this.currentCloudServerToolsConnection();
+      if (connection !== undefined && "url" in connection) {
         const url = new URL(connection.url);
         url.searchParams.set("agentkitSessionId", sessionId);
         servers[SERVER_TOOLS_MCP_SERVER_NAME] = {

package/src/types.ts

@@ -1147,6 +1147,16 @@ export interface ExtensionOptions<TConfig, TInput = TConfig> {
   description?: string;
   /** Mount configuration schema. A consumer's settings are validated at mount. */
   config?: z.ZodType<TConfig, z.ZodTypeDef, TInput>;
+  /** Choose which contribution groups this mount includes. */
+  contributions?: (config: TConfig) => ExtensionContributionSelection;
+}
+
+/** Contribution groups a configured extension mount may include or omit. */
+export interface ExtensionContributionSelection {
+  /** Include tools from the extension tree. Defaults to true. */
+  tools?: boolean;
+  /** Include skills from the extension tree. Defaults to true. */
+  skills?: boolean;
 }
 
 /**
@@ -1181,6 +1191,7 @@ export interface CursorPluginDeclaration extends ExtensionDeclaration {
 export interface ExtensionMount extends BrandedDefinition<"extension"> {
   readonly extension: ExtensionDeclaration | CursorPluginDeclaration;
   readonly config: unknown;
+  readonly contributions?: ExtensionContributionSelection;
 }
 
 /** `cursorPlugin({ ... })`: mount a Cursor plugin directory as an extension. */
@@ -1479,13 +1490,20 @@ export type ConnectionConfig = (
    * Fail-closed: a `listTools` failure, an invalid tool name, or a name
    * collision (with an authored tool or another advertised connection)
    * fails the turn — a turn never silently runs with a shrunken toolset.
-   * Local runtime only, like all server tools: a `runtime: "cloud"` agent
-   * fails discovery, and hybrid per-send cloud sessions refuse the turn.
-   * The listing runs once per turn; point this at endpoints that can
+   * Set {@link optional} to skip this connection instead of failing the
+   * turn. Local runtime only, like all server tools: a `runtime: "cloud"`
+   * agent fails discovery, and hybrid per-send cloud sessions refuse the
+   * turn. The listing runs once per turn; point this at endpoints that can
    * answer `tools/list` cheaply. Tools whose MCP `annotations.title` is
    * `do-not-call` are omitted (vendor host-UI / MCP Apps helpers).
    */
   advertiseTools?: boolean;
+  /**
+   * With {@link advertiseTools}, a `listTools` or `auth` failure skips this
+   * connection (zero tools from it) instead of failing the turn. Other
+   * advertised connections still fail closed. Requires `advertiseTools`.
+   */
+  optional?: boolean;
   /**
    * Intended effects of tools this connection serves. When set, only
    * tools whose classified effect is in this set are advertised — a
@@ -3246,6 +3264,8 @@ export interface DiscoveredConnection {
   auth?: ConnectionAuthProvider;
   /** Advertise-by-name from {@link ConnectionConfig.advertiseTools}. */
   advertiseTools?: boolean;
+  /** Skip a listing failure instead of failing the turn. */
+  optional?: boolean;
   /**
    * Normalized intended effects from {@link ConnectionConfig.effects}.
    * Absent means every listed tool is advertised.
@@ -3424,6 +3444,7 @@ export interface AgentProjectInfo {
     name: string;
     transport: string;
     advertiseTools?: boolean;
+    optional?: boolean;
     effects?: readonly ToolEffect[];
     tools?: readonly string[];
     disallowedTools?: readonly string[];