@cursor/july 0.1.43 → 0.1.46

package/src/internal/otel/collector.ts

@@ -27,6 +27,15 @@ const CONTENT_MAX = 2_048;
 export interface OtelCollector {
   onEvent(event: SessionEvent, session: SessionInfo): void;
   close(): void;
+  /** Merge author tags onto the session; paints open spans immediately. */
+  setSessionAttributes(
+    sessionId: string,
+    attributes: Record<string, AttrValue>
+  ): void;
+  /** Session tags previously set by {@link setSessionAttributes}. */
+  getSessionAttributes(
+    sessionId: string
+  ): Record<string, AttrValue> | undefined;
 }
 
 interface TurnState {
@@ -49,6 +58,7 @@ export function createOtelCollector(
   log: (line: string) => void
 ): OtelCollector {
   const sessions = new Map<string, SessionState>();
+  const extraBySession = new Map<string, Record<string, AttrValue>>();
   const metrics = runtime.meter ? buildMetrics(runtime.meter) : undefined;
   const logOpts =
     runtime.config.logs === false ? undefined : runtime.config.logs;
@@ -71,6 +81,17 @@ export function createOtelCollector(
         state.span.end();
         sessions.delete(sessionId);
       }
+      extraBySession.clear();
+    },
+    setSessionAttributes(sessionId, attributes) {
+      const bag = extraBySession.get(sessionId) ?? {};
+      Object.assign(bag, attributes);
+      extraBySession.set(sessionId, bag);
+      paintOpenSpans(sessionId, attributes);
+    },
+    getSessionAttributes(sessionId) {
+      const bag = extraBySession.get(sessionId);
+      return bag === undefined ? undefined : { ...bag };
     },
   };
 
