@bitkyc08/opencodex 2.10.0 → 2.10.1

package/src/adapters/cursor/live-transport.ts

@@ -1,7 +1,7 @@
 import http2 from "node:http2";
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
 import { namespacedToolName, type OcxProviderConfig, type OcxUsage } from "../../types";
-import { CONNECT_FLAG_END_STREAM, decodeAvailableConnectFrames, encodeConnectFrame } from "./framing";
+import { CONNECT_FLAG_END_STREAM, ConnectFrameError, consumeConnectFrames, encodeConnectFrame } from "./framing";
 import {
   CURSOR_MAX_EFFECTIVE_CONNECT_PAYLOAD_BYTES,
   CURSOR_MAX_CONNECT_FRAME_BYTES,
@@ -787,6 +787,7 @@ class LiveCursorTransport implements CursorTransport {
       clearTimer: () => this.clearFirstFrameTimer(),
     });
     const failAndClear = (error: Error) => {
+      releaseBacklogLease();
       if (this.expectedClose) {
         // We already emitted a terminal `done` and cancelled the run (client-tool suspension). The
         // RST_STREAM CANCEL surfaces here as a stream error/abort; it is expected, not a failure.
@@ -822,28 +823,53 @@ class LiveCursorTransport implements CursorTransport {
       // close() waits for in-flight frames; a dead socket can ignore it — force-destroy shortly
       // after so a stalled TLS session cannot linger past the timeout.
       armTimeoutDestroyFallback(stream, session, this.input.timeoutDestroyGraceMs ?? CURSOR_TIMEOUT_DESTROY_GRACE_MS);
+      releaseBacklogLease();
       settler.settleFail(new Error("Cursor transport timed out before first response"));
     }, this.input.firstFrameTimeoutMs ?? CURSOR_FIRST_FRAME_TIMEOUT_MS);
 
-    let pending: Uint8Array<ArrayBufferLike> = new Uint8Array();
-    let frameWork: Promise<void> = Promise.resolve();
-    const reservePayloadCopy = (bytes: number) => {
-      if (this.transportBufferedBytes + bytes > CURSOR_TRANSPORT_MAX_BUFFERED_BYTES) {
-        throw new TranslatorBudgetExceededError("cursor_transport", CURSOR_TRANSPORT_MAX_BUFFERED_BYTES);
+    // Raw Connect backlog with a parse cursor: appends copy only the incoming
+    // chunk (amortized capacity growth), the consumed prefix is reclaimed
+    // lazily, and the RAW used length (headers included) is what the 32 MiB
+    // transport cap bounds — payload-only accounting let tiny-frame/header
+    // floods slip through.
+    let backlog = new Uint8Array();
+    let backlogStart = 0;
+    let backlogEnd = 0;
+    const BACKLOG_COMPACT_MIN_SAVINGS = 64 * 1024;
+    const appendBacklog = (chunk: Uint8Array): void => {
+      const used = backlogEnd - backlogStart;
+      let start = backlogStart;
+      let end = backlogEnd;
+      // Reclaim the consumed prefix when it is large or needed for capacity.
+      if (start > 0 && (start >= BACKLOG_COMPACT_MIN_SAVINGS || end + chunk.byteLength > backlog.byteLength)) {
+        backlog = backlog.slice(start, end);
+        start = 0;
+        end = used;
+      }
+      if (end + chunk.byteLength > backlog.byteLength) {
+        const capacity = Math.max(8192, backlog.byteLength * 2, end + chunk.byteLength);
+        const next = new Uint8Array(Math.min(CURSOR_TRANSPORT_MAX_BUFFERED_BYTES, capacity));
+        next.set(backlog.subarray(start, end), 0);
+        backlog = next;
       }
-      const reservation = this.translatorBudget.reserveTransient(bytes, { kind: "cursor_transport" });
-      this.transportBufferedBytes += bytes;
-      this.updateTransportFlowControl();
-      return {
-        commitRetained: () => reservation.commitRetained(),
-        release: () => {
-          reservation.release();
-          this.transportBufferedBytes = Math.max(0, this.transportBufferedBytes - bytes);
-          this.updateTransportFlowControl();
-        },
-      };
+      backlog.set(chunk, end);
+      backlogStart = start;
+      backlogEnd = end + chunk.byteLength;
+    };
+    let frameWork: Promise<void> = Promise.resolve();
+    // Idempotent terminal owner for the backlog lease: every settle/close path
+    // must leave the raw charge at zero instead of relying on budget disposal.
+    let backlogLeaseReleased = false;
+    const releaseBacklogLease = () => {
+      if (backlogLeaseReleased) return;
+      backlogLeaseReleased = true;
+      const leftover = backlogEnd - backlogStart;
+      if (leftover > 0) this.releaseTransportBytes(leftover);
+      backlog = new Uint8Array();
+      backlogStart = 0;
+      backlogEnd = 0;
     };
-    const handleFrame = async (frame: ReturnType<typeof decodeAvailableConnectFrames>["frames"][number]) => {
+    const handleFrame = async (frame: ReturnType<typeof consumeConnectFrames>["frames"][number]) => {
       this.framesReceived++;
       if ((frame.flags & CONNECT_FLAG_END_STREAM) === CONNECT_FLAG_END_STREAM) {
         const endError = parseConnectEndStreamError(frame.payload);
@@ -861,22 +887,25 @@ class LiveCursorTransport implements CursorTransport {
     };
     const drainPendingFrames = () => {
       const availableSlots = CURSOR_MAX_PENDING_FRAMES - this.pendingTransportFrames;
-      if (availableSlots <= 0 || pending.byteLength === 0) {
+      const used = backlogEnd - backlogStart;
+      if (availableSlots <= 0 || used === 0) {
         this.updateTransportFlowControl();
         return;
       }
-      const previousPayloadBytes = connectBufferedPayloadBytes(pending);
-      // The decoder materializes payload and residual copies. Keep the aggregate pending owner
-      // charged until every replacement has been admitted and committed; a failed admission must
-      // leave that predecessor lease intact for deterministic cleanup.
-      const decoded = decodeAvailableConnectFrames(
-        pending,
+      // Cursor decode, zero-copy: frame payloads are views into the backlog, so
+      // the charge TRANSFERS — only consumed header bytes leave the counter
+      // (payload bytes stay charged and are released when each frame's work
+      // finishes). An exact 16 MiB payload therefore peaks at 16 MiB + 5, not
+      // at double its size.
+      const decoded = consumeConnectFrames(
+        backlog.subarray(backlogStart, backlogEnd),
         CURSOR_MAX_EFFECTIVE_CONNECT_PAYLOAD_BYTES,
         availableSlots,
-        reservePayloadCopy,
       );
-      pending = decoded.remainder;
-      this.releaseTransportBytes(previousPayloadBytes);
+      if (decoded.frames.length > 0) {
+        backlogStart += decoded.consumedBytes;
+        this.releaseTransportBytes(decoded.consumedBytes - decoded.frames.reduce((n, frame) => n + frame.payload.byteLength, 0));
+      }
       for (const frame of decoded.frames) {
         this.pendingTransportFrames += 1;
         this.updateTransportFlowControl();
@@ -893,32 +922,31 @@ class LiveCursorTransport implements CursorTransport {
     };
     this.stream.on("data", chunk => {
       this.clearFirstFrameTimer();
+      // Once the turn has settled, late network bytes must never be charged —
+      // the backlog lease is already released and nobody would own these.
+      if (settler.settled()) return;
       if (!this.firstFrameLogged) {
         this.firstFrameLogged = true;
         this.firstFrameAt = Date.now();
         debugProviderDiagnostic("cursor", "first-frame", { latencyMs: this.firstFrameAt - this.turnStartedAt });
       }
       const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-      let incomingPayloadBytes = 0;
-      let incomingCharged = false;
-      let replacement: ReturnType<typeof reservePayloadCopy> | undefined;
+      let charged = false;
+      let appended = false;
       try {
-        const previousPendingPayloadBytes = connectBufferedPayloadBytes(pending);
-        const nextPendingPayloadBytes = connectBufferedPayloadBytesAcross(pending, bytes);
-        incomingPayloadBytes = Math.max(0, nextPendingPayloadBytes - previousPendingPayloadBytes);
-        this.reserveTransportBytes(incomingPayloadBytes);
-        incomingCharged = true;
-        replacement = reservePayloadCopy(nextPendingPayloadBytes);
-        const nextPending = concatBytes(pending, bytes);
-        pending = nextPending;
-        replacement.commitRetained();
-        replacement = undefined;
-        this.releaseTransportBytes(previousPendingPayloadBytes + incomingPayloadBytes);
-        incomingCharged = false;
+        // RAW chunk bytes (headers included) join the backlog charge; consumed
+        // bytes leave it at drain. No whole-backlog replacement copy anymore.
+        this.reserveTransportBytes(bytes.byteLength);
+        charged = true;
+        appendBacklog(bytes);
+        appended = true;
         drainPendingFrames();
       } catch (err) {
-        replacement?.release();
-        if (incomingCharged) this.releaseTransportBytes(incomingPayloadBytes);
+        // Release ONLY when the reservation succeeded but the append never
+        // happened. A failed reservation charged nothing — releasing here
+        // would debit unrelated existing ownership; an appended chunk is owned
+        // by the terminal backlog cleanup.
+        if (charged && !appended) this.releaseTransportBytes(bytes.byteLength);
         failAndClear(err instanceof Error ? err : new Error(String(err)));
       }
     });
@@ -954,15 +982,38 @@ class LiveCursorTransport implements CursorTransport {
         expectedClose: this.expectedClose,
         elapsedMs: Date.now() - this.turnStartedAt,
       });
-      // A zero-frame end without an expected close is an unexpected EOF (peer dropped the
-      // connection before any response frame) — surfacing it as success would silently
-      // swallow the turn (WP4 review blocker 1). With frames, the protobuf event state
-      // owns terminal semantics as before.
-      if (this.framesReceived === 0 && !this.expectedClose) {
-        settler.settleFail(new Error("Cursor stream ended before any response frame (unexpected EOF)"));
-        return;
-      }
-      settler.settleFinish();
+      // Settle only after queued frame work drains to quiescence (the chain can
+      // extend itself while draining), then classify the terminal state:
+      // a trailing incomplete frame is a typed failure, and a zero-frame,
+      // zero-byte end without an expected close stays the existing unexpected
+      // EOF — both beat the old silent success.
+      void (async () => {
+        let previous: Promise<void>;
+        do {
+          previous = frameWork;
+          await previous;
+        } while (previous !== frameWork);
+      })().then(() => {
+        if (settler.settled()) return;
+        const leftover = backlogEnd - backlogStart;
+        if (leftover > 0 && !this.expectedClose) {
+          releaseBacklogLease();
+          settler.settleFail(new ConnectFrameError(
+            "frame_incomplete",
+            `Cursor Connect stream ended with ${leftover} unconsumed bytes (incomplete frame)`,
+          ));
+          return;
+        }
+        if (this.framesReceived === 0 && !this.expectedClose) {
+          releaseBacklogLease();
+          settler.settleFail(new Error("Cursor stream ended before any response frame (unexpected EOF)"));
+          return;
+        }
+        releaseBacklogLease();
+        settler.settleFinish();
+      }, (err) => {
+        failAndClear(err instanceof Error ? err : new Error(String(err)));
+      });
     });
 
     signal?.addEventListener("abort", () => {
@@ -1140,47 +1191,6 @@ export function isClientToolFrame(message: AgentServerMessage): boolean {
   }
 }
 
-function concatBytes(a: Uint8Array, b: Uint8Array): Uint8Array {
-  const out = new Uint8Array(a.length + b.length);
-  out.set(a);
-  out.set(b, a.length);
-  return out;
-}
-
-function connectBufferedPayloadBytes(input: Uint8Array): number {
-  let offset = 0;
-  let payloadBytes = 0;
-  while (input.byteLength - offset >= 5) {
-    const length = new DataView(input.buffer, input.byteOffset + offset, input.byteLength - offset).getUint32(1, false);
-    const available = Math.min(length, input.byteLength - offset - 5);
-    payloadBytes += available;
-    if (available < length) break;
-    offset += 5 + length;
-  }
-  return payloadBytes;
-}
-
-/** Payload-byte count for a virtual concatenation, without allocating the concatenated buffer. */
-function connectBufferedPayloadBytesAcross(first: Uint8Array, second: Uint8Array): number {
-  const totalBytes = first.byteLength + second.byteLength;
-  const byteAt = (index: number): number => index < first.byteLength
-    ? first[index]!
-    : second[index - first.byteLength]!;
-  let offset = 0;
-  let payloadBytes = 0;
-  while (totalBytes - offset >= 5) {
-    const length = (byteAt(offset + 1) * 0x1000000)
-      + (byteAt(offset + 2) << 16)
-      + (byteAt(offset + 3) << 8)
-      + byteAt(offset + 4);
-    const available = Math.min(length, totalBytes - offset - 5);
-    payloadBytes += available;
-    if (available < length) break;
-    offset += 5 + length;
-  }
-  return payloadBytes;
-}
-
 /** Host-only label for Cursor transport diagnostics — never leaks path/query/credentials. */
 function cursorHostLabel(baseUrl: string): string {
   try {

package/src/adapters/cursor/native-exec.ts

@@ -128,6 +128,8 @@ const blobs = new Map<string, CursorBlobEntry>();
 const blobRequestScopes = new Map<CursorBlobRequestScopeToken, CursorBlobRequestScopeState>();
 let blobLimits = { ...DEFAULT_BLOB_LIMITS };
 let blobBytes = 0;
+/** Retained key-string bytes (separate from the payload cap — see key()). */
+let blobKeyBytes = 0;
 let blobLocalBytes = 0;
 let blobPinnedBytes = 0;
 let blobEvictableBytes = 0;
@@ -152,13 +154,16 @@ function recomputeBlobClassAccounting(): void {
   let pinnedBytes = 0;
   let evictableBytes = 0;
   let oldestAt: number | null = null;
-  for (const entry of blobs.values()) {
+  for (const [k, entry] of blobs) {
     const requestPinned = entry.requestPins.size > 0;
     const provenancePinned = entry.provenance === "remote-setBlobArgs" && !isExpired(entry, now);
     if (entry.provenance === "local-regenerated") localBytes += entry.sizeBytes;
-    if (requestPinned || provenancePinned) pinnedBytes += entry.sizeBytes;
+    // Key strings classify WITH their entry: a zero-payload blob must stay
+    // evictable/pinned exactly as its payload would be, or the budget cannot
+    // select it even though the total snapshot counts its key.
+    if (requestPinned || provenancePinned) pinnedBytes += entry.sizeBytes + k.length;
     if (!requestPinned && (entry.provenance === "local-regenerated" || isExpired(entry, now))) {
-      evictableBytes += entry.sizeBytes;
+      evictableBytes += entry.sizeBytes + k.length;
       oldestAt = oldestAt === null ? entry.storedAt : Math.min(oldestAt, entry.storedAt);
     }
   }
@@ -196,9 +201,12 @@ function deleteBlob(k: string, recompute = true): number {
   if (!entry) return 0;
   blobs.delete(k);
   blobBytes -= entry.sizeBytes;
+  blobKeyBytes -= k.length;
   for (const scope of entry.requestPins) blobRequestScopes.get(scope)?.keys.delete(k);
   if (recompute) recomputeBlobClassAccounting();
-  return entry.sizeBytes;
+  // Full logical release (payload + key): the retained-store snapshot counts
+  // both, so budget enforcement must see both leave.
+  return entry.sizeBytes + k.length;
 }
 
 function releaseHydratedBlob(k: string, requestScope?: CursorBlobRequestScopeToken): void {
@@ -313,6 +321,7 @@ function setBlob(
   if (blobs.has(k)) deleteBlob(k, false);
   blobs.set(k, entry);
   blobBytes += entry.sizeBytes;
+  blobKeyBytes += k.length;
   for (const scope of entry.requestPins) blobRequestScopes.get(scope)?.keys.add(k);
   reconcileBlobClassAccountingAndEnforce();
   return { admitted: true, replaced: existing !== undefined };
@@ -328,8 +337,20 @@ function getBlob(k: string): Uint8Array | undefined {
   return entry.data;
 }
 
+/**
+ * Raw blob IDs up to this size keep their hex passthrough (every ID the live
+ * protocol carries is a 32-byte digest). Anything larger maps to a fixed-size
+ * SHA-256 hex of the raw bytes — the derivation is symmetric across
+ * setBlobArgs/getBlobArgs, so the round-trip still works, but a hostile or
+ * malformed multi-MiB ID can never become an unbounded hex Map key.
+ * The `h:`/`d:` prefix domain-separates the two namespaces: a digested ID's
+ * key can never collide with a raw 32-byte ID that happens to BE that digest.
+ */
+const MAX_BLOB_ID_PASSTHROUGH_BYTES = 64;
+
 function key(bytes: Uint8Array): string {
-  return Buffer.from(bytes).toString("hex");
+  if (bytes.byteLength <= MAX_BLOB_ID_PASSTHROUGH_BYTES) return `h:${Buffer.from(bytes).toString("hex")}`;
+  return `d:${createHash("sha256").update(bytes).digest("hex")}`;
 }
 
 /**
@@ -382,6 +403,7 @@ export function storeCursorBlob(data: Uint8Array, requestScope?: CursorBlobReque
 export interface CursorBlobMetrics {
   count: number;
   totalBytes: number;
+  keyBytes: number;
   localBytes: number;
   pinnedBytes: number;
   rejectedEntryTooLarge: number;
@@ -393,6 +415,7 @@ export function cursorBlobMetrics(): CursorBlobMetrics {
   return {
     count: blobs.size,
     totalBytes: blobBytes,
+    keyBytes: blobKeyBytes,
     localBytes: blobLocalBytes,
     pinnedBytes: blobPinnedBytes,
     rejectedEntryTooLarge,
@@ -410,7 +433,9 @@ export function cursorBlobRetainedStoreSnapshot(): {
 } {
   return {
     count: blobs.size,
-    bytes: blobBytes,
+    // Payload + retained key strings: the framework must see everything the
+    // store retains. The 64 MiB admission cap stays payload-only by design.
+    bytes: blobBytes + blobKeyBytes,
     evictableBytes: blobEvictableBytes,
     pinnedBytes: blobPinnedBytes,
     oldestAt: blobOldestEvictableAt,
@@ -440,6 +465,7 @@ export function resetCursorBlobStateForTests(): void {
   blobs.clear();
   blobRequestScopes.clear();
   blobBytes = 0;
+  blobKeyBytes = 0;
   rejectedEntryTooLarge = 0;
   rejectedPinnedSaturation = 0;
   recomputeBlobClassAccounting();

package/src/adapters/cursor/protobuf-request.ts

@@ -621,6 +621,11 @@ function buildPreparedCursorRunRequest(
     tools: request.tools?.length ?? 0,
   });
 
+  const requestedModelParameters = [
+    ...(request.requestedModelParameters ?? []),
+    ...(request.routingLevel ? [{ id: CURSOR_ROUTING_LEVEL_PARAMETER_ID, value: request.routingLevel }] : []),
+  ];
+  const hasExplicitModelParameters = (request.requestedModelParameters?.length ?? 0) > 0;
   const runRequest = create(AgentRunRequestSchema, {
     conversationId: request.conversationId,
     conversationState: create(ConversationStateStructureSchema, {
@@ -637,24 +642,24 @@ function buildPreparedCursorRunRequest(
       readPaths: [],
     }),
     action,
-    modelDetails: create(ModelDetailsSchema, {
-      modelId: request.modelId,
-      displayModelId: request.modelId,
-      displayName: request.modelId,
-      displayNameShort: request.modelId,
-      aliases: [],
-    }),
-    // requested_model is currently a Cursor Router-only surface. External model clients still
-    // send model_details alone; sending both makes external workers reach stepCompleted and then
-    // reject the turn with invalid_argument.
-    ...(request.routingLevel ? {
+    // Explicit model-picker parameters follow current Cursor clients and use requested_model alone.
+    // Keep legacy model_details for flat model ids and the already-live Router path; sending both for
+    // a parameterized external model can resolve conflicting selections and end in invalid_argument.
+    ...(!hasExplicitModelParameters ? {
+      modelDetails: create(ModelDetailsSchema, {
+        modelId: request.modelId,
+        displayModelId: request.modelId,
+        displayName: request.modelId,
+        displayNameShort: request.modelId,
+        aliases: [],
+      }),
+    } : {}),
+    ...(requestedModelParameters.length > 0 ? {
       requestedModel: create(RequestedModelSchema, {
         modelId: request.modelId,
         maxMode: false,
-        parameters: [create(RequestedModel_ModelParameterbytesSchema, {
-          id: CURSOR_ROUTING_LEVEL_PARAMETER_ID,
-          value: request.routingLevel,
-        })],
+        parameters: requestedModelParameters.map(parameter =>
+          create(RequestedModel_ModelParameterbytesSchema, parameter)),
       }),
     } : {}),
     // Mirror the client (Responses) tool definitions into the top-level AgentRunRequest.mcp_tools

package/src/adapters/cursor/request-builder.ts

@@ -8,7 +8,7 @@ import type {
   OcxToolResultMessage,
 } from "../../types";
 import { isAllowedToolChoice, namespacedToolName, toolChoiceAliases, type OcxTool, type OcxToolChoice } from "../../types";
-import type { CursorRequestMessage, CursorRunRequest } from "./types";
+import type { CursorRequestMessage, CursorRequestedModelParameter, CursorRunRequest } from "./types";
 import { cursorWireModelSelection, type CursorRoutingLevel } from "./discovery";
 import { cursorEffortSuffix, cursorWireModelIdWithEffort } from "./effort-map";
 import {
@@ -117,16 +117,29 @@ function catalogLimitNote(kept: readonly OcxTool[], omitted: readonly OcxTool[])
 }
 
 /**
- * Resolve a `cursor/<model>` selection + Codex reasoning effort to the actual Cursor model id. Cursor
-* encodes the effort as a per-model suffix (`claude-4.6-opus-high`); `cursorEffortSuffix` picks the
- * right tier for that specific model (literal pass-through, with rank clamp fallback) or
-* `undefined` for non-reasoning models like `composer-2.5`. A fully-qualified id (one that isn't a
-* known effort base) passes through unchanged.
+ * Resolve a `cursor/<model>` selection + Codex reasoning effort to Cursor's requested model shape.
+ * Most models encode effort in a flat id (`claude-4.6-opus-high`). Grok 4.5 Fast is parameterized
+ * instead: current Cursor clients send the `grok-4.5` base id plus `effort` and `fast` parameters.
+ * A fully-qualified id (one that is not a known effort base) passes through unchanged.
  */
-function normalizeCursorModelId(modelId: string, reasoning?: string): { modelId: string; routingLevel?: CursorRoutingLevel } {
+function normalizeCursorModelId(modelId: string, reasoning?: string): {
+  modelId: string;
+  requestedModelParameters?: readonly CursorRequestedModelParameter[];
+  routingLevel?: CursorRoutingLevel;
+} {
   const selection = cursorWireModelSelection(modelId);
   const id = selection.modelId;
   const suffix = cursorEffortSuffix(id, reasoning);
+  if (id === "grok-4.5-fast" && suffix) {
+    return {
+      ...selection,
+      modelId: "grok-4.5",
+      requestedModelParameters: [
+        { id: "effort", value: suffix },
+        { id: "fast", value: "true" },
+      ],
+    };
+  }
   return { ...selection, modelId: suffix ? cursorWireModelIdWithEffort(id, suffix) : id };
 }
 
@@ -241,6 +254,7 @@ export function createCursorRequest(
   const model = normalizeCursorModelId(parsed.modelId, parsed.options.reasoning);
   return {
     modelId: model.modelId,
+    ...(model.requestedModelParameters ? { requestedModelParameters: model.requestedModelParameters } : {}),
     ...(model.routingLevel ? { routingLevel: model.routingLevel } : {}),
     conversationId: resolveCursorConversationId(parsed, model.modelId, options),
     system: [...(parsed.context.systemPrompt ?? []), ...(limitNote ? [limitNote] : [])],

package/src/adapters/cursor/types.ts

@@ -2,8 +2,15 @@ import type { OcxUsage } from "../../types";
 import type { OcxMessage, OcxRequestOptions, OcxTool } from "../../types";
 import type { CursorRoutingLevel } from "./discovery";
 
+export interface CursorRequestedModelParameter {
+  id: string;
+  value: string;
+}
+
 export interface CursorRunRequest {
   modelId: string;
+  /** Cursor model-picker parameters encoded through AgentRunRequest.requested_model. */
+  requestedModelParameters?: readonly CursorRequestedModelParameter[];
   /** Cursor Router optimization parameter; valid only while modelId is the `default` wire model. */
   routingLevel?: CursorRoutingLevel;
   conversationId: string;