braintrust 3.9.0 → 3.10.0

package/dist/workerd.mjs

@@ -1809,6 +1809,7 @@ var TopicMapData = z6.object({
   report_key: z6.string().optional(),
   topic_names: z6.record(z6.string()).optional(),
   generation_settings: TopicMapGenerationSettings.optional(),
+  disable_reconciliation: z6.boolean().optional(),
   distance_threshold: z6.number().optional()
 });
 var BatchedFacetData = z6.object({
@@ -2139,28 +2140,6 @@ var EnvVar = z6.object({
   secret_type: z6.union([z6.string(), z6.null()]).optional(),
   secret_category: z6.enum(["env_var", "ai_provider", "sandbox_provider"]).optional().default("env_var")
 });
-var EvalStatusPageTheme = z6.enum(["light", "dark"]);
-var EvalStatusPageConfig = z6.object({
-  score_columns: z6.union([z6.array(z6.string()), z6.null()]),
-  metric_columns: z6.union([z6.array(z6.string()), z6.null()]),
-  grouping_field: z6.union([z6.string(), z6.null()]),
-  filter: z6.union([z6.string(), z6.null()]),
-  sort_by: z6.union([z6.string(), z6.null()]),
-  sort_order: z6.union([z6.enum(["asc", "desc"]), z6.null()]),
-  api_key: z6.union([z6.string(), z6.null()])
-}).partial();
-var EvalStatusPage = z6.object({
-  id: z6.string().uuid(),
-  project_id: z6.string().uuid(),
-  user_id: z6.union([z6.string(), z6.null()]).optional(),
-  created: z6.union([z6.string(), z6.null()]).optional(),
-  deleted_at: z6.union([z6.string(), z6.null()]).optional(),
-  name: z6.string(),
-  description: z6.union([z6.string(), z6.null()]).optional(),
-  logo_url: z6.union([z6.string(), z6.null()]).optional(),
-  theme: EvalStatusPageTheme,
-  config: EvalStatusPageConfig
-});
 var RepoInfo = z6.union([
   z6.object({
     commit: z6.union([z6.string(), z6.null()]),
@@ -2187,6 +2166,15 @@ var Experiment = z6.object({
   deleted_at: z6.union([z6.string(), z6.null()]).optional(),
   dataset_id: z6.union([z6.string(), z6.null()]).optional(),
   dataset_version: z6.union([z6.string(), z6.null()]).optional(),
+  internal_metadata: z6.union([
+    z6.object({
+      dataset_filter: z6.union([
+        z6.object({}).partial().passthrough(),
+        z6.null()
+      ])
+    }).partial().passthrough(),
+    z6.null()
+  ]).optional(),
   parameters_id: z6.union([z6.string(), z6.null()]).optional(),
   parameters_version: z6.union([z6.string(), z6.null()]).optional(),
   public: z6.boolean(),
@@ -2923,14 +2911,21 @@ var ProjectAutomation = z6.object({
         z6.object({ type: z6.literal("log_spans") }),
         z6.object({ type: z6.literal("btql_query"), btql_query: z6.string() })
       ]),
+      scope: z6.union([SpanScope, TraceScope, GroupScope, z6.null()]).optional(),
       export_path: z6.string(),
       format: z6.enum(["jsonl", "parquet"]),
       interval_seconds: z6.number().gte(1).lte(2592e3),
-      credentials: z6.object({
-        type: z6.literal("aws_iam"),
-        role_arn: z6.string(),
-        external_id: z6.string()
-      }),
+      credentials: z6.union([
+        z6.object({
+          type: z6.literal("aws_iam"),
+          role_arn: z6.string(),
+          external_id: z6.string()
+        }),
+        z6.object({
+          type: z6.literal("gcp_service_account"),
+          service_account_email: z6.string()
+        })
+      ]),
       batch_size: z6.union([z6.number(), z6.null()]).optional()
     }),
     z6.object({
@@ -3310,7 +3305,7 @@ var ViewOptions = z6.union([
       z6.object({ from: z6.string(), to: z6.string() }),
       z6.null()
     ]),
-    queryShape: z6.union([z6.enum(["traces", "spans"]), z6.null()]),
+    queryShape: z6.union([z6.enum(["traces", "spans", "topics"]), z6.null()]),
     cluster: z6.union([z6.string(), z6.null()]),
     freezeColumns: z6.union([z6.boolean(), z6.null()])
   }).partial(),
@@ -4326,6 +4321,19 @@ var RESET_CONTEXT_MANAGER_STATE = Symbol.for(
   "braintrust.resetContextManagerState"
 );
 var DEFAULT_MAX_REQUEST_SIZE = 6 * 1024 * 1024;
+var datasetSnapshotRegisterResponseSchema = z8.object({
+  dataset_snapshot: DatasetSnapshot,
+  found_existing: z8.boolean().optional()
+});
+var datasetRestorePreviewResultSchema = z8.object({
+  rows_to_restore: z8.number(),
+  rows_to_delete: z8.number()
+});
+var datasetRestoreResultSchema = z8.object({
+  xact_id: z8.string().nullable(),
+  rows_restored: z8.number(),
+  rows_deleted: z8.number()
+});
 var parametersRowSchema = z8.object({
   id: z8.string().uuid(),
   _xact_id: z8.string(),
@@ -6547,6 +6555,33 @@ Error: ${errorText}`;
     this.queue.enforceQueueSizeLimit(enforce);
   }
 };
+function isDatasetSnapshotNameLookup(lookup) {
+  return "snapshotName" in lookup;
+}
+function assertDatasetSnapshotLookup(lookup) {
+  const hasSnapshotName = lookup.snapshotName !== void 0;
+  const hasXactId = lookup.xactId !== void 0;
+  if (hasSnapshotName === hasXactId) {
+    throw new Error("Exactly one of snapshotName or xactId must be provided");
+  }
+}
+function getExperimentDatasetFilter({
+  dataset,
+  _internal_btql
+}) {
+  if (_internal_btql !== void 0) {
+    return _internal_btql;
+  }
+  if (!(dataset instanceof Dataset2)) {
+    return void 0;
+  }
+  const datasetFilter = Reflect.get(dataset, "_internal_btql");
+  return isObject(datasetFilter) ? datasetFilter : void 0;
+}
+function getInternalBtqlLimit(internalBtql) {
+  const limit = internalBtql?.["limit"];
+  return typeof limit === "number" ? limit : void 0;
+}
 function init(projectOrOptions, optionalOptions) {
   const options = (() => {
     if (typeof projectOrOptions === "string") {
@@ -6565,6 +6600,7 @@ function init(projectOrOptions, optionalOptions) {
     experiment,
     description,
     dataset,
+    _internal_btql,
     parameters,
     baseExperiment,
     isPublic,
@@ -6673,16 +6709,24 @@ function init(projectOrOptions, optionalOptions) {
         args["ancestor_commits"] = await isomorph_default.getPastNAncestors();
       }
       if (dataset !== void 0) {
-        if ("id" in dataset && typeof dataset.id === "string" && !("__braintrust_dataset_marker" in dataset)) {
-          args["dataset_id"] = dataset.id;
-          if ("version" in dataset && dataset.version !== void 0) {
-            args["dataset_version"] = dataset.version;
-          }
-        } else {
-          args["dataset_id"] = await dataset.id;
-          args["dataset_version"] = await dataset.version();
+        const datasetSelection = await serializeDatasetForExperiment({
+          dataset,
+          state
+        });
+        args["dataset_id"] = datasetSelection.datasetId;
+        if (datasetSelection.datasetVersion !== void 0) {
+          args["dataset_version"] = datasetSelection.datasetVersion;
         }
       }
+      const datasetFilter = getExperimentDatasetFilter({
+        dataset,
+        _internal_btql
+      });
+      if (datasetFilter !== void 0) {
+        args["internal_metadata"] = {
+          dataset_filter: datasetFilter
+        };
+      }
       if (parameters !== void 0) {
         if (RemoteEvalParameters.isParameters(parameters)) {
           args["parameters_id"] = parameters.id;
@@ -6736,7 +6780,7 @@ function init(projectOrOptions, optionalOptions) {
   const ret = new Experiment2(
     state,
     lazyMetadata,
-    dataset !== void 0 && "version" in dataset ? dataset : void 0
+    dataset !== void 0 ? dataset : void 0
   );
   if (options.setCurrent ?? true) {
     state.currentExperiment = ret;
@@ -6772,6 +6816,153 @@ function withLogger(callback, options = {}) {
   const logger = initLogger(options);
   return callback(logger);
 }
+async function getDatasetSnapshots(params) {
+  const { state, datasetId } = params;
+  return DatasetSnapshot.array().parse(
+    await state.appConn().post_json("api/dataset_snapshot/get", {
+      dataset_id: datasetId,
+      ..."snapshotName" in params ? { name: params.snapshotName } : {},
+      ..."xactId" in params ? { xact_id: params.xactId } : {}
+    })
+  );
+}
+async function getDatasetSnapshot(params) {
+  assertDatasetSnapshotLookup(params);
+  const snapshots = await getDatasetSnapshots(params);
+  if (snapshots.length > 1) {
+    throw new Error(
+      isDatasetSnapshotNameLookup(params) ? `Expected a unique dataset snapshot named "${params.snapshotName}" for ${params.datasetId}` : `Expected a unique dataset snapshot for xact_id "${params.xactId}" in ${params.datasetId}`
+    );
+  }
+  return snapshots[0];
+}
+function normalizeDatasetSelection({
+  version,
+  environment,
+  snapshotName
+}) {
+  if (version !== void 0) {
+    return { version };
+  }
+  if (snapshotName !== void 0) {
+    return { snapshotName };
+  }
+  if (environment !== void 0) {
+    return { environment };
+  }
+  return {};
+}
+async function resolveDatasetSnapshotName({
+  state,
+  datasetId,
+  snapshotName
+}) {
+  const match = await getDatasetSnapshot({
+    state,
+    datasetId,
+    snapshotName
+  });
+  if (match === void 0) {
+    throw new Error(
+      `Dataset snapshot "${snapshotName}" not found for ${datasetId}`
+    );
+  }
+  return match.xact_id;
+}
+async function resolveDatasetSnapshotNameForMetadata({
+  state,
+  lazyMetadata,
+  snapshotName
+}) {
+  const metadata = await lazyMetadata.get();
+  return await resolveDatasetSnapshotName({
+    state,
+    datasetId: metadata.dataset.id,
+    snapshotName
+  });
+}
+async function resolveDatasetEnvironment({
+  state,
+  datasetId,
+  environment
+}) {
+  const environmentObjectPath = `environment-object/dataset/${datasetId}/${encodeURIComponent(environment)}`;
+  const response = state.orgName == null ? await state.apiConn().get_json(environmentObjectPath) : await state.apiConn().get_json(environmentObjectPath, {
+    org_name: state.orgName
+  });
+  return z8.object({ object_version: z8.string() }).parse(response).object_version;
+}
+async function resolveDatasetEnvironmentForMetadata({
+  state,
+  lazyMetadata,
+  environment
+}) {
+  const metadata = await lazyMetadata.get();
+  return await resolveDatasetEnvironment({
+    state,
+    datasetId: metadata.dataset.id,
+    environment
+  });
+}
+async function serializeDatasetForExperiment({
+  dataset,
+  state
+}) {
+  if (!Dataset2.isDataset(dataset)) {
+    const selection2 = normalizeDatasetSelection(dataset);
+    if (selection2.version !== void 0) {
+      return {
+        datasetId: dataset.id,
+        datasetVersion: selection2.version
+      };
+    }
+    if (selection2.snapshotName !== void 0) {
+      return {
+        datasetId: dataset.id,
+        datasetVersion: await resolveDatasetSnapshotName({
+          state,
+          datasetId: dataset.id,
+          snapshotName: selection2.snapshotName
+        })
+      };
+    }
+    if (selection2.environment !== void 0) {
+      return {
+        datasetId: dataset.id,
+        datasetVersion: await resolveDatasetEnvironment({
+          state,
+          datasetId: dataset.id,
+          environment: selection2.environment
+        })
+      };
+    }
+    return {
+      datasetId: dataset.id
+    };
+  }
+  const evalData = await dataset.toEvalData();
+  const selection = normalizeDatasetSelection({
+    version: evalData.dataset_version,
+    environment: evalData.dataset_environment,
+    snapshotName: evalData.dataset_snapshot_name
+  });
+  if (selection.version !== void 0) {
+    return {
+      datasetId: evalData.dataset_id,
+      datasetVersion: selection.version
+    };
+  }
+  const datasetVersion = await dataset.version();
+  if (datasetVersion !== void 0) {
+    return {
+      datasetId: evalData.dataset_id,
+      datasetVersion
+    };
+  }
+  return {
+    datasetId: evalData.dataset_id
+  };
+}
 function initDataset(projectOrOptions, optionalOptions) {
   const options = (() => {
     if (typeof projectOrOptions === "string") {
@@ -6790,6 +6981,8 @@ function initDataset(projectOrOptions, optionalOptions) {
     dataset,
     description,
     version,
+    snapshotName,
+    environment,
     appUrl,
     apiKey,
     orgName,
@@ -6801,6 +6994,14 @@ function initDataset(projectOrOptions, optionalOptions) {
     state: stateArg,
     _internal_btql
   } = options;
+  const selection = normalizeDatasetSelection({
+    version,
+    environment,
+    snapshotName
+  });
+  const normalizedVersion = selection.version;
+  const normalizedEnvironment = selection.environment;
+  const normalizedSnapshotName = selection.snapshotName;
   const state = stateArg ?? _globalState;
   const lazyMetadata = new LazyValue(
     async () => {
@@ -6834,13 +7035,38 @@ function initDataset(projectOrOptions, optionalOptions) {
       };
     }
   );
-  return new Dataset2(
+  const resolvedVersion = normalizedVersion !== void 0 ? normalizedVersion : normalizedSnapshotName !== void 0 ? new LazyValue(async () => {
+    return await resolveDatasetSnapshotNameForMetadata({
+      state,
+      lazyMetadata,
+      snapshotName: normalizedSnapshotName
+    });
+  }) : normalizedEnvironment !== void 0 ? new LazyValue(async () => {
+    return await resolveDatasetEnvironmentForMetadata({
+      state,
+      lazyMetadata,
+      environment: normalizedEnvironment
+    });
+  }) : void 0;
+  const datasetObject = new Dataset2(
     stateArg ?? _globalState,
     lazyMetadata,
-    version,
+    typeof resolvedVersion === "string" ? resolvedVersion : void 0,
     legacy,
-    _internal_btql
+    _internal_btql,
+    resolvedVersion instanceof LazyValue || normalizedEnvironment !== void 0 || normalizedSnapshotName !== void 0 ? {
+      ...resolvedVersion instanceof LazyValue ? {
+        lazyPinnedVersion: resolvedVersion
+      } : {},
+      ...normalizedEnvironment !== void 0 ? {
+        pinnedEnvironment: normalizedEnvironment
+      } : {},
+      ...normalizedSnapshotName !== void 0 ? {
+        pinnedSnapshotName: normalizedSnapshotName
+      } : {}
+    } : void 0
   );
+  return datasetObject;
 }
 function withDataset(project, callback, options = {}) {
   debugLogger.forState(options.state).warn(
@@ -7836,11 +8062,20 @@ var ObjectFetcher = class {
   async getState() {
     throw new Error("ObjectFetcher subclasses must have a 'getState' method");
   }
+  getPinnedVersion() {
+    return this.pinnedVersion;
+  }
+  setPinnedVersion(pinnedVersion) {
+    this.pinnedVersion = pinnedVersion;
+  }
+  getInternalBtql() {
+    return this._internal_btql;
+  }
   async *fetchRecordsFromApi(batchSize) {
     const state = await this.getState();
     const objectId = await this.id;
     const batchLimit = batchSize ?? DEFAULT_FETCH_BATCH_SIZE;
-    const internalLimit = this._internal_btql?.limit;
+    const internalLimit = getInternalBtqlLimit(this._internal_btql);
     const limit = batchSize !== void 0 ? batchSize : internalLimit ?? batchLimit;
     const internalBtqlWithoutReservedQueryKeys = Object.fromEntries(
       Object.entries(this._internal_btql ?? {}).filter(
@@ -8654,7 +8889,7 @@ function splitLoggingData({
   return [serializableInternalData, lazyInternalData];
 }
 var Dataset2 = class extends ObjectFetcher {
-  constructor(state, lazyMetadata, pinnedVersion, legacy, _internal_btql) {
+  constructor(state, lazyMetadata, pinnedVersion, legacy, _internal_btql, pinState) {
     const isLegacyDataset = legacy ?? DEFAULT_IS_LEGACY_DATASET;
     if (isLegacyDataset) {
       debugLogger.forState(state).warn(
@@ -8675,10 +8910,16 @@ var Dataset2 = class extends ObjectFetcher {
     );
     this.state = state;
     this.lazyMetadata = lazyMetadata;
+    this.lazyPinnedVersion = pinState?.lazyPinnedVersion;
+    this.pinnedEnvironment = pinState?.pinnedEnvironment;
+    this.pinnedSnapshotName = pinState?.pinnedSnapshotName;
   }
   lazyMetadata;
   __braintrust_dataset_marker = true;
   newRecords = 0;
+  lazyPinnedVersion;
+  pinnedEnvironment;
+  pinnedSnapshotName;
   get id() {
     return (async () => {
       return (await this.lazyMetadata.get()).dataset.id;
@@ -8697,10 +8938,40 @@ var Dataset2 = class extends ObjectFetcher {
   get loggingState() {
     return this.state;
   }
+  async toEvalData() {
+    await this.getState();
+    const metadata = await this.lazyMetadata.get();
+    const pinnedVersion = this.getPinnedVersion();
+    const internalBtql = this.getInternalBtql();
+    return {
+      dataset_id: metadata.dataset.id,
+      ...this.pinnedEnvironment !== void 0 ? {
+        dataset_environment: this.pinnedEnvironment
+      } : {},
+      ...this.pinnedEnvironment === void 0 && this.pinnedSnapshotName !== void 0 ? {
+        dataset_snapshot_name: this.pinnedSnapshotName
+      } : {},
+      ...this.pinnedEnvironment === void 0 && this.pinnedSnapshotName === void 0 && pinnedVersion !== void 0 ? {
+        dataset_version: pinnedVersion
+      } : {},
+      ...internalBtql !== void 0 ? { _internal_btql: internalBtql } : {}
+    };
+  }
   async getState() {
     await this.lazyMetadata.get();
+    if (this.lazyPinnedVersion !== void 0 && this.getPinnedVersion() === void 0) {
+      this.setPinnedVersion(await this.lazyPinnedVersion.get());
+    }
     return this.state;
   }
+  async version(options) {
+    const pinnedVersion = this.getPinnedVersion();
+    if (pinnedVersion !== void 0) {
+      return pinnedVersion;
+    }
+    await this.getState();
+    return await super.version(options);
+  }
   validateEvent({
     metadata,
     expected,
@@ -8836,6 +9107,88 @@ var Dataset2 = class extends ObjectFetcher {
     this.state.bgLogger().log([args]);
     return id;
   }
+  async createSnapshot({
+    name,
+    description,
+    update
+  }) {
+    await this.flush();
+    const state = await this.getState();
+    const datasetId = await this.id;
+    const currentVersion = await this.version();
+    if (currentVersion === void 0) {
+      throw new Error("Cannot create snapshot: dataset has no version");
+    }
+    const response = await state.appConn().post_json("api/dataset_snapshot/register", {
+      dataset_id: datasetId,
+      dataset_snapshot_name: name,
+      description,
+      xact_id: currentVersion,
+      update
+    });
+    return datasetSnapshotRegisterResponseSchema.parse(response).dataset_snapshot;
+  }
+  async listSnapshots() {
+    const state = await this.getState();
+    return await getDatasetSnapshots({
+      state,
+      datasetId: await this.id
+    });
+  }
+  async getSnapshot(lookup) {
+    const state = await this.getState();
+    const datasetId = await this.id;
+    return await getDatasetSnapshot({
+      state,
+      datasetId,
+      ...lookup
+    });
+  }
+  async updateSnapshot(snapshotId, {
+    name,
+    description
+  }) {
+    const state = await this.getState();
+    return DatasetSnapshot.parse(
+      await state.appConn().post_json("api/dataset_snapshot/patch_id", {
+        id: snapshotId,
+        name,
+        description
+      })
+    );
+  }
+  async deleteSnapshot(snapshotId) {
+    const state = await this.getState();
+    return DatasetSnapshot.parse(
+      await state.appConn().post_json("api/dataset_snapshot/delete_id", {
+        id: snapshotId
+      })
+    );
+  }
+  async restorePreview({
+    version
+  }) {
+    await this.flush();
+    const state = await this.getState();
+    const datasetId = await this.id;
+    return datasetRestorePreviewResultSchema.parse(
+      await state.apiConn().post_json(`v1/dataset/${datasetId}/restore/preview`, {
+        version
+      })
+    );
+  }
+  async restore({
+    version
+  }) {
+    await this.flush();
+    const state = await this.getState();
+    const datasetId = await this.id;
+    return datasetRestoreResultSchema.parse(
+      await state.apiConn().post_json(`v1/dataset/${datasetId}/restore`, {
+        version
+      })
+    );
+  }
   /**
    * Summarize the dataset, including high level metrics about its size and other metadata.
    * @param summarizeData Whether to summarize the data. If false, only the metadata will be returned.
@@ -14212,6 +14565,9 @@ function llmParentKey(parentToolUseId) {
 function isSubAgentDelegationToolName(toolName) {
   return toolName === "Agent" || toolName === "Task";
 }
+function shouldParentToolAsTaskSibling(toolName) {
+  return toolName === "Agent" || toolName === "Task" || toolName === "Bash";
+}
 function filterSerializableOptions(options) {
   const allowedKeys = [
     "model",
@@ -14311,6 +14667,11 @@ function resolveTaskToolUseId(taskIdToToolUseId, message) {
   }
   return void 0;
 }
+function seedTaskToolUseIdMapping(taskIdToToolUseId, message) {
+  if (typeof message.task_id === "string" && typeof message.tool_use_id === "string") {
+    taskIdToToolUseId.set(message.task_id, message.tool_use_id);
+  }
+}
 function extractUsageFromMessage(message) {
   const metrics = {};
   let usage;
@@ -14506,7 +14867,10 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
         }
       },
       name: parsed.displayName,
-      parent: await resolveParentSpan(toolUseID),
+      parent: await resolveParentSpan(toolUseID, {
+        agentId: input.agent_id,
+        preferTaskSiblingParent: shouldParentToolAsTaskSibling(parsed.toolName)
+      }),
       spanAttributes: { type: "tool" /* TOOL */ }
     });
     activeToolSpans.set(toolUseID, toolSpan);
@@ -14796,6 +15160,7 @@ async function finalizeCurrentMessageGroup(state) {
   state.currentMessages.length = 0;
 }
 function maybeTrackToolUseContext(state, message) {
+  seedTaskToolUseIdMapping(state.taskIdToToolUseId, message);
   if (message.type !== "assistant" || !Array.isArray(message.message?.content)) {
     return;
   }
@@ -14850,6 +15215,34 @@ async function ensureSubAgentSpan(subAgentDetailsByToolUseId, rootSpan, activeTo
   subAgentSpans.set(parentToolUseId, subAgentSpan);
   return subAgentSpan;
 }
+async function ensureActiveLlmSpanForParentToolUse(rootSpan, activeLlmSpansByParentToolUse, subAgentDetailsByToolUseId, activeToolSpans, subAgentSpans, parentToolUseId, startTime) {
+  const parentKey = llmParentKey(parentToolUseId);
+  const existingLlmSpan = activeLlmSpansByParentToolUse.get(parentKey);
+  if (existingLlmSpan) {
+    return existingLlmSpan;
+  }
+  let llmParentSpan = await rootSpan.export();
+  if (parentToolUseId) {
+    const subAgentSpan = await ensureSubAgentSpan(
+      subAgentDetailsByToolUseId,
+      rootSpan,
+      activeToolSpans,
+      subAgentSpans,
+      parentToolUseId
+    );
+    llmParentSpan = await subAgentSpan.export();
+  }
+  const llmSpan = startSpan({
+    name: "anthropic.messages.create",
+    parent: llmParentSpan,
+    spanAttributes: {
+      type: "llm" /* LLM */
+    },
+    startTime
+  });
+  activeLlmSpansByParentToolUse.set(parentKey, llmSpan);
+  return llmSpan;
+}
 async function maybeHandleTaskLifecycleMessage(state, message) {
   if (message.type !== "system") {
     return false;
@@ -14959,29 +15352,15 @@ async function handleStreamMessage(state, message) {
   }
   if (message.type === "assistant" && message.message?.usage) {
     const parentToolUseId = message.parent_tool_use_id ?? null;
-    const parentKey = llmParentKey(parentToolUseId);
-    if (!state.activeLlmSpansByParentToolUse.has(parentKey)) {
-      let llmParentSpan = await state.span.export();
-      if (parentToolUseId) {
-        const subAgentSpan = await ensureSubAgentSpan(
-          state.subAgentDetailsByToolUseId,
-          state.span,
-          state.activeToolSpans,
-          state.subAgentSpans,
-          parentToolUseId
-        );
-        llmParentSpan = await subAgentSpan.export();
-      }
-      const llmSpan = startSpan({
-        name: "anthropic.messages.create",
-        parent: llmParentSpan,
-        spanAttributes: {
-          type: "llm" /* LLM */
-        },
-        startTime: state.currentMessageStartTime
-      });
-      state.activeLlmSpansByParentToolUse.set(parentKey, llmSpan);
-    }
+    await ensureActiveLlmSpanForParentToolUse(
+      state.span,
+      state.activeLlmSpansByParentToolUse,
+      state.subAgentDetailsByToolUseId,
+      state.activeToolSpans,
+      state.subAgentSpans,
+      parentToolUseId,
+      state.currentMessageStartTime
+    );
     state.currentMessages.push(message);
   }
   if (message.type !== "result" || !message.usage) {
@@ -15128,10 +15507,35 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         const localToolContext = createClaudeLocalToolContext();
         const { hasLocalToolHandlers, localToolHookNames } = prepareLocalToolHandlersInMcpServers(options.mcpServers);
         const skipLocalToolHooks = options[CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION] === true || hasLocalToolHandlers;
-        const resolveToolUseParentSpan = async (toolUseID) => {
-          const parentToolUseId = toolUseToParent.get(toolUseID) ?? null;
+        const resolveToolUseParentSpan = async (toolUseID, context) => {
+          const trackedParentToolUseId = toolUseToParent.get(toolUseID);
+          const parentToolUseId = trackedParentToolUseId ?? (context?.agentId ? taskIdToToolUseId.get(context.agentId) ?? null : null);
           const parentKey = llmParentKey(parentToolUseId);
           const activeLlmSpan = activeLlmSpansByParentToolUse.get(parentKey);
+          if (context?.preferTaskSiblingParent) {
+            if (!activeLlmSpan) {
+              await ensureActiveLlmSpanForParentToolUse(
+                span,
+                activeLlmSpansByParentToolUse,
+                subAgentDetailsByToolUseId,
+                activeToolSpans,
+                subAgentSpans,
+                parentToolUseId,
+                getCurrentUnixTimestamp()
+              );
+            }
+            if (parentToolUseId) {
+              const subAgentSpan = await ensureSubAgentSpan(
+                subAgentDetailsByToolUseId,
+                span,
+                activeToolSpans,
+                subAgentSpans,
+                parentToolUseId
+              );
+              return subAgentSpan.export();
+            }
+            return span.export();
+          }
           if (activeLlmSpan) {
             return activeLlmSpan.export();
           }
@@ -15259,62 +15663,940 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
   }
 };
 
-// src/instrumentation/plugins/google-genai-channels.ts
-var googleGenAIChannels = defineChannels("@google/genai", {
-  generateContent: channel({
-    channelName: "models.generateContent",
+// src/instrumentation/plugins/cursor-sdk-channels.ts
+var cursorSDKChannels = defineChannels("@cursor/sdk", {
+  create: channel({
+    channelName: "Agent.create",
     kind: "async"
   }),
-  generateContentStream: channel({
-    channelName: "models.generateContentStream",
+  resume: channel({
+    channelName: "Agent.resume",
     kind: "async"
   }),
-  embedContent: channel({
-    channelName: "models.embedContent",
+  prompt: channel({
+    channelName: "Agent.prompt",
+    kind: "async"
+  }),
+  send: channel({
+    channelName: "agent.send",
     kind: "async"
   })
 });
 
-// src/instrumentation/plugins/google-genai-plugin.ts
-var GOOGLE_GENAI_INTERNAL_CONTEXT = {
-  caller_filename: "<node-internal>",
-  caller_functionname: "<node-internal>",
-  caller_lineno: 0
-};
-function createWrapperParityEvent(args) {
-  return {
-    context: GOOGLE_GENAI_INTERNAL_CONTEXT,
-    input: args.input,
-    metadata: args.metadata
-  };
-}
-var GoogleGenAIPlugin = class extends BasePlugin {
+// src/instrumentation/plugins/cursor-sdk-plugin.ts
+var PATCHED_AGENT = Symbol.for("braintrust.cursor-sdk.auto-patched-agent");
+var PATCHED_RUN = Symbol.for("braintrust.cursor-sdk.patched-run");
+var WRAPPED_AGENT = Symbol.for("braintrust.cursor-sdk.wrapped-agent");
+var CursorSDKPlugin = class extends BasePlugin {
+  promptDepth = 0;
   onEnable() {
-    this.subscribeToGoogleGenAIChannels();
+    this.subscribeToAgentFactories();
+    this.subscribeToPrompt();
+    this.subscribeToSend();
   }
   onDisable() {
-    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+    this.promptDepth = 0;
   }
-  subscribeToGoogleGenAIChannels() {
-    this.subscribeToGenerateContentChannel();
-    this.subscribeToGenerateContentStreamChannel();
-    this.subscribeToEmbedContentChannel();
+  subscribeToAgentFactories() {
+    this.subscribeToAgentFactory(cursorSDKChannels.create);
+    this.subscribeToAgentFactory(cursorSDKChannels.resume);
   }
-  subscribeToGenerateContentChannel() {
-    const tracingChannel2 = googleGenAIChannels.generateContent.tracingChannel();
+  subscribeToAgentFactory(channel2) {
+    const tracingChannel2 = channel2.tracingChannel();
+    const handlers = {
+      asyncEnd: (event) => {
+        patchCursorAgentInPlace(event.result);
+      },
+      error: () => {
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToPrompt() {
+    const channel2 = cursorSDKChannels.prompt.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
-    const unbindCurrentSpanStore = bindCurrentSpanStoreToStart2(
-      tracingChannel2,
-      states,
-      (event) => {
-        const params = event.arguments[0];
-        const input = serializeGenerateContentInput(params);
-        const metadata = extractGenerateContentMetadata(params);
+    const handlers = {
+      start: (event) => {
+        this.promptDepth += 1;
+        const message = event.arguments[0];
+        const options = event.arguments[1];
+        const metadata = {
+          ...extractAgentOptionsMetadata(options),
+          "cursor_sdk.operation": "Agent.prompt",
+          provider: "cursor",
+          ...event.moduleVersion ? { "cursor_sdk.version": event.moduleVersion } : {}
+        };
         const span = startSpan({
-          name: "generate_content",
-          spanAttributes: {
-            type: "llm" /* LLM */
-          },
+          name: "Cursor Agent",
+          spanAttributes: { type: "task" /* TASK */ }
+        });
+        const startTime = getCurrentUnixTimestamp();
+        safeLog(span, {
+          input: sanitizeUserMessage(message),
+          metadata
+        });
+        states.set(event, { metadata, span, startTime });
+      },
+      asyncEnd: (event) => {
+        this.promptDepth = Math.max(0, this.promptDepth - 1);
+        const state = states.get(event);
+        if (!state) {
+          return;
+        }
+        try {
+          safeLog(state.span, {
+            metadata: {
+              ...state.metadata,
+              ...extractRunResultMetadata(event.result)
+            },
+            metrics: buildDurationMetrics(state.startTime),
+            output: event.result?.result ?? event.result
+          });
+        } finally {
+          state.span.end();
+          states.delete(event);
+        }
+      },
+      error: (event) => {
+        this.promptDepth = Math.max(0, this.promptDepth - 1);
+        const state = states.get(event);
+        if (!state || !event.error) {
+          return;
+        }
+        safeLog(state.span, { error: event.error.message });
+        state.span.end();
+        states.delete(event);
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToSend() {
+    const channel2 = cursorSDKChannels.send.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const handlers = {
+      start: (event) => {
+        if (this.promptDepth > 0) {
+          return;
+        }
+        const message = event.arguments[0];
+        const sendOptions = event.arguments[1];
+        const agent = event.agent;
+        const metadata = {
+          ...extractSendMetadata(sendOptions),
+          ...agent ? extractAgentMetadata(agent) : {},
+          "cursor_sdk.operation": "agent.send",
+          provider: "cursor",
+          ...event.moduleVersion ? { "cursor_sdk.version": event.moduleVersion } : {}
+        };
+        const span = startSpan({
+          name: "Cursor Agent",
+          spanAttributes: { type: "task" /* TASK */ }
+        });
+        const startTime = getCurrentUnixTimestamp();
+        safeLog(span, {
+          input: sanitizeUserMessage(message),
+          metadata
+        });
+        const state = {
+          activeToolSpans: /* @__PURE__ */ new Map(),
+          agent,
+          conversationText: [],
+          deltaText: [],
+          finalized: false,
+          input: message,
+          metadata,
+          metrics: {},
+          span,
+          startTime,
+          streamMessages: [],
+          streamText: [],
+          stepText: [],
+          taskText: []
+        };
+        if (hasCursorCallbacks(sendOptions)) {
+          event.arguments[1] = wrapSendOptionsCallbacks(sendOptions, state);
+        }
+        states.set(event, state);
+      },
+      asyncEnd: (event) => {
+        const state = states.get(event);
+        if (!state) {
+          return;
+        }
+        if (!event.result) {
+          return;
+        }
+        state.run = event.result;
+        state.metadata = {
+          ...state.metadata,
+          ...extractRunMetadata(event.result)
+        };
+        patchCursorRun(event.result, state);
+      },
+      error: (event) => {
+        const state = states.get(event);
+        if (!state || !event.error) {
+          return;
+        }
+        safeLog(state.span, { error: event.error.message });
+        endOpenToolSpans(state, event.error.message);
+        state.span.end();
+        state.finalized = true;
+        states.delete(event);
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel2.unsubscribe(handlers);
+    });
+  }
+};
+function patchCursorAgentInPlace(agent) {
+  if (!agent || typeof agent !== "object") {
+    return;
+  }
+  const agentRecord = agent;
+  if (agentRecord[PATCHED_AGENT] || agentRecord[WRAPPED_AGENT] || typeof agentRecord.send !== "function") {
+    return;
+  }
+  const originalSend = agentRecord.send.bind(agentRecord);
+  try {
+    Object.defineProperty(agentRecord, PATCHED_AGENT, {
+      configurable: false,
+      enumerable: false,
+      value: true
+    });
+    Object.defineProperty(agentRecord, "send", {
+      configurable: true,
+      value(message, options) {
+        const args = [message, options];
+        return cursorSDKChannels.send.tracePromise(
+          () => originalSend(...args),
+          {
+            agent: agentRecord,
+            arguments: args,
+            operation: "send"
+          }
+        );
+      },
+      writable: true
+    });
+  } catch {
+  }
+}
+function wrapSendOptionsCallbacks(options, state) {
+  const originalOnDelta = options.onDelta;
+  const originalOnStep = options.onStep;
+  return {
+    ...options,
+    async onDelta(args) {
+      try {
+        await handleInteractionUpdate(state, args.update);
+      } catch (error) {
+        logInstrumentationError("Cursor SDK onDelta", error);
+      }
+      if (originalOnDelta) {
+        return originalOnDelta(args);
+      }
+    },
+    async onStep(args) {
+      try {
+        handleStepUpdate(state, args.step);
+      } catch (error) {
+        logInstrumentationError("Cursor SDK onStep", error);
+      }
+      if (originalOnStep) {
+        return originalOnStep(args);
+      }
+    }
+  };
+}
+function hasCursorCallbacks(options) {
+  return !!options && (typeof options.onDelta === "function" || typeof options.onStep === "function");
+}
+function patchCursorRun(run, state) {
+  if (!run || typeof run !== "object") {
+    return;
+  }
+  const runRecord = run;
+  if (runRecord[PATCHED_RUN]) {
+    return;
+  }
+  try {
+    Object.defineProperty(runRecord, PATCHED_RUN, {
+      configurable: false,
+      enumerable: false,
+      value: true
+    });
+    if (typeof runRecord.stream === "function") {
+      const originalStream = runRecord.stream.bind(runRecord);
+      Object.defineProperty(runRecord, "stream", {
+        configurable: true,
+        value() {
+          const stream = originalStream();
+          return patchCursorStream(stream, state);
+        },
+        writable: true
+      });
+    }
+    if (typeof runRecord.wait === "function") {
+      const originalWait = runRecord.wait.bind(runRecord);
+      Object.defineProperty(runRecord, "wait", {
+        configurable: true,
+        async value() {
+          try {
+            const result = await originalWait();
+            state.lastResult = result;
+            await finalizeCursorRun(state, { result });
+            return result;
+          } catch (error) {
+            await finalizeCursorRun(state, { error });
+            throw error;
+          }
+        },
+        writable: true
+      });
+    }
+    if (typeof runRecord.conversation === "function") {
+      const originalConversation = runRecord.conversation.bind(runRecord);
+      Object.defineProperty(runRecord, "conversation", {
+        configurable: true,
+        async value() {
+          try {
+            const conversation = await originalConversation();
+            await handleConversation(state, conversation);
+            await finalizeCursorRun(state);
+            return conversation;
+          } catch (error) {
+            await finalizeCursorRun(state, { error });
+            throw error;
+          }
+        },
+        writable: true
+      });
+    }
+  } catch {
+    void finalizeCursorRun(state, { output: run });
+  }
+}
+async function* patchCursorStream(stream, state) {
+  try {
+    for await (const message of stream) {
+      try {
+        await handleStreamMessage2(state, message);
+      } catch (error) {
+        logInstrumentationError("Cursor SDK stream", error);
+      }
+      yield message;
+    }
+    await finalizeCursorRun(state);
+  } catch (error) {
+    await finalizeCursorRun(state, { error });
+    throw error;
+  }
+}
+async function handleInteractionUpdate(state, update) {
+  switch (update.type) {
+    case "text-delta":
+      if (typeof update.text === "string") {
+        state.deltaText.push(update.text);
+      }
+      return;
+    case "token-delta":
+      if (typeof update.tokens === "number") {
+        state.metrics["cursor_sdk.delta_tokens"] = (state.metrics["cursor_sdk.delta_tokens"] ?? 0) + update.tokens;
+      }
+      return;
+    case "tool-call-started":
+    case "partial-tool-call":
+    case "tool-call-completed":
+      await handleToolUpdate(
+        state,
+        update
+      );
+      return;
+    case "turn-ended":
+      addUsageMetrics(
+        state.metrics,
+        update.usage
+      );
+      return;
+    case "summary":
+      if (typeof update.summary === "string") {
+        state.taskText.push(update.summary);
+      }
+      return;
+    case "step-completed":
+      if (typeof update.stepDurationMs === "number") {
+        state.metrics["cursor_sdk.step_duration_ms"] = (state.metrics["cursor_sdk.step_duration_ms"] ?? 0) + update.stepDurationMs;
+      }
+      state.metrics["cursor_sdk.steps"] = (state.metrics["cursor_sdk.steps"] ?? 0) + 1;
+      return;
+    default:
+      return;
+  }
+}
+async function handleToolUpdate(state, update) {
+  const callId = update.callId;
+  if (!callId) {
+    return;
+  }
+  const toolCall = update.toolCall;
+  const name = extractToolName(toolCall);
+  const args = extractToolArgs(toolCall);
+  const result = extractToolResult(toolCall);
+  if (update.type === "tool-call-started" || update.type === "partial-tool-call") {
+    if (!state.activeToolSpans.has(callId)) {
+      state.activeToolSpans.set(
+        callId,
+        await startToolSpan(state, {
+          args,
+          callId,
+          name,
+          status: "running",
+          toolCall
+        })
+      );
+    }
+    return;
+  }
+  const toolState = state.activeToolSpans.get(callId) ?? await startToolSpan(state, {
+    args,
+    callId,
+    name,
+    status: "completed",
+    toolCall
+  });
+  finishToolSpan(toolState, {
+    error: toolCall?.status === "error" ? stringifyUnknown(result) : void 0,
+    metadata: {
+      "cursor_sdk.tool.status": toolCall?.status ?? "completed"
+    },
+    output: result
+  });
+  state.activeToolSpans.delete(callId);
+}
+async function handleStreamMessage2(state, message) {
+  state.streamMessages.push(message);
+  if (message.type === "system") {
+    const systemMessage = message;
+    state.metadata = {
+      ...state.metadata,
+      ...extractModelMetadata(systemMessage.model),
+      ...systemMessage.agent_id ? { "cursor_sdk.agent_id": systemMessage.agent_id } : {},
+      ...systemMessage.run_id ? { "cursor_sdk.run_id": systemMessage.run_id } : {},
+      ...systemMessage.tools ? { "cursor_sdk.tools": systemMessage.tools } : {}
+    };
+    return;
+  }
+  if (message.type === "assistant") {
+    const assistantMessage = message;
+    for (const block of assistantMessage.message?.content ?? []) {
+      if (block?.type === "text" && typeof block.text === "string") {
+        state.streamText.push(block.text);
+      } else if (block?.type === "tool_use" && block.id) {
+        state.activeToolSpans.set(
+          block.id,
+          await startToolSpan(state, {
+            args: block.input,
+            callId: block.id,
+            name: block.name,
+            status: "running"
+          })
+        );
+      }
+    }
+    return;
+  }
+  if (message.type === "tool_call") {
+    await handleToolMessage(
+      state,
+      message
+    );
+    return;
+  }
+  if (message.type === "task" && typeof message.text === "string") {
+    state.taskText.push(message.text);
+    return;
+  }
+  if (message.type === "status" && message.status) {
+    state.metadata["cursor_sdk.status"] = message.status;
+  }
+}
+async function handleToolMessage(state, message) {
+  const callId = message.call_id;
+  if (!callId) {
+    return;
+  }
+  if (message.status === "running") {
+    if (!state.activeToolSpans.has(callId)) {
+      state.activeToolSpans.set(
+        callId,
+        await startToolSpan(state, {
+          args: message.args,
+          callId,
+          name: message.name,
+          status: message.status,
+          truncated: message.truncated
+        })
+      );
+    }
+    return;
+  }
+  const toolState = state.activeToolSpans.get(callId) ?? await startToolSpan(state, {
+    args: message.args,
+    callId,
+    name: message.name,
+    status: message.status,
+    truncated: message.truncated
+  });
+  finishToolSpan(toolState, {
+    error: message.status === "error" ? stringifyUnknown(message.result) : void 0,
+    metadata: {
+      "cursor_sdk.tool.status": message.status
+    },
+    output: message.result
+  });
+  state.activeToolSpans.delete(callId);
+}
+async function handleConversation(state, turns) {
+  state.conversationOutput = turns;
+  for (const turn of turns) {
+    if (turn.type === "agentConversationTurn") {
+      for (const step of turn.turn?.steps ?? []) {
+        await handleConversationStep(state, step);
+      }
+    } else if (turn.type === "shellConversationTurn") {
+      const command = turn.turn?.shellCommand?.command;
+      if (command) {
+        const callId = `shell:${state.activeToolSpans.size}:${command}`;
+        const toolState = await startToolSpan(state, {
+          args: turn.turn?.shellCommand,
+          callId,
+          name: "shell",
+          status: "completed"
+        });
+        finishToolSpan(toolState, {
+          metadata: { "cursor_sdk.tool.status": "completed" },
+          output: turn.turn?.shellOutput
+        });
+      }
+    }
+  }
+}
+async function handleConversationStep(state, step) {
+  if (step.type === "assistantMessage" && typeof step.message?.text === "string") {
+    state.conversationText.push(step.message.text);
+    return;
+  }
+  if (step.type !== "toolCall") {
+    return;
+  }
+  const toolCall = step.message;
+  const callId = typeof toolCall?.callId === "string" ? toolCall.callId : `conversation-tool:${state.activeToolSpans.size}`;
+  const toolState = await startToolSpan(state, {
+    args: extractToolArgs(toolCall),
+    callId,
+    name: extractToolName(toolCall),
+    status: toolCall?.status,
+    toolCall
+  });
+  finishToolSpan(toolState, {
+    error: toolCall?.status === "error" ? stringifyUnknown(toolCall.result) : void 0,
+    metadata: {
+      "cursor_sdk.tool.status": toolCall?.status ?? "completed"
+    },
+    output: extractToolResult(toolCall)
+  });
+}
+function handleStepUpdate(state, step) {
+  state.metrics["cursor_sdk.steps"] = (state.metrics["cursor_sdk.steps"] ?? 0) + 1;
+  if (step.type) {
+    const stepTypes = state.metadata["cursor_sdk.step_types"];
+    if (Array.isArray(stepTypes)) {
+      if (!stepTypes.includes(step.type)) {
+        stepTypes.push(step.type);
+      }
+    } else {
+      state.metadata["cursor_sdk.step_types"] = [step.type];
+    }
+  }
+  if (step.type === "assistantMessage" && typeof step.message?.text === "string") {
+    state.stepText.push(step.message.text);
+  }
+}
+async function startToolSpan(state, args) {
+  const name = args.name || "unknown";
+  const metadata = {
+    "cursor_sdk.tool.status": args.status,
+    "gen_ai.tool.call.id": args.callId,
+    "gen_ai.tool.name": name
+  };
+  if (args.truncated?.args !== void 0) {
+    metadata["cursor_sdk.tool.args_truncated"] = args.truncated.args;
+  }
+  if (args.truncated?.result !== void 0) {
+    metadata["cursor_sdk.tool.result_truncated"] = args.truncated.result;
+  }
+  const span = startSpan({
+    event: {
+      input: args.args,
+      metadata
+    },
+    name: `tool: ${name}`,
+    parent: await state.span.export(),
+    spanAttributes: { type: "tool" /* TOOL */ }
+  });
+  let subAgentSpan;
+  if (isSubAgentToolName(name)) {
+    subAgentSpan = startSpan({
+      event: {
+        input: args.args,
+        metadata: {
+          "cursor_sdk.subagent.tool_call_id": args.callId,
+          "gen_ai.tool.name": name
+        }
+      },
+      name: formatSubAgentSpanName2(args.toolCall, args.args),
+      parent: await span.export(),
+      spanAttributes: { type: "task" /* TASK */ }
+    });
+  }
+  return { span, subAgentSpan };
+}
+function finishToolSpan(toolState, result) {
+  try {
+    if (result.error) {
+      safeLog(toolState.span, {
+        error: result.error,
+        metadata: result.metadata,
+        output: result.output
+      });
+      if (toolState.subAgentSpan) {
+        safeLog(toolState.subAgentSpan, {
+          error: result.error,
+          metadata: result.metadata,
+          output: result.output
+        });
+      }
+    } else {
+      safeLog(toolState.span, {
+        metadata: result.metadata,
+        output: result.output
+      });
+      if (toolState.subAgentSpan) {
+        safeLog(toolState.subAgentSpan, {
+          metadata: result.metadata,
+          output: result.output
+        });
+      }
+    }
+  } finally {
+    toolState.subAgentSpan?.end();
+    toolState.span.end();
+  }
+}
+async function finalizeCursorRun(state, params = {}) {
+  if (state.finalized) {
+    return;
+  }
+  state.finalized = true;
+  const error = params.error;
+  const result = params.result ?? state.lastResult;
+  const output = params.output ?? result?.result ?? state.run?.result ?? (state.conversationText.length > 0 ? state.conversationText.join("\n") : void 0) ?? state.conversationOutput ?? (state.streamText.length > 0 ? state.streamText.join("") : void 0) ?? (state.deltaText.length > 0 ? state.deltaText.join("") : void 0) ?? (state.stepText.length > 0 ? state.stepText.join("\n") : void 0) ?? (state.taskText.length > 0 ? state.taskText.join("\n") : void 0);
+  try {
+    const metadata = {
+      ...state.metadata,
+      ...state.run ? extractRunMetadata(state.run) : {},
+      ...result ? extractRunResultMetadata(result) : {}
+    };
+    if (error) {
+      safeLog(state.span, {
+        error: error instanceof Error ? error.message : String(error),
+        metadata,
+        metrics: {
+          ...cleanMetrics(state.metrics),
+          ...buildDurationMetrics(state.startTime)
+        },
+        output
+      });
+    } else {
+      safeLog(state.span, {
+        metadata,
+        metrics: {
+          ...cleanMetrics(state.metrics),
+          ...buildDurationMetrics(state.startTime)
+        },
+        output
+      });
+    }
+  } finally {
+    endOpenToolSpans(state);
+    state.span.end();
+  }
+}
+function endOpenToolSpans(state, error) {
+  for (const [, toolState] of state.activeToolSpans) {
+    finishToolSpan(toolState, { error });
+  }
+  state.activeToolSpans.clear();
+}
+function sanitizeUserMessage(message) {
+  if (typeof message === "string" || message === void 0) {
+    return message;
+  }
+  return {
+    ...message,
+    images: message.images?.map((image) => {
+      const imageRecord = image;
+      return {
+        ...typeof imageRecord.url === "string" ? { url: imageRecord.url } : {},
+        ...typeof imageRecord.mimeType === "string" ? { mimeType: imageRecord.mimeType } : {},
+        ...image.dimension ? { dimension: image.dimension } : {},
+        hasData: typeof imageRecord.data === "string"
+      };
+    })
+  };
+}
+function extractAgentOptionsMetadata(options) {
+  if (!options) {
+    return {};
+  }
+  return {
+    ...extractModelMetadata(options.model),
+    ...options.agentId ? { "cursor_sdk.agent_id": options.agentId } : {},
+    ...options.name ? { "cursor_sdk.agent_name": options.name } : {},
+    ...options.local ? {
+      "cursor_sdk.runtime": "local",
+      "cursor_sdk.local.cwd": Array.isArray(options.local.cwd) ? options.local.cwd.join(",") : options.local.cwd
+    } : {},
+    ...options.cloud ? {
+      "cursor_sdk.runtime": "cloud",
+      "cursor_sdk.cloud.auto_create_pr": options.cloud.autoCreatePR,
+      "cursor_sdk.cloud.env_type": options.cloud.env?.type,
+      "cursor_sdk.cloud.env_name": options.cloud.env?.name,
+      "cursor_sdk.cloud.repos": options.cloud.repos?.map((repo) => repo.url).filter((url) => typeof url === "string")
+    } : {}
+  };
+}
+function extractSendMetadata(options) {
+  if (!options) {
+    return {};
+  }
+  return {
+    ...extractModelMetadata(options.model),
+    ...options.local?.force !== void 0 ? { "cursor_sdk.local.force": options.local.force } : {}
+  };
+}
+function extractAgentMetadata(agent) {
+  return {
+    ...agent.agentId ? { "cursor_sdk.agent_id": agent.agentId } : {},
+    ...extractModelMetadata(agent.model)
+  };
+}
+function extractRunMetadata(run) {
+  if (!run) {
+    return {};
+  }
+  return {
+    ...run.id ? { "cursor_sdk.run_id": run.id } : {},
+    ...run.agentId ? { "cursor_sdk.agent_id": run.agentId } : {},
+    ...run.status ? { "cursor_sdk.status": run.status } : {},
+    ...run.durationMs !== void 0 ? { "cursor_sdk.duration_ms": run.durationMs } : {},
+    ...extractModelMetadata(run.model),
+    ...extractGitMetadata(run.git)
+  };
+}
+function extractRunResultMetadata(result) {
+  if (!result) {
+    return {};
+  }
+  return {
+    ...result.id ? { "cursor_sdk.run_id": result.id } : {},
+    ...result.status ? { "cursor_sdk.status": result.status } : {},
+    ...result.durationMs !== void 0 ? { "cursor_sdk.duration_ms": result.durationMs } : {},
+    ...extractModelMetadata(result.model),
+    ...extractGitMetadata(result.git)
+  };
+}
+function extractGitMetadata(git) {
+  const branches = git?.branches;
+  if (!branches || branches.length === 0) {
+    return {};
+  }
+  return {
+    "cursor_sdk.git.branches": branches.map((branch) => ({
+      branch: branch.branch,
+      prUrl: branch.prUrl,
+      repoUrl: branch.repoUrl
+    }))
+  };
+}
+function extractModelMetadata(model) {
+  if (!model?.id) {
+    return {};
+  }
+  return {
+    model: model.id,
+    "cursor_sdk.model": model.id,
+    ...model.params ? { "cursor_sdk.model.params": model.params } : {}
+  };
+}
+function addUsageMetrics(metrics, usage) {
+  if (!usage) {
+    return;
+  }
+  if (usage.inputTokens !== void 0) {
+    metrics.prompt_tokens = (metrics.prompt_tokens ?? 0) + usage.inputTokens;
+  }
+  if (usage.outputTokens !== void 0) {
+    metrics.completion_tokens = (metrics.completion_tokens ?? 0) + usage.outputTokens;
+  }
+  if (usage.cacheReadTokens !== void 0) {
+    metrics.prompt_cached_tokens = (metrics.prompt_cached_tokens ?? 0) + usage.cacheReadTokens;
+  }
+  if (usage.cacheWriteTokens !== void 0) {
+    metrics.prompt_cache_creation_tokens = (metrics.prompt_cache_creation_tokens ?? 0) + usage.cacheWriteTokens;
+  }
+  metrics.tokens = (metrics.prompt_tokens ?? 0) + (metrics.completion_tokens ?? 0) + (metrics.prompt_cached_tokens ?? 0) + (metrics.prompt_cache_creation_tokens ?? 0);
+}
+function buildDurationMetrics(startTime) {
+  const end = getCurrentUnixTimestamp();
+  return {
+    duration: end - startTime,
+    end,
+    start: startTime
+  };
+}
+function extractToolName(toolCall) {
+  if (!toolCall) {
+    return "unknown";
+  }
+  if (typeof toolCall.name === "string") {
+    return toolCall.name;
+  }
+  if (typeof toolCall.type === "string") {
+    return toolCall.type;
+  }
+  return "unknown";
+}
+function extractToolArgs(toolCall) {
+  return toolCall && "args" in toolCall ? toolCall.args : void 0;
+}
+function extractToolResult(toolCall) {
+  return toolCall && "result" in toolCall ? toolCall.result : void 0;
+}
+function isSubAgentToolName(name) {
+  return name === "Agent" || name === "Task" || name === "task";
+}
+function formatSubAgentSpanName2(toolCall, args) {
+  const details = toolCall ?? args;
+  const description = getString(details, "description") ?? getString(details, "subagent_type") ?? getString(details, "type") ?? getString(details, "name");
+  return description ? `Agent: ${description}` : "Agent: sub-agent";
+}
+function getString(obj, key) {
+  const value = obj?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function stringifyUnknown(value) {
+  if (value instanceof Error) {
+    return value.message;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function safeLog(span, event) {
+  try {
+    span.log(event);
+  } catch (error) {
+    logInstrumentationError("Cursor SDK span log", error);
+  }
+}
+function logInstrumentationError(context, error) {
+  debugLogger.error(`Error processing ${context}:`, error);
+}
+function cleanMetrics(metrics) {
+  const cleaned = {};
+  for (const [key, value] of Object.entries(metrics)) {
+    if (value !== void 0 && Number.isFinite(value)) {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}
+
+// src/instrumentation/plugins/google-genai-channels.ts
+var googleGenAIChannels = defineChannels("@google/genai", {
+  generateContent: channel({
+    channelName: "models.generateContent",
+    kind: "async"
+  }),
+  generateContentStream: channel({
+    channelName: "models.generateContentStream",
+    kind: "async"
+  }),
+  embedContent: channel({
+    channelName: "models.embedContent",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/google-genai-plugin.ts
+var GOOGLE_GENAI_INTERNAL_CONTEXT = {
+  caller_filename: "<node-internal>",
+  caller_functionname: "<node-internal>",
+  caller_lineno: 0
+};
+function createWrapperParityEvent(args) {
+  return {
+    context: GOOGLE_GENAI_INTERNAL_CONTEXT,
+    input: args.input,
+    metadata: args.metadata
+  };
+}
+var GoogleGenAIPlugin = class extends BasePlugin {
+  onEnable() {
+    this.subscribeToGoogleGenAIChannels();
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+  subscribeToGoogleGenAIChannels() {
+    this.subscribeToGenerateContentChannel();
+    this.subscribeToGenerateContentStreamChannel();
+    this.subscribeToEmbedContentChannel();
+  }
+  subscribeToGenerateContentChannel() {
+    const tracingChannel2 = googleGenAIChannels.generateContent.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const unbindCurrentSpanStore = bindCurrentSpanStoreToStart2(
+      tracingChannel2,
+      states,
+      (event) => {
+        const params = event.arguments[0];
+        const input = serializeGenerateContentInput(params);
+        const metadata = extractGenerateContentMetadata(params);
+        const span = startSpan({
+          name: "generate_content",
+          spanAttributes: {
+            type: "llm" /* LLM */
+          },
           event: createWrapperParityEvent({ input, metadata })
         });
         return {
@@ -15351,7 +16633,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
           const responseMetadata = extractResponseMetadata(event.result);
           spanState.span.log({
             ...responseMetadata ? { metadata: responseMetadata } : {},
-            metrics: cleanMetrics(
+            metrics: cleanMetrics2(
               extractGenerateContentMetrics(
                 event.result,
                 spanState.startTime
@@ -15452,7 +16734,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
           const output = summarizeEmbedContentOutput(event.result);
           spanState.span.log({
             ...output ? { output } : {},
-            metrics: cleanMetrics(
+            metrics: cleanMetrics2(
               extractEmbedContentMetrics(event.result, spanState.startTime)
             )
           });
@@ -15549,7 +16831,7 @@ function patchGoogleGenAIStreamingResult(args) {
       );
       span.log({
         ...responseMetadata ? { metadata: responseMetadata } : {},
-        metrics: cleanMetrics(metricsWithoutEnd),
+        metrics: cleanMetrics2(metricsWithoutEnd),
         output: options.result.aggregated
       });
       span.end(typeof end === "number" ? { endTime: end } : void 0);
@@ -15974,7 +17256,7 @@ function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
   }
   return { aggregated, metrics };
 }
-function cleanMetrics(metrics) {
+function cleanMetrics2(metrics) {
   const cleaned = {};
   for (const [key, value] of Object.entries(metrics)) {
     if (value !== null && value !== void 0) {
@@ -16058,6 +17340,8 @@ var REQUEST_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
   "stop",
   "stream",
   "temperature",
+  "tool_choice",
+  "tools",
   "top_p"
 ]);
 var RESPONSE_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
@@ -16320,7 +17604,10 @@ function aggregateChatCompletionChunks2(chunks) {
   for (const chunk of chunks) {
     for (const choice of chunk.choices ?? []) {
       const index = typeof choice.index === "number" ? choice.index : 0;
-      const existing = aggregatedChoices.get(index) ?? { content: "" };
+      const existing = aggregatedChoices.get(index) ?? {
+        content: "",
+        toolCallsByIndex: /* @__PURE__ */ new Map()
+      };
       const delta = isObject(choice.delta) ? choice.delta : void 0;
       const message = isObject(choice.message) ? choice.message : void 0;
       if (typeof delta?.content === "string") {
@@ -16336,6 +17623,10 @@ function aggregateChatCompletionChunks2(chunks) {
       if (choice.finish_reason !== void 0) {
         existing.finish_reason = choice.finish_reason;
       }
+      const toolCallDeltas = getChatToolCallDeltas(delta) ?? getChatToolCallDeltas(message);
+      if (toolCallDeltas) {
+        mergeChatToolCallDeltas(existing.toolCallsByIndex, toolCallDeltas);
+      }
       aggregatedChoices.set(index, existing);
     }
   }
@@ -16344,12 +17635,72 @@ function aggregateChatCompletionChunks2(chunks) {
       index,
       message: {
         content: choice.content,
-        role: choice.role ?? "assistant"
+        role: choice.role ?? "assistant",
+        ...choice.toolCallsByIndex.size > 0 ? {
+          tool_calls: [...choice.toolCallsByIndex.entries()].sort(([leftIndex], [rightIndex]) => leftIndex - rightIndex).map(([, toolCall]) => toolCall)
+        } : {}
       },
       ...choice.finish_reason !== void 0 ? { finish_reason: choice.finish_reason } : {}
     }))
   };
 }
+function getChatToolCallDeltas(value) {
+  if (!Array.isArray(value?.tool_calls)) {
+    return void 0;
+  }
+  const toolCalls = value.tool_calls.filter((toolCall) => isObject(toolCall));
+  return toolCalls.length > 0 ? toolCalls : void 0;
+}
+function mergeChatToolCallDeltas(toolCallsByIndex, toolCallDeltas) {
+  for (const toolDelta of toolCallDeltas) {
+    const toolIndex = typeof toolDelta.index === "number" && toolDelta.index >= 0 ? toolDelta.index : 0;
+    const existing = toolCallsByIndex.get(toolIndex);
+    if (!existing) {
+      toolCallsByIndex.set(toolIndex, createChatToolCall(toolDelta));
+      continue;
+    }
+    mergeChatToolCall(existing, toolDelta);
+  }
+}
+function createChatToolCall(toolDelta) {
+  const toolFunction = isObject(toolDelta.function) ? toolDelta.function : {};
+  const toolCallFunction = {
+    arguments: typeof toolFunction.arguments === "string" ? toolFunction.arguments : ""
+  };
+  if (typeof toolFunction.name === "string") {
+    toolCallFunction.name = toolFunction.name;
+  }
+  const toolCall = {
+    function: toolCallFunction
+  };
+  if (typeof toolDelta.id === "string") {
+    toolCall.id = toolDelta.id;
+  }
+  if (typeof toolDelta.type === "string") {
+    toolCall.type = toolDelta.type;
+  }
+  return toolCall;
+}
+function mergeChatToolCall(existing, toolDelta) {
+  const currentFunction = isObject(existing.function) ? existing.function : {};
+  const deltaFunction = isObject(toolDelta.function) ? toolDelta.function : {};
+  const currentArguments = typeof currentFunction.arguments === "string" ? currentFunction.arguments : "";
+  const deltaArguments = typeof deltaFunction.arguments === "string" ? deltaFunction.arguments : "";
+  if (typeof toolDelta.id === "string" && typeof existing.id !== "string") {
+    existing.id = toolDelta.id;
+  }
+  if (typeof toolDelta.type === "string" && typeof existing.type !== "string") {
+    existing.type = toolDelta.type;
+  }
+  const nextFunction = {
+    ...currentFunction,
+    arguments: `${currentArguments}${deltaArguments}`
+  };
+  if (typeof deltaFunction.name === "string" && typeof currentFunction.name !== "string") {
+    nextFunction.name = deltaFunction.name;
+  }
+  existing.function = nextFunction;
+}
 function aggregateTextGenerationStreamChunks(chunks) {
   if (chunks.length === 0) {
     return void 0;
@@ -18394,6 +19745,8 @@ var MISTRAL_REQUEST_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
   "presence_penalty",
   "randomSeed",
   "random_seed",
+  "reasoningEffort",
+  "reasoning_effort",
   "responseFormat",
   "response_format",
   "safePrompt",
@@ -18517,22 +19870,114 @@ function extractMistralStreamingMetrics(result, startTime) {
   if (startTime) {
     metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
   }
-  return metrics;
+  return metrics;
+}
+function extractDeltaText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  const textParts = content.map((part) => {
+    if (!isObject(part) || part.type !== "text") {
+      return "";
+    }
+    return typeof part.text === "string" ? part.text : "";
+  }).filter((part) => part.length > 0);
+  return textParts.length > 0 ? textParts.join("") : void 0;
+}
+function normalizeMistralTextContentPart(part) {
+  if (!isObject(part) || part.type !== "text" || typeof part.text !== "string") {
+    return void 0;
+  }
+  return {
+    type: "text",
+    text: part.text
+  };
+}
+function normalizeMistralThinkingContentPart(part) {
+  if (!isObject(part) || part.type !== "thinking") {
+    return void 0;
+  }
+  const thinking = Array.isArray(part.thinking) ? part.thinking.map((thinkingPart) => normalizeMistralTextContentPart(thinkingPart)).filter(
+    (thinkingPart) => thinkingPart !== void 0 && typeof thinkingPart.text === "string"
+  ) : [];
+  return {
+    type: "thinking",
+    thinking
+  };
+}
+function normalizeMistralContentParts(content) {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content.map((part) => {
+    return normalizeMistralTextContentPart(part) || normalizeMistralThinkingContentPart(part);
+  }).filter((part) => part !== void 0);
+}
+function mergeMistralTextSegments(left, right) {
+  const merged = left.map((part) => ({ ...part }));
+  for (const part of right) {
+    const lastPart = merged[merged.length - 1];
+    if (lastPart && lastPart.type === "text" && typeof lastPart.text === "string" && typeof part.text === "string") {
+      lastPart.text += part.text;
+      continue;
+    }
+    merged.push({ ...part });
+  }
+  return merged;
+}
+function mergeMistralContentParts(left, right) {
+  const merged = [...(left || []).map((part) => structuredClone(part))];
+  for (const part of right) {
+    const lastPart = merged[merged.length - 1];
+    if (part.type === "text" && lastPart?.type === "text" && typeof lastPart.text === "string" && typeof part.text === "string") {
+      lastPart.text += part.text;
+      continue;
+    }
+    if (part.type === "thinking" && lastPart?.type === "thinking" && Array.isArray(lastPart.thinking) && Array.isArray(part.thinking)) {
+      lastPart.thinking = mergeMistralTextSegments(
+        lastPart.thinking,
+        part.thinking
+      );
+      continue;
+    }
+    merged.push(structuredClone(part));
+  }
+  return merged;
 }
-function extractDeltaText(content) {
+function appendMistralContent(accumulator, content) {
   if (typeof content === "string") {
-    return content;
+    if (accumulator.contentParts) {
+      accumulator.contentParts = mergeMistralContentParts(
+        accumulator.contentParts,
+        [{ type: "text", text: content }]
+      );
+      return;
+    }
+    accumulator.content = `${accumulator.content || ""}${content}`;
+    return;
   }
-  if (!Array.isArray(content)) {
-    return void 0;
+  const normalizedContentParts = normalizeMistralContentParts(content);
+  if (normalizedContentParts.length === 0) {
+    return;
   }
-  const textParts = content.map((part) => {
-    if (!isObject(part) || part.type !== "text") {
-      return "";
+  const hasStructuredContent = normalizedContentParts.some(
+    (part) => part.type !== "text"
+  );
+  if (!accumulator.contentParts && !hasStructuredContent) {
+    const text = extractDeltaText(content);
+    if (text) {
+      accumulator.content = `${accumulator.content || ""}${text}`;
     }
-    return typeof part.text === "string" ? part.text : "";
-  }).filter((part) => part.length > 0);
-  return textParts.length > 0 ? textParts.join("") : void 0;
+    return;
+  }
+  accumulator.contentParts = mergeMistralContentParts(
+    accumulator.contentParts || (accumulator.content ? [{ type: "text", text: accumulator.content }] : []),
+    normalizedContentParts
+  );
+  delete accumulator.content;
 }
 function getDeltaToolCalls(delta) {
   const toolCalls = Array.isArray(delta.toolCalls) && delta.toolCalls || Array.isArray(delta.tool_calls) && delta.tool_calls || [];
@@ -18702,10 +20147,7 @@ function aggregateMistralStreamChunks(chunks) {
         if (!accumulator.role && typeof delta.role === "string") {
           accumulator.role = delta.role;
         }
-        const deltaText = extractDeltaText(delta.content);
-        if (deltaText) {
-          accumulator.content = `${accumulator.content || ""}${deltaText}`;
-        }
+        appendMistralContent(accumulator, delta.content);
         accumulator.toolCalls = mergeToolCallDeltas(
           accumulator.toolCalls,
           getDeltaToolCalls(delta)
@@ -18723,7 +20165,7 @@ function aggregateMistralStreamChunks(chunks) {
     index: choice.index,
     message: {
       ...choice.role ? { role: choice.role } : {},
-      content: choice.content ?? null,
+      content: choice.contentParts ?? choice.content ?? null,
       ...choice.toolCalls ? { toolCalls: choice.toolCalls } : {}
     },
     ...choice.finishReason !== void 0 ? { finishReason: choice.finishReason } : {}
@@ -18962,7 +20404,7 @@ var GoogleADKPlugin = class extends BasePlugin {
       start: (event) => {
         const req = event.arguments[0] ?? {};
         const tool = event.self;
-        const toolName = extractToolName(req, tool);
+        const toolName = extractToolName2(req, tool);
         const parentSpan = findToolParentSpan(
           req,
           this.activeAgentSpans,
@@ -19001,7 +20443,7 @@ var GoogleADKPlugin = class extends BasePlugin {
           metrics.duration = end - state.startTime;
           state.span.log({
             output: event.result,
-            metrics: cleanMetrics2(metrics)
+            metrics: cleanMetrics3(metrics)
           });
         } finally {
           state.span.end();
@@ -19220,7 +20662,7 @@ function extractToolCallId(req) {
   const toolContext = req.toolContext;
   return toolContext?.functionCallId;
 }
-function extractToolName(req, tool) {
+function extractToolName2(req, tool) {
   if (typeof tool?.name === "string" && tool.name.length > 0) {
     return tool.name;
   }
@@ -19268,7 +20710,7 @@ function finalizeRunnerSpan(state, activeRunnerSpans) {
     }
     state.span.log({
       output: lastEvent ? extractEventOutput(lastEvent) : void 0,
-      metrics: cleanMetrics2(metrics)
+      metrics: cleanMetrics3(metrics)
     });
   } finally {
     cleanupActiveRunnerSpan(state, activeRunnerSpans);
@@ -19285,7 +20727,7 @@ function finalizeAgentSpan(state, activeAgentSpans) {
     metrics.duration = end - state.startTime;
     state.span.log({
       output: lastEvent ? extractEventOutput(lastEvent) : void 0,
-      metrics: cleanMetrics2(metrics)
+      metrics: cleanMetrics3(metrics)
     });
   } finally {
     cleanupActiveAgentSpan(state, activeAgentSpans);
@@ -19371,7 +20813,7 @@ function populateUsageMetrics2(metrics, usage) {
     metrics.completion_reasoning_tokens = usage.thoughtsTokenCount;
   }
 }
-function cleanMetrics2(metrics) {
+function cleanMetrics3(metrics) {
   const cleaned = {};
   for (const [key, value] of Object.entries(metrics)) {
     if (value !== null && value !== void 0) {
@@ -19499,6 +20941,11 @@ var CHAT_REQUEST_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
   "strictTools",
   "strict_tools",
   "temperature",
+  "thinking",
+  "thinkingTokenBudget",
+  "thinkingType",
+  "thinking_token_budget",
+  "thinking_type",
   "toolChoice",
   "tool_choice"
 ]);
@@ -19719,6 +21166,11 @@ function mergeUsageMetrics(metrics, usage) {
       "tokens",
       tokenContainer.totalTokens ?? tokenContainer.total_tokens
     );
+    setMetricIfNumber(
+      metrics,
+      "reasoning_tokens",
+      tokenContainer.reasoningTokens ?? tokenContainer.reasoning_tokens ?? tokenContainer.thinkingTokens ?? tokenContainer.thinking_tokens
+    );
   }
   const billedUnits = (isObject(source.billedUnits) ? source.billedUnits : void 0) || (isObject(source.billed_units) ? source.billed_units : void 0);
   if (billedUnits) {
@@ -19799,13 +21251,87 @@ function extractV8DeltaText(chunk) {
   }
   return void 0;
 }
+function getV8ContentIndex(chunk) {
+  return typeof chunk.index === "number" ? chunk.index : 0;
+}
+function toContentBlockType(value) {
+  return value === "text" || value === "thinking" ? value : void 0;
+}
+function getOrCreateContentBlock(contentBlocksByIndex, contentBlockOrder, index) {
+  if (!contentBlockOrder.includes(index)) {
+    contentBlockOrder.push(index);
+  }
+  if (!(index in contentBlocksByIndex)) {
+    contentBlocksByIndex[index] = {
+      text: "",
+      thinking: ""
+    };
+  }
+  return contentBlocksByIndex[index];
+}
+function appendV8ContentBlock(contentBlocksByIndex, contentBlockOrder, index, content) {
+  if (typeof content === "string") {
+    const block2 = getOrCreateContentBlock(
+      contentBlocksByIndex,
+      contentBlockOrder,
+      index
+    );
+    block2.type ??= "text";
+    block2.text += content;
+    return;
+  }
+  if (!isObject(content)) {
+    return;
+  }
+  const block = getOrCreateContentBlock(
+    contentBlocksByIndex,
+    contentBlockOrder,
+    index
+  );
+  const contentType = toContentBlockType(content.type);
+  if (contentType) {
+    block.type = contentType;
+  }
+  if (typeof content.text === "string") {
+    block.type ??= "text";
+    block.text += content.text;
+  }
+  if (typeof content.thinking === "string") {
+    block.type ??= "thinking";
+    block.thinking += content.thinking;
+  }
+}
+function serializeAggregatedContentBlocks(contentBlocksByIndex, contentBlockOrder) {
+  return contentBlockOrder.sort((left, right) => left - right).flatMap((index) => {
+    const block = contentBlocksByIndex[index];
+    if (!block) {
+      return [];
+    }
+    if (block.type === "thinking" && block.thinking.length > 0) {
+      return [{ type: "thinking", thinking: block.thinking }];
+    }
+    if (block.text.length > 0) {
+      return [{ type: "text", text: block.text }];
+    }
+    if (block.thinking.length > 0) {
+      return [{ type: "thinking", thinking: block.thinking }];
+    }
+    return [];
+  });
+}
+function hasThinkingContent(contentBlocks) {
+  return contentBlocks.some((block) => block.type === "thinking");
+}
 function aggregateCohereChatStreamChunks(chunks) {
   const textDeltas = [];
+  const contentBlocksByIndex = {};
+  const contentBlockOrder = [];
   const toolCallsByIndex = {};
   const toolCallOrder = [];
   let terminalResponse;
   let role;
   let finishReason;
+  let toolPlan = "";
   let metadata = {};
   let metrics = {};
   for (const chunk of chunks) {
@@ -19863,12 +21389,36 @@ function aggregateCohereChatStreamChunks(chunks) {
       continue;
     }
     if (eventType === "content-delta") {
+      appendV8ContentBlock(
+        contentBlocksByIndex,
+        contentBlockOrder,
+        getV8ContentIndex(chunk),
+        isObject(chunk.delta) && isObject(chunk.delta.message) ? chunk.delta.message.content : void 0
+      );
       const text = extractV8DeltaText(chunk);
       if (text) {
         textDeltas.push(text);
       }
       continue;
     }
+    if (eventType === "content-start") {
+      appendV8ContentBlock(
+        contentBlocksByIndex,
+        contentBlockOrder,
+        getV8ContentIndex(chunk),
+        isObject(chunk.delta) && isObject(chunk.delta.message) ? chunk.delta.message.content : void 0
+      );
+      continue;
+    }
+    if (eventType === "tool-plan-delta") {
+      if (isObject(chunk.delta) && isObject(chunk.delta.message)) {
+        const deltaToolPlan = typeof chunk.delta.message.toolPlan === "string" ? chunk.delta.message.toolPlan : typeof chunk.delta.message.tool_plan === "string" ? chunk.delta.message.tool_plan : void 0;
+        if (deltaToolPlan) {
+          toolPlan += deltaToolPlan;
+        }
+      }
+      continue;
+    }
     if (eventType === "tool-call-start") {
       const toolCalls = isObject(chunk.delta) && isObject(chunk.delta.message) ? toToolCallArray(
         Array.isArray(chunk.delta.message.toolCalls) ? chunk.delta.message.toolCalls : chunk.delta.message.toolCalls ?? chunk.delta.message.tool_calls
@@ -19922,13 +21472,26 @@ function aggregateCohereChatStreamChunks(chunks) {
     }
   }
   const mergedToolCalls = toolCallOrder.sort((left, right) => left - right).map((index) => toolCallsByIndex[index]).filter((toolCall) => isObject(toolCall));
+  const aggregatedContentBlocks = serializeAggregatedContentBlocks(
+    contentBlocksByIndex,
+    contentBlockOrder
+  );
   let output = extractCohereChatOutput(terminalResponse);
   if (output === void 0) {
     const mergedText = textDeltas.join("");
-    if (mergedToolCalls.length > 0 || role || mergedText.length > 0) {
+    const shouldUseStructuredContent = hasThinkingContent(aggregatedContentBlocks) || toolPlan.length > 0;
+    if (shouldUseStructuredContent) {
+      output = {
+        ...role ? { role } : {},
+        ...aggregatedContentBlocks.length > 0 ? { content: aggregatedContentBlocks } : {},
+        ...toolPlan.length > 0 ? { toolPlan } : {},
+        ...mergedToolCalls.length > 0 ? { toolCalls: mergedToolCalls } : {}
+      };
+    } else if (mergedToolCalls.length > 0 || role || mergedText.length > 0 || aggregatedContentBlocks.length > 0) {
+      const textContent = mergedText.length > 0 ? mergedText : aggregatedContentBlocks[0]?.type === "text" ? aggregatedContentBlocks[0].text : void 0;
       output = {
         ...role ? { role } : {},
-        ...mergedText.length > 0 ? { content: mergedText } : {},
+        ...textContent ? { content: textContent } : {},
         ...mergedToolCalls.length > 0 ? { toolCalls: mergedToolCalls } : {}
       };
     }
@@ -19946,6 +21509,98 @@ function aggregateCohereChatStreamChunks(chunks) {
   };
 }
 
+// src/instrumentation/plugins/groq-channels.ts
+var groqChannels = defineChannels("groq-sdk", {
+  chatCompletionsCreate: channel({
+    channelName: "chat.completions.create",
+    kind: "async"
+  }),
+  embeddingsCreate: channel(
+    {
+      channelName: "embeddings.create",
+      kind: "async"
+    }
+  )
+});
+
+// src/instrumentation/plugins/groq-plugin.ts
+var GroqPlugin = class extends BasePlugin {
+  onEnable() {
+    this.unsubscribers.push(
+      traceStreamingChannel(groqChannels.chatCompletionsCreate, {
+        name: "groq.chat.completions.create",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const { messages, ...metadata } = params;
+          return {
+            input: processInputAttachments(messages),
+            metadata: { ...metadata, provider: "groq" }
+          };
+        },
+        extractOutput: (result) => result?.choices,
+        extractMetrics: (result, startTime) => {
+          const metrics = parseGroqMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateGroqChatCompletionChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(groqChannels.embeddingsCreate, {
+        name: "groq.embeddings.create",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const { input, ...metadata } = params;
+          return {
+            input,
+            metadata: { ...metadata, provider: "groq" }
+          };
+        },
+        extractOutput: (result) => {
+          const embedding = result?.data?.[0]?.embedding;
+          return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
+        },
+        extractMetrics: (result) => parseGroqMetrics(result)
+      })
+    );
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+};
+function parseGroqMetrics(result) {
+  const metrics = parseMetricsFromUsage(result?.usage);
+  const xGroq = result?.x_groq;
+  if (!xGroq || typeof xGroq !== "object") {
+    return metrics;
+  }
+  const extraUsage = "usage" in xGroq ? xGroq.usage : void 0;
+  if (!extraUsage || typeof extraUsage !== "object") {
+    return metrics;
+  }
+  const dramCachedTokens = extraUsage["dram_cached_tokens"];
+  const sramCachedTokens = extraUsage["sram_cached_tokens"];
+  return {
+    ...metrics,
+    ...typeof dramCachedTokens === "number" ? { dram_cached_tokens: dramCachedTokens } : {},
+    ...typeof sramCachedTokens === "number" ? { sram_cached_tokens: sramCachedTokens } : {}
+  };
+}
+function aggregateGroqChatCompletionChunks(chunks, streamResult, endEvent) {
+  const aggregated = aggregateChatCompletionChunks(
+    chunks,
+    streamResult,
+    endEvent
+  );
+  return {
+    metrics: aggregated.metrics,
+    output: aggregated.output
+  };
+}
+
 // src/instrumentation/braintrust-plugin.ts
 var BraintrustPlugin = class extends BasePlugin {
   config;
@@ -19953,6 +21608,7 @@ var BraintrustPlugin = class extends BasePlugin {
   anthropicPlugin = null;
   aiSDKPlugin = null;
   claudeAgentSDKPlugin = null;
+  cursorSDKPlugin = null;
   googleGenAIPlugin = null;
   huggingFacePlugin = null;
   openRouterPlugin = null;
@@ -19960,6 +21616,7 @@ var BraintrustPlugin = class extends BasePlugin {
   mistralPlugin = null;
   googleADKPlugin = null;
   coherePlugin = null;
+  groqPlugin = null;
   constructor(config = {}) {
     super();
     this.config = config;
@@ -19982,6 +21639,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.claudeAgentSDKPlugin = new ClaudeAgentSDKPlugin();
       this.claudeAgentSDKPlugin.enable();
     }
+    if (integrations.cursorSDK !== false && integrations.cursor !== false) {
+      this.cursorSDKPlugin = new CursorSDKPlugin();
+      this.cursorSDKPlugin.enable();
+    }
     if (integrations.googleGenAI !== false && integrations.google !== false) {
       this.googleGenAIPlugin = new GoogleGenAIPlugin();
       this.googleGenAIPlugin.enable();
@@ -20010,6 +21671,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.coherePlugin = new CoherePlugin();
       this.coherePlugin.enable();
     }
+    if (integrations.groq !== false) {
+      this.groqPlugin = new GroqPlugin();
+      this.groqPlugin.enable();
+    }
   }
   onDisable() {
     if (this.openaiPlugin) {
@@ -20028,6 +21693,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.claudeAgentSDKPlugin.disable();
       this.claudeAgentSDKPlugin = null;
     }
+    if (this.cursorSDKPlugin) {
+      this.cursorSDKPlugin.disable();
+      this.cursorSDKPlugin = null;
+    }
     if (this.googleGenAIPlugin) {
       this.googleGenAIPlugin.disable();
       this.googleGenAIPlugin = null;
@@ -20056,6 +21725,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.coherePlugin.disable();
       this.coherePlugin = null;
     }
+    if (this.groqPlugin) {
+      this.groqPlugin.disable();
+      this.groqPlugin = null;
+    }
   }
 };
 
@@ -20129,6 +21802,8 @@ var PluginRegistry = class {
       google: true,
       huggingface: true,
       claudeAgentSDK: true,
+      cursor: true,
+      cursorSDK: true,
       openrouter: true,
       openrouterAgent: true,
       mistral: true,
@@ -20145,7 +21820,11 @@ var PluginRegistry = class {
     if (disabledList) {
       const disabled = disabledList.split(",").map((s) => s.trim().toLowerCase()).filter((s) => s.length > 0);
       for (const sdk of disabled) {
-        integrations[sdk] = false;
+        if (sdk === "cursor-sdk") {
+          integrations.cursorSDK = false;
+        } else {
+          integrations[sdk] = false;
+        }
       }
     }
     return { integrations };
@@ -20324,8 +22003,10 @@ __export(exports_exports, {
   wrapAnthropic: () => wrapAnthropic,
   wrapClaudeAgentSDK: () => wrapClaudeAgentSDK,
   wrapCohere: () => wrapCohere,
+  wrapCursorSDK: () => wrapCursorSDK,
   wrapGoogleADK: () => wrapGoogleADK,
   wrapGoogleGenAI: () => wrapGoogleGenAI,
+  wrapGroq: () => wrapGroq,
   wrapHuggingFace: () => wrapHuggingFace,
   wrapMastraAgent: () => wrapMastraAgent,
   wrapMistral: () => wrapMistral,
@@ -21940,6 +23621,130 @@ function claudeAgentSDKProxy(sdk) {
   });
 }
 
+// src/wrappers/cursor-sdk.ts
+var WRAPPED_AGENT2 = Symbol.for("braintrust.cursor-sdk.wrapped-agent");
+function wrapCursorSDK(sdk) {
+  if (!sdk || typeof sdk !== "object") {
+    return sdk;
+  }
+  const maybeSDK = sdk;
+  if (!maybeSDK.Agent || typeof maybeSDK.Agent !== "function") {
+    console.warn("Unsupported Cursor SDK. Not wrapping.");
+    return sdk;
+  }
+  const target = isModuleNamespace2(sdk) ? Object.setPrototypeOf({}, sdk) : sdk;
+  return new Proxy(target, {
+    get(target2, prop, receiver) {
+      const value = Reflect.get(target2, prop, receiver);
+      if (prop === "Agent" && typeof value === "function") {
+        return wrapCursorAgentClass(value);
+      }
+      if (typeof value === "function") {
+        return value.bind(target2);
+      }
+      return value;
+    }
+  });
+}
+function isModuleNamespace2(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  if (obj.constructor?.name === "Module") {
+    return true;
+  }
+  const keys = Object.keys(obj);
+  if (keys.length === 0) {
+    return false;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(obj, keys[0]);
+  return descriptor ? !descriptor.configurable && !descriptor.writable : false;
+}
+function wrapCursorAgentClass(Agent) {
+  const cache = /* @__PURE__ */ new Map();
+  return new Proxy(Agent, {
+    get(target, prop, receiver) {
+      if (cache.has(prop)) {
+        return cache.get(prop);
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "create" && typeof value === "function") {
+        const wrapped = async function(options) {
+          const args = [options];
+          return cursorSDKChannels.create.tracePromise(
+            async () => wrapCursorAgent(await Reflect.apply(value, target, args)),
+            { arguments: args }
+          );
+        };
+        cache.set(prop, wrapped);
+        return wrapped;
+      }
+      if (prop === "resume" && typeof value === "function") {
+        const wrapped = async function(agentId, options) {
+          const args = [agentId, options];
+          return cursorSDKChannels.resume.tracePromise(
+            async () => wrapCursorAgent(await Reflect.apply(value, target, args)),
+            { arguments: args }
+          );
+        };
+        cache.set(prop, wrapped);
+        return wrapped;
+      }
+      if (prop === "prompt" && typeof value === "function") {
+        const wrapped = async function(message, options) {
+          const args = [message, options];
+          return cursorSDKChannels.prompt.tracePromise(
+            () => Reflect.apply(value, target, args),
+            { arguments: args }
+          );
+        };
+        cache.set(prop, wrapped);
+        return wrapped;
+      }
+      if (typeof value === "function") {
+        const bound = value.bind(target);
+        cache.set(prop, bound);
+        return bound;
+      }
+      return value;
+    }
+  });
+}
+function wrapCursorAgent(agent) {
+  if (!agent || typeof agent !== "object") {
+    return agent;
+  }
+  if (agent[WRAPPED_AGENT2]) {
+    return agent;
+  }
+  const proxy = new Proxy(agent, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_AGENT2) {
+        return true;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "send" && typeof value === "function") {
+        return function(message, options) {
+          const args = [message, options];
+          return cursorSDKChannels.send.tracePromise(
+            () => Reflect.apply(value, target, args),
+            {
+              agent: target,
+              arguments: args,
+              operation: "send"
+            }
+          );
+        };
+      }
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    }
+  });
+  return proxy;
+}
+
 // src/wrappers/google-genai.ts
 function wrapGoogleGenAI(googleGenAI) {
   if (!googleGenAI || typeof googleGenAI !== "object") {
@@ -22693,6 +24498,94 @@ function wrapRerank3(rerank) {
   });
 }
 
+// src/wrappers/groq.ts
+function wrapGroq(groq) {
+  if (isSupportedGroqClient(groq)) {
+    return groqProxy(groq);
+  }
+  console.warn("Unsupported Groq library. Not wrapping.");
+  return groq;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasFunction4(value, methodName) {
+  return isRecord3(value) && methodName in value && typeof value[methodName] === "function";
+}
+function hasChat2(value) {
+  return isRecord3(value) && isRecord3(value.completions) && hasFunction4(value.completions, "create");
+}
+function hasEmbeddings2(value) {
+  return hasFunction4(value, "create");
+}
+function isSupportedGroqClient(value) {
+  return isRecord3(value) && (value.chat !== void 0 && hasChat2(value.chat) || value.embeddings !== void 0 && hasEmbeddings2(value.embeddings));
+}
+function groqProxy(groq) {
+  const privateMethodWorkaroundCache = /* @__PURE__ */ new WeakMap();
+  const completionProxy = groq.chat?.completions ? new Proxy(groq.chat.completions, {
+    get(target, prop, receiver) {
+      if (prop === "create") {
+        return wrapChatCompletionsCreate(target.create.bind(target));
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  }) : void 0;
+  const chatProxy3 = groq.chat ? new Proxy(groq.chat, {
+    get(target, prop, receiver) {
+      if (prop === "completions") {
+        return completionProxy ?? target.completions;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  }) : void 0;
+  const embeddingsProxy3 = groq.embeddings ? new Proxy(groq.embeddings, {
+    get(target, prop, receiver) {
+      if (prop === "create") {
+        return wrapEmbeddingsCreate2(target.create.bind(target));
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  }) : void 0;
+  const topLevelProxy = new Proxy(groq, {
+    get(target, prop, receiver) {
+      switch (prop) {
+        case "chat":
+          return chatProxy3 ?? target.chat;
+        case "embeddings":
+          return embeddingsProxy3 ?? target.embeddings;
+      }
+      const value = Reflect.get(target, prop, target);
+      if (typeof value !== "function") {
+        return value;
+      }
+      const cachedValue = privateMethodWorkaroundCache.get(value);
+      if (cachedValue) {
+        return cachedValue;
+      }
+      const thisBoundValue = function(...args) {
+        const thisArg = this === topLevelProxy ? target : this;
+        const output = Reflect.apply(value, thisArg, args);
+        return output === target ? topLevelProxy : output;
+      };
+      privateMethodWorkaroundCache.set(value, thisBoundValue);
+      return thisBoundValue;
+    }
+  });
+  return topLevelProxy;
+}
+function wrapChatCompletionsCreate(create) {
+  return (request, options) => groqChannels.chatCompletionsCreate.tracePromise(
+    () => create(request, options),
+    { arguments: [request] }
+  );
+}
+function wrapEmbeddingsCreate2(create) {
+  return (request, options) => groqChannels.embeddingsCreate.tracePromise(() => create(request, options), {
+    arguments: [request]
+  });
+}
+
 // src/wrappers/vitest/context-manager.ts
 var VitestContextManager = class {
   /**
@@ -26673,8 +28566,10 @@ export {
   wrapAnthropic,
   wrapClaudeAgentSDK,
   wrapCohere,
+  wrapCursorSDK,
   wrapGoogleADK,
   wrapGoogleGenAI,
+  wrapGroq,
   wrapHuggingFace,
   wrapMastraAgent,
   wrapMistral,