@@ -215,7 +236,7 @@ export function createOtelCollector(
             {
               kind: SpanKind.INTERNAL,
               startTime,
-              attributes: attrs({
+              attributes: join(event.sessionId, {
                 "cursor.conversation.id": event.sessionId,
                 "cursor.tool.name": call.toolName,
                 "cursor.tool.kind": "builtin",
@@ -287,12 +308,15 @@ export function createOtelCollector(
           span.end(startTime);
           turn?.tools.delete(event.data.callId);
         }
-        metrics?.toolCalls.add(1, {
-          "cursor.tool.name": event.data.toolName,
-          "cursor.tool.kind": "builtin",
-          "cursor.tool.status": status,
-          "agent_sdk.agent": agentName,
-        });
+        metrics?.toolCalls.add(
+          1,
+          join(event.sessionId, {
+            "cursor.tool.name": event.data.toolName,
+            "cursor.tool.kind": "builtin",
+            "cursor.tool.status": status,
+            "agent_sdk.agent": agentName,
+          })
+        );
         emitLog(
           "action.result",
           event.data.isError ? SeverityNumber.ERROR : SeverityNumber.INFO,
@@ -327,7 +351,7 @@ export function createOtelCollector(
           {
             kind: SpanKind.INTERNAL,
             startTime,
-            attributes: attrs({
+            attributes: join(event.sessionId, {
               "cursor.conversation.id": event.sessionId,
               "agent_sdk.agent": agentName,
               "agent_sdk.turn_id": event.turnId,
@@ -343,10 +367,13 @@ export function createOtelCollector(
           trace.setSpan(context.active(), turn.span)
         );
         turn.subagents.set(event.data.callId, span);
-        metrics?.subagents.add(1, {
-          "agent_sdk.agent": agentName,
-          "agent_sdk.subagent_name": event.data.name ?? "unknown",
-        });
+        metrics?.subagents.add(
+          1,
+          join(event.sessionId, {
+            "agent_sdk.agent": agentName,
+            "agent_sdk.subagent_name": event.data.name ?? "unknown",
+          })
+        );
         return;
       }
       case "subagent.completed": {
@@ -389,7 +416,7 @@ export function createOtelCollector(
               "agent_sdk.usage.reasoning_tokens": usage.reasoningTokens,
             })
           );
-          recordTokens(usage);
+          recordTokens(event.sessionId, usage);
         }
         if (cost !== undefined) {
           turn.span.setAttributes(
@@ -399,18 +426,24 @@ export function createOtelCollector(
               "agent_sdk.cost_source": cost.source,
             })
           );
-          metrics?.cost.add(cost.totalUsd, {
-            "cursor.model.name": cost.model,
-            "agent_sdk.agent": agentName,
-          });
+          metrics?.cost.add(
+            cost.totalUsd,
+            join(event.sessionId, {
+              "cursor.model.name": cost.model,
+              "agent_sdk.agent": agentName,
+            })
+          );
         }
         turn.span.setStatus({ code: SpanStatusCode.OK });
         turn.span.end(startTime);
         sessions.get(event.sessionId)?.turns.delete(event.turnId);
-        metrics?.turns.add(1, {
-          "agent_sdk.agent": agentName,
-          "agent_sdk.turn_status": "completed",
-        });
+        metrics?.turns.add(
+          1,
+          join(event.sessionId, {
+            "agent_sdk.agent": agentName,
+            "agent_sdk.turn_status": "completed",
+          })
+        );
         emitLog(
           "turn.completed",
           SeverityNumber.INFO,
@@ -441,10 +474,13 @@ export function createOtelCollector(
         }
         turn.span.end(startTime);
         sessions.get(event.sessionId)?.turns.delete(event.turnId);
-        metrics?.turns.add(1, {
-          "agent_sdk.agent": agentName,
-          "agent_sdk.turn_status": "failed",
-        });
+        metrics?.turns.add(
+          1,
+          join(event.sessionId, {
+            "agent_sdk.agent": agentName,
+            "agent_sdk.turn_status": "failed",
+          })
+        );
         emitLog(
           "turn.failed",
           SeverityNumber.ERROR,
@@ -531,7 +567,7 @@ export function createOtelCollector(
       {
         kind: SpanKind.INTERNAL,
         startTime: args.startTime,
-        attributes: attrs({
+        attributes: join(args.sessionId, {
           "cursor.conversation.id": args.sessionId,
           "agent_sdk.agent": agentName,
           "agent_sdk.channel": args.channelId,
@@ -549,10 +585,13 @@ export function createOtelCollector(
     };
     sessions.set(args.sessionId, state);
     if (!args.restored) {
-      metrics?.sessions.add(1, {
-        "agent_sdk.agent": agentName,
-        "agent_sdk.channel": args.channelId,
-      });
+      metrics?.sessions.add(
+        1,
+        join(args.sessionId, {
+          "agent_sdk.agent": agentName,
+          "agent_sdk.channel": args.channelId,
+        })
+      );
     }
     return state;
   }
@@ -600,7 +639,7 @@ export function createOtelCollector(
       {
         kind: SpanKind.INTERNAL,
         startTime: args.startTime,
-        attributes: attrs({
+        attributes: join(args.sessionId, {
           "cursor.conversation.id": args.sessionId,
           "agent_sdk.agent": agentName,
           "agent_sdk.turn_id": args.turnId,
@@ -666,34 +705,77 @@ export function createOtelCollector(
     );
     state.span.end(args.endTime);
     sessions.delete(args.sessionId);
+    extraBySession.delete(args.sessionId);
   }
 
-  function recordTokens(usage: {
-    inputTokens: number;
-    outputTokens: number;
-    cacheReadTokens: number;
-    cacheWriteTokens: number;
-    reasoningTokens?: number;
-  }): void {
+  function extra(sessionId: string): Record<string, AttrValue> {
+    return extraBySession.get(sessionId) ?? {};
+  }
+
+  function join(
+    sessionId: string,
+    rest: Record<string, AttrValue | undefined>
+  ): Record<string, AttrValue> {
+    return attrs({ ...extra(sessionId), ...rest });
+  }
+
+  function paintOpenSpans(
+    sessionId: string,
+    incoming: Record<string, AttrValue>
+  ): void {
+    const state = sessions.get(sessionId);
+    if (state === undefined) {
+      return;
+    }
+    const painted = attrs(incoming);
+    if (Object.keys(painted).length === 0) {
+      return;
+    }
+    state.span.setAttributes(painted);
+    for (const turn of state.turns.values()) {
+      turn.span.setAttributes(painted);
+      for (const span of turn.tools.values()) {
+        span.setAttributes(painted);
+      }
+      for (const span of turn.subagents.values()) {
+        span.setAttributes(painted);
+      }
+    }
+  }
+
+  function recordTokens(
+    sessionId: string,
+    usage: {
+      inputTokens: number;
+      outputTokens: number;
+      cacheReadTokens: number;
+      cacheWriteTokens: number;
+      reasoningTokens?: number;
+    }
+  ): void {
     if (metrics === undefined) {
       return;
     }
     const agent = agentName;
     // Wire token types match enterprise export (`cache_creation`, not write).
-    addTokens(usage.inputTokens, "input", agent);
-    addTokens(usage.outputTokens, "output", agent);
-    addTokens(usage.cacheReadTokens, "cache_read", agent);
-    addTokens(usage.cacheWriteTokens, "cache_creation", agent);
+    addTokens(sessionId, usage.inputTokens, "input", agent);
+    addTokens(sessionId, usage.outputTokens, "output", agent);
+    addTokens(sessionId, usage.cacheReadTokens, "cache_read", agent);
+    addTokens(sessionId, usage.cacheWriteTokens, "cache_creation", agent);
     if (usage.reasoningTokens !== undefined) {
       // Reasoning is Agent-SDK-only; enterprise wire has no reasoning enum.
-      metrics.tokens.add(usage.reasoningTokens, {
-        "cursor.token.type": "reasoning",
-        "agent_sdk.agent": agent,
-      });
+      metrics.tokens.add(
+        usage.reasoningTokens,
+        join(sessionId, {
+          "cursor.token.type": "reasoning",
+          "agent_sdk.agent": agent,
+        })
+      );
     }
   }
 
   function addTokens(
+    sessionId: string,
     value: number,
     type: "input" | "output" | "cache_read" | "cache_creation",
     agent: string
@@ -701,10 +783,13 @@ export function createOtelCollector(
     if (metrics === undefined || value === 0) {
       return;
     }
-    metrics.tokens.add(value, {
-      "cursor.token.type": type,
-      "agent_sdk.agent": agent,
-    });
+    metrics.tokens.add(
+      value,
+      join(sessionId, {
+        "cursor.token.type": type,
+        "agent_sdk.agent": agent,
+      })
+    );
   }
 
   /** Content opt-in for failure text (same gate as tool payloads). */

package/src/internal/sdk-runner.ts

@@ -52,6 +52,7 @@ export type RunnerPrewarmRequest = Pick<
   | "workspaceDir"
   | "runnerStateDir"
   | "sandbox"
+  | "tools"
   | "mcpServers"
   | "subagents"
   | "model"
@@ -373,6 +374,11 @@ export class CursorSdkRunner implements AgentRunner {
       this.options.store ?? (await this.getStore(request.runnerStateDir));
     return {
       ...this.buildSharedOptions(request),
+      // The built-in tool allowlist rides AgentOptions, not `local`, and is
+      // deliberately absent from openCloudAgent's options: the SDK rejects
+      // tool restrictions on cloud agents. Passed on create *and* resume
+      // (both flow through here) — the SDK does not persist it across runs.
+      ...(request.tools === undefined ? {} : { tools: request.tools }),
       local: {
         cwd: request.workspaceDir,
         settingSources: ["project"],

package/src/internal/server.ts

@@ -17,6 +17,7 @@ import { join } from "node:path";
 import {
   type CursorGithubRepoScope,
   createCursorAccountGithubTokenResolver,
+  cursorGithubPermissionsForChannel,
   type GithubCursorAccountRuntime,
   getGithubCursorAccountRuntime,
   parseCursorGithubRepoScope,
@@ -435,6 +436,7 @@ export async function startServer(
       logger,
       platforms: hostPlatforms,
       otel: otelCollector,
+      otelMeter: otelRuntime?.meter,
     });
     // Rehydrate sessions from the authored storage sink before any
     // channel or route can address them (continuation tokens must resolve).
@@ -1868,8 +1870,11 @@ function resolveCursorGithubEventConfig(input: {
     ]),
   ];
   const permissions = resolveCursorGithubPermissions(
-    input.targets.map(
-      (target) => target.accountRuntime.scope?.permissions ?? "pr-write"
+    input.targets.map((target) =>
+      cursorGithubPermissionsForChannel(
+        target.accountRuntime.options,
+        target.accountRuntime.scope?.permissions
+      )
     )
   );
   const scope = parseCursorGithubRepoScope(repos, permissions